archid 1.0__py3-none-any.whl

archid/__init__.py

@@ -0,0 +1,47 @@
+from .reinforcement_learning import (
+    ReinforcementLearning,
+    Experience,
+    Transition,
+    Environment,
+    Algorithm,
+    ActionBased,
+    QLearning,
+    SARSA,
+    DQN,
+    ExpectedSARSA,
+    DoubleQLearning,
+    MonteCarloControl,
+    StateBased,
+    TD,
+    ActorCritic,
+    QCritic,
+    QActorCritic,
+    VCritic,
+    PPO,
+)
+from .supervised_learning import SupervisedLearning
+import archid.supervised_learning as supervised_learning
+__all__ = [
+    "Model",
+    "ReinforcementLearning",
+    "Experience",
+    "Transition",
+    "Environment",
+    "SupervisedLearning",
+    "Algorithm",
+    "ActionBased",
+    "QLearning",
+    "SARSA",
+    "DQN",
+    "ExpectedSARSA",
+    "DoubleQLearning",
+    "MonteCarloControl",
+    "StateBased",
+    "TD",
+    "ActorCritic",
+    "QCritic",
+    "QActorCritic",
+    "VCritic",
+    "PPO",
+    "SupervisedLearning"
+]

archid/learning_methods/__init__.py

@@ -0,0 +1,4 @@
+import archid.learning_methods.evolutionary_learning.__init__ as evolutionary
+import archid.learning_methods.learning as Learning
+import archid.learning_methods.reinforcement_learning.__init__ as reinforcement
+import archid.learning_methods.supervised_learning.__init__ as supervised

archid/learning_methods/evolutionary_learning/__init__.py

@@ -0,0 +1,2 @@
+from .evolutionary_supervised.evolutionary_supervised import EvolutionarySupervisedLearning
+#from .evolutionary_reinforcement.evolutionary_reinforcement import EvolutionaryReinforcementLearning

archid/learning_methods/evolutionary_learning/evolutionary_learning.py

@@ -0,0 +1,72 @@
+from ..learning import Learning
+import copy
+import numpy as np
+
+class EvolutionaryLearning(Learning):
+    name = "Evolutionary"
+
+    def __init__(self, mutation_rate, population_size, selection_size):
+        super().__init__()
+
+        self.mutation_rate = mutation_rate
+        self.population_size = population_size
+        self.selection_size = selection_size
+
+        self.population = []
+
+    def reproduce(self):
+        new_population = []
+
+        # Keep elites unchanged
+        new_population.extend(self.population)
+
+        # Fill the rest with copies
+        while len(new_population) < self.population_size:
+            parent = np.random.choice(self.population)
+            child = copy.deepcopy(parent)
+            new_population.append(child)
+
+        self.population = new_population
+    def select(self, fitness):
+        # same for SL and RL
+        self.population = sorted(
+            self.population,
+            key=lambda x: fitness[self.population.index(x)],
+            reverse=True
+        )[:self.selection_size]
+    def initialize_population(self):
+        """
+        Creates the initial population from a starting network.
+        """
+
+        self.population = []
+
+        for _ in range(self.population_size):
+            individual = copy.deepcopy(self.network)
+            self.population.append(individual)
+
+        return self.population
+    def mutate(self):
+        for i, network in enumerate(self.population):
+
+            # Skip elites
+            if i < self.selection_size:
+                continue
+
+            for layer in network.layers:
+
+                if hasattr(layer, "weights"):
+                    weights = layer.weights.data
+
+                    mask = np.random.random(weights.shape) < self.mutation_rate
+                    noise = np.random.normal(0, 0.01, weights.shape)
+
+                    weights += mask * noise
+
+                if hasattr(layer, "bias"):
+                    bias = layer.bias.data
+
+                    mask = np.random.random(bias.shape) < self.mutation_rate
+                    noise = np.random.normal(0, 0.01, bias.shape)
+
+                    bias += mask * noise

archid/learning_methods/evolutionary_learning/evolutionary_supervised/evolutionary_supervised.py

@@ -0,0 +1,49 @@
+from ..evolutionary_learning import EvolutionaryLearning
+from euclid.core.tensor import Tensor
+
+
+class EvolutionarySupervisedLearning(EvolutionaryLearning):
+    name = "EvolutionarySupervised"
+
+    def __init__(
+        self,
+        loss,
+        mutation_rate,
+        population_size,
+        selection_size
+    ):
+        super().__init__(
+            mutation_rate,
+            population_size,
+            selection_size
+        )
+
+        self.loss = loss
+
+    def train(self, loader, epochs):
+        self.population=[]
+        self.initialize_population()
+        for epoch in range(epochs):
+
+            # Evaluate population
+            fitness = []
+
+            for network in self.population:
+                total_loss = 0
+
+                for x, y in loader:
+                    x = Tensor(x)
+                    y = Tensor(y)
+
+                    prediction = network(x)
+                    loss = self.loss(prediction, y)
+
+                    total_loss += loss.data
+
+                fitness.append(-total_loss)
+
+            # Evolution step
+            self.select(fitness)
+            self.reproduce()
+            self.mutate()
+            best_fitness = max(fitness)

archid/learning_methods/learning.py

@@ -0,0 +1,10 @@
+class Learning:
+    name = "Learning"
+
+    def __init__(self):
+        self.network = None
+
+    def attach_network(self,network):
+        self.network=network
+    def train(self, data):
+        raise NotImplementedError

archid/learning_methods/reinforcement_learning/__init__.py

@@ -0,0 +1 @@
+from .reinforcement_learning import ReinforcementLearning

archid/learning_methods/reinforcement_learning/reinforcement_learning.py

@@ -0,0 +1,45 @@
+from ..learning import Learning
+
+
+class ReinforcementLearning(Learning):
+
+    def __init__(
+        self,
+        algorithm,
+        policy,
+        optimizer
+    ):
+        super().__init__()
+
+        self.algorithm = algorithm
+        self.policy = policy
+        self.optimizer = optimizer
+    def attach_network(self, network):
+        self.optimizer.set_parameters(network.parameters())
+        return super().attach_network(network)
+    def predict(self, state):
+        return self.policy.sample_action(
+            self.network.forward(state)
+        )
+
+    def update_model(self, **data):
+        update = getattr(self.algorithm, "update", None)
+        if update is not None:
+            return update(
+                self.policy,
+                self.optimizer,
+                **data
+            )
+
+        loss = self.algorithm.compute_loss(
+            self.policy,
+            **data
+        )
+
+        self.optimizer.zero_grad()
+
+        loss.backward()
+
+        self.optimizer.step()
+
+        return loss

archid/learning_methods/supervised_learning/__init__.py

@@ -0,0 +1 @@
+from .supervised_learning import SupervisedLearning

archid/learning_methods/supervised_learning/supervised_learning.py

@@ -0,0 +1,59 @@
+from ..learning import Learning
+from euclid.core.tensor import Tensor
+
+
+class SupervisedLearning(Learning):
+
+    name = "Supervised"
+
+    def __init__(self, loss, optimizer):
+        super().__init__()
+
+        self.loss = loss
+        self.optimizer = optimizer
+
+    def attach_network(self, network):
+        self.optimizer.set_parameters(
+            network.parameters()
+        )
+        return super().attach_network(network)
+
+    def train(self, loader, steps):
+
+        for step in range(steps):
+
+            x_batch, y_batch = loader.batch()
+
+            if not isinstance(x_batch, Tensor):
+                x_batch = Tensor(x_batch)
+
+            if not isinstance(y_batch, Tensor):
+                y_batch = Tensor(y_batch)
+
+            self.optimizer.zero_grad()
+
+            prediction = self.network.forward(
+                x_batch
+            )
+
+            loss = self.loss.forward(
+                prediction,
+                y_batch
+            )
+
+
+            loss.backward()
+
+            self.optimizer.step()
+
+
+
+            print(
+                f"Step {step + 1}/{steps} | "
+                f"Loss: {float(loss.data):.6f}",
+                flush=True,
+            )            
+            del prediction
+            del loss
+            del x_batch
+            del y_batch

archid/model/__init__.py

@@ -0,0 +1 @@
+from .model import Model

archid/model/model.py

@@ -0,0 +1,15 @@
+import numpy as np 
+class Model:
+    def __init__(self,network,learning):
+        self.network=network
+        self.learning=learning
+
+        self.learning.attach_network(self.network)
+    def train(self, *args, **kwargs):
+        return self.learning.train(*args, **kwargs)
+    def predict(self,input):
+        return self.network.forward(input)
+    def eval(self):
+        self.network.eval()
+    def train_mode(self):
+        self.network.train()

archid/reinforcement_learning/__init__.py

@@ -0,0 +1,42 @@
+from .reinforcement_learning import ReinforcementLearning
+from .algorithms import (
+    Algorithm,
+    ActionBased,
+    QLearning,
+    SARSA,
+    DQN,
+    ExpectedSARSA,
+    DoubleQLearning,
+    MonteCarloControl,
+    StateBased,
+    TD,
+    ActorCritic,
+    QCritic,
+    QActorCritic,
+    VCritic,
+    PPO,
+)
+from .environment import Environment
+from .experience import Experience, Transition
+
+__all__ = [
+    "ReinforcementLearning",
+    "Experience",
+    "Transition",
+    "Environment",
+    "Algorithm",
+    "ActionBased",
+    "QLearning",
+    "SARSA",
+    "DQN",
+    "ExpectedSARSA",
+    "DoubleQLearning",
+    "MonteCarloControl",
+    "StateBased",
+    "TD",
+    "ActorCritic",
+    "QCritic",
+    "QActorCritic",
+    "VCritic",
+    "PPO",
+]

archid/reinforcement_learning/algorithms/__init__.py

@@ -0,0 +1,38 @@
+"""Reinforcement-learning algorithms."""
+
+from .algorithm import Algorithm
+
+from .action_value_based.action_based import ActionBased
+from .action_value_based.qlearning import QLearning
+from .action_value_based.sarsa import SARSA
+from .action_value_based.dqn import DQN
+from .action_value_based.expected_sarsa import ExpectedSARSA
+from .action_value_based.double_qlearning import DoubleQLearning
+from .action_value_based.monte_carlo import MonteCarloControl
+
+from .state_value_based.state_based import StateBased
+from .state_value_based.td import TD
+
+from .actor_critic.actor_critic import ActorCritic
+from .actor_critic.q_critic.q_critic import QCritic
+from .actor_critic.q_critic.q_actor_critic import QActorCritic
+from .actor_critic.v_critic.v_critic import VCritic
+from .actor_critic.v_critic.ppo import PPO
+
+__all__ = [
+    "Algorithm",
+    "ActionBased",
+    "QLearning",
+    "SARSA",
+    "DQN",
+    "ExpectedSARSA",
+    "DoubleQLearning",
+    "MonteCarloControl",
+    "StateBased",
+    "TD",
+    "ActorCritic",
+    "QCritic",
+    "QActorCritic",
+    "VCritic",
+    "PPO",
+]

archid/reinforcement_learning/algorithms/algorithm.py

@@ -0,0 +1,7 @@
+class Algorithm:
+
+    def predict(self, state):
+        raise NotImplementedError
+
+    def update(self, **data):
+        raise NotImplementedError

archid/reinforcement_learning/environment/__init__.py

@@ -0,0 +1,5 @@
+"""Environment interfaces."""
+
+from .environment import Environment
+
+__all__ = ["Environment"]

archid/reinforcement_learning/environment/environment.py

@@ -0,0 +1,39 @@
+class Environment:
+
+    name = "Environment"
+
+    def __init__(self):
+        pass
+
+
+    def reset(self):
+        """
+        Reset the environment and return the initial state.
+        """
+        raise NotImplementedError
+
+
+    def step(self, action):
+        """
+        Apply an action.
+
+        Returns:
+            next_state,
+            reward,
+            done
+        """
+        raise NotImplementedError
+
+
+    def render(self):
+        """
+        Optional visualization.
+        """
+        pass
+
+
+    def close(self):
+        """
+        Cleanup resources.
+        """
+        pass

archid/reinforcement_learning/episode/__init__.py

@@ -0,0 +1,5 @@
+"""Episode data structures."""
+
+from .episode import Episode, Step
+
+__all__ = ["Episode", "Step"]

archid/reinforcement_learning/episode/episode.py

@@ -0,0 +1,123 @@
+from euclid.settings import xp
+
+
+class Step:
+
+    def __init__(
+        self,
+        state,
+        action,
+        reward,
+        next_state,
+        done,
+        log_probability
+    ):
+
+        self.state = state
+        self.action = action
+        self.reward = reward
+        self.next_state = next_state
+        self.done = done
+
+        # Stored from behavior policy during rollout
+        self.log_probability = (log_probability)
+        self.old_log_probability = (log_probability)
+
+        self.reward_to_go = None
+        self.value = None
+        self.advantage = None
+
+
+class Episode:
+
+    def __init__(self):
+        self.steps = []
+
+
+    def add(
+        self,
+        state,
+        action,
+        reward,
+        next_state,
+        done,
+        log_probability
+    ):
+
+        self.steps.append(
+            Step(
+                state,
+                action,
+                reward,
+                next_state,
+                done,
+                log_probability
+            )
+        )
+
+
+    def discounted_returns(self, gamma):
+
+        returns = xp.empty(
+            len(self.steps),
+            dtype=xp.float32
+        )
+
+        running_return = 0.0
+
+        for index in range(len(self.steps)-1, -1, -1):
+
+            step = self.steps[index]
+
+            running_return = (
+                float(step.reward)
+                +
+                gamma *
+                running_return *
+                (not step.done)
+            )
+
+            returns[index] = running_return
+            step.reward_to_go = running_return
+
+        return returns
+
+
+    def set_advantages(
+        self,
+        gamma,
+        normalize=False
+    ):
+
+        returns = self.discounted_returns(gamma)
+
+        advantages = returns.copy()
+
+        if normalize and len(advantages) > 1:
+
+            advantages = (
+                advantages - advantages.mean()
+            ) / (
+                advantages.std() + 1e-8
+            )
+
+        for step, advantage in zip(
+            self.steps,
+            advantages
+        ):
+            step.advantage = float(advantage)
+
+        return advantages
+
+
+    def set_returns(self, gamma):
+
+        returns = self.discounted_returns(gamma)
+
+        for step, value in zip(
+            self.steps,
+            returns
+        ):
+            step.reward_to_go = float(value)
+
+        return returns

archid/reinforcement_learning/experience/__init__.py

@@ -0,0 +1 @@
+from .experience import Experience, Transition

archid/reinforcement_learning/experience/experience.py

@@ -0,0 +1,41 @@
+
+class Transition:
+
+    def __init__(
+        self,
+        state,
+        action,
+        reward,
+        next_state,
+        done,
+        next_action=None,
+        log_prob=None
+    ):
+        self.state = state
+        self.action = action
+        self.reward = reward
+        self.next_state = next_state
+        self.done = done
+        self.next_action = next_action
+        self.log_prob = log_prob
+
+
+class Experience:
+
+    def __init__(self):
+        self.transitions = []
+
+    def add(self, transition):
+        self.transitions.append(transition)
+
+    def clear(self):
+        self.transitions.clear()
+
+    def __len__(self):
+        return len(self.transitions)
+
+    def __iter__(self):
+        return iter(self.transitions)
+
+    def __getitem__(self, index):
+        return self.transitions[index]

archid/reinforcement_learning/reinforcement_learning.py

@@ -0,0 +1,185 @@
+
+
+import random
+
+from .experience import Experience, Transition
+
+
+class ReinforcementLearning:
+    """Pair an algorithm and environment, then train them with one method."""
+
+    def __init__(self, algorithm, environment):
+        self.algorithm = algorithm
+        self.environment = environment
+
+    def predict(self, state):
+        return self.algorithm.predict(state)
+
+    def _select_action(self, state, epsilon, rng):
+        if (
+            hasattr(self.algorithm, "action_value")
+            and getattr(self.algorithm, "actions", None) is not None
+        ):
+            actions = self.algorithm.available_actions(state)
+
+            if rng.random() < epsilon:
+                return rng.choice(actions)
+
+            def value(action):
+                result = self.algorithm.action_value(state, action)
+
+                if hasattr(result, "data"):
+                    return float(result.data.reshape(-1)[0])
+
+                return result
+
+            return max(actions, key=value)
+
+        return self.predict(state)
+
+    def train(
+        self,
+        episodes,
+        max_steps=None,
+        epsilon=0.1,
+        seed=None,
+    ):
+        """Train for a number of episodes.
+
+        Algorithms can specify how experience is consumed through
+        ``update_mode``:
+
+        ``"step"``
+            Update after every transition.
+
+        ``"episode"``
+            Collect the complete episode, then update once.
+
+        The default is ``"step"``.
+        """
+        if episodes < 1:
+            raise ValueError("episodes must be positive")
+
+        rng = random.Random(seed)
+        history = []
+
+        update_mode = getattr(
+            self.algorithm,
+            "update_mode",
+            "step",
+        )
+
+        if update_mode not in {"step", "episode"}:
+            raise ValueError(
+                f"Invalid update_mode: {update_mode!r}. "
+                "Expected 'step' or 'episode'."
+            )
+
+        for episode in range(episodes):
+            state = self.environment.reset()
+
+            total_reward = 0.0
+            steps = 0
+            done = False
+
+            experience = Experience()
+
+            action = self._select_action(
+                state,
+                epsilon,
+                rng,
+            )
+
+            while not done and (
+                max_steps is None or steps < max_steps
+            ):
+                next_state, reward, done = (
+                    self.environment.step(action)
+                )
+
+                steps += 1
+                total_reward += reward
+
+                next_action = (
+                    None
+                    if done
+                    else self._select_action(
+                        next_state,
+                        epsilon,
+                        rng,
+                    )
+                )
+
+                transition = Transition(
+                    state,
+                    action,
+                    reward,
+                    next_state,
+                    done,
+                    next_action,
+                )
+
+                experience.add(transition)
+
+                # TD / online algorithms learn immediately.
+                if update_mode == "step":
+                    step_experience = Experience()
+                    step_experience.add(transition)
+
+                    self.algorithm.update(
+                        step_experience
+                    )
+
+                state = next_state
+                action = next_action
+
+            # Monte Carlo and other episode-based algorithms
+            # receive the entire trajectory.
+            if update_mode == "episode":
+                self.algorithm.update(experience)
+            self.log_training(episode,reward,steps)
+            history.append({
+                "episode": episode + 1,
+                "return": total_reward,
+                "steps": steps,
+                "done": done,
+            })
+
+        return history
+
+    def run(self, steps=None):
+        """Collect one greedy episode without updating the algorithm."""
+
+        state = self.environment.reset()
+        experience = Experience()
+
+        count = 0
+        done = False
+
+        while not done and (
+            steps is None or count < steps
+        ):
+            action = self.predict(state)
+
+            next_state, reward, done = (
+                self.environment.step(action)
+            )
+
+            experience.add(
+                Transition(
+                    state,
+                    action,
+                    reward,
+                    next_state,
+                    done,
+                )
+            )
+
+            state = next_state
+            count += 1
+
+        return experience
+
+
+    def log_training(self,epoch,reward,steps):
+        pass

archid/supervised_learning/__init__.py

@@ -0,0 +1 @@
+from .supervised_learning import SupervisedLearning

archid/supervised_learning/supervised_learning.py

@@ -0,0 +1,56 @@
+from euclid.core.tensor import Tensor
+
+
+class SupervisedLearning():
+
+    name = "Supervised"
+
+    def __init__(self, loss, optimizer, network):
+
+        self.loss = loss
+        self.optimizer = optimizer
+        self.network = network
+        self.optimizer.set_parameters(network.parameters())
+
+
+
+
+    def train(self, loader, steps):
+        self.network.train()
+        for step in range(steps):
+
+            x_batch, y_batch = loader.batch()
+
+            if not isinstance(x_batch, Tensor):
+                x_batch = Tensor(x_batch)
+
+            if not isinstance(y_batch, Tensor):
+                y_batch = Tensor(y_batch)
+
+            self.optimizer.zero_grad()
+
+            prediction = self.network.forward(
+                x_batch
+            )
+
+            loss = self.loss.forward(
+                prediction,
+                y_batch
+            )
+
+
+            loss.backward()
+
+            self.optimizer.step()
+
+
+
+            self.log_training(step,loss)
+            
+            del prediction
+            del loss
+            del x_batch
+            del y_batch
+        self.network.eval()
+    def log_training(self,epoch,loss):
+        pass

archid-1.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: archid
+Version: 1.0
+Summary: A higher level deep learning framework built on Euclid
+Author: Dra3don
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: euclid-ml
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary

archid-1.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+archid/__init__.py,sha256=twWWRzexPXvYcqOvJIY-XiiNlcFT1rLnV1OF_g6Htko,865
+archid/learning_methods/__init__.py,sha256=jPL6fisGnVUBUYYkqf6S3Ea6_Dv-NLw7Xvx18UnvPOc,283
+archid/learning_methods/learning.py,sha256=5inU2NBEEkZ9_d1ot5_l4mUqWpx8DytIUtSFx5QhWVg,220
+archid/learning_methods/evolutionary_learning/__init__.py,sha256=0-GbJpR3V9hUTzaIvu9qLjho34UcE6nb0WPatWq0n0k,193
+archid/learning_methods/evolutionary_learning/evolutionary_learning.py,sha256=qXK4NJ5-OaMfaXcmRnGAtgT5bgha0D-gRPZnuhNFjXw,2151
+archid/learning_methods/evolutionary_learning/evolutionary_reinforcement/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+archid/learning_methods/evolutionary_learning/evolutionary_supervised/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+archid/learning_methods/evolutionary_learning/evolutionary_supervised/evolutionary_supervised.py,sha256=JMV6re96uSwEJOG98-Y3pdKfAdpWI8gTe1cu-ynQq80,1187
+archid/learning_methods/reinforcement_learning/__init__.py,sha256=ZIGz5SXTOt4w1hpP8-Yu3tSxugpcIgQTVcKoQb5pi_U,57
+archid/learning_methods/reinforcement_learning/reinforcement_learning.py,sha256=vidRlB4pV-BJlAiE_b2RYu-MT4ABs_RRhYRDOl6MiuI,1023
+archid/learning_methods/supervised_learning/__init__.py,sha256=y9SbZn_0ZLEpL8ih-dlnR-42nYjQEHnf9O8q49zbUbM,51
+archid/learning_methods/supervised_learning/supervised_learning.py,sha256=JffmZGEbmB3Xeh1oU4oXIVaWTz2BPZe4TNMh7rnx1HU,1295
+archid/model/__init__.py,sha256=6sCCdLLZqBnf3i0oQLvwi8gObYAvZWGJpNV9okUKwa8,24
+archid/model/model.py,sha256=Evy8JrHI837wxYJ2sg82ZTIVdFlCtC6m1mFk_VM4fFk,450
+archid/reinforcement_learning/__init__.py,sha256=_yMnkjIa51cIksgCaLeWIUEmNn3QJqZ6gzQ1LI9fu3Q,747
+archid/reinforcement_learning/reinforcement_learning.py,sha256=YtfyyqTcYSJoKoYgcR9k6JOgS8Z_QmaW06cbRzM-vjs,4765
+archid/reinforcement_learning/algorithms/__init__.py,sha256=eSIJp9rz93nTwER9cMGY--oAV8AwbYniY4EyJQfpZs4,1080
+archid/reinforcement_learning/algorithms/algorithm.py,sha256=qBFVLALo9L1j-ffKs-aACMq2WbBNIPbgrYyporY_SnU,147
+archid/reinforcement_learning/environment/__init__.py,sha256=PoCkH9ZMsqC4FXvqhOxUVXZKUAoj738u91TqQ3NuBYI,95
+archid/reinforcement_learning/environment/environment.py,sha256=GDODTYQ-s7K27NcMCBfN4VggpsX-lCKnuhqeXai92WA,595
+archid/reinforcement_learning/episode/__init__.py,sha256=Fq0sfFTjL0uqC_7f9ABNZoDPW7OFwzXkUVk6UW7NtfI,98
+archid/reinforcement_learning/episode/episode.py,sha256=AMJhsBthP_DFBahH_1CSxza4Q7byK2a_NPPEbYaivYw,2359
+archid/reinforcement_learning/experience/__init__.py,sha256=9DVdnX_i6k9b2cz_fVBLiq7Aq3dYb0t3gVHHm9Pemac,46
+archid/reinforcement_learning/experience/experience.py,sha256=2yZhPnZf1C1tM4wZ5LXPLHjZMPQU4Dq0ArrVLZ8szps,811
+archid/supervised_learning/__init__.py,sha256=y9SbZn_0ZLEpL8ih-dlnR-42nYjQEHnf9O8q49zbUbM,51
+archid/supervised_learning/supervised_learning.py,sha256=PUy9yYrxAPFITX1M8AfmqzhxqZsL-8M335st9gDC0xo,1156
+archid-1.0.dist-info/licenses/LICENSE,sha256=EeC3lqDx0EHjO0V5USy3B0pXPTpMtQi38E2a0eqbYUw,1065
+archid-1.0.dist-info/METADATA,sha256=NSb0lLhkthT51xekfAMaKuENvo4prOqBogQ8wIHdARc,274
+archid-1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+archid-1.0.dist-info/top_level.txt,sha256=PDxAiIYTvP8uluvoPjP0kL2Z0_lHr_JoQPIBHcOpU58,7
+archid-1.0.dist-info/RECORD,,

archid-1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

archid-1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dra3d30n
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

archid-1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+archid