homa 0.3.2__py3-none-any.whl → 0.3.11__py3-none-any.whl

homa/core/concerns/__init__.py

@@ -1,2 +1 @@
 from .MovesNetworkToDevice import MovesNetworkToDevice
-from .TracksTime import TracksTime

homa/device.py

@@ -25,6 +25,5 @@ def device():
     return get_device()
 
 
-def move(*modules):
-    for module in modules:
-        module.to(get_device())
+def move(module: torch.nn.Module):
+    module.to(get_device())

homa/ensemble/concerns/CalculatesMetricNecessities.py

@@ -3,8 +3,8 @@ from ...device import get_device
 
 
 class CalculatesMetricNecessities:
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
 
     @torch.no_grad()
     def metric_necessities(self, dataloader):

homa/ensemble/concerns/PredictsProbabilities.py

@@ -3,8 +3,8 @@ from .ReportsLogits import ReportsLogits
 
 
 class PredictsProbabilities(ReportsLogits):
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
 
     def predict(self, x: torch.Tensor) -> torch.Tensor:
         logits = self.logits(x)

homa/ensemble/concerns/ReportsClassificationMetrics.py

@@ -10,5 +10,4 @@ class ReportsClassificationMetrics(
     ReportsEnsembleF1,
     ReportsEnsembleKappa,
 ):
-    def __init__(self):
-        super().__init__()
+    pass

homa/ensemble/concerns/ReportsEnsembleAccuracy.py

@@ -3,8 +3,8 @@ from torch.utils.data import DataLoader
 
 
 class ReportsEnsembleAccuracy:
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
 
     def accuracy(self, dataloader: DataLoader) -> float:
         predictions, labels = self.metric_necessities(dataloader)

homa/ensemble/concerns/ReportsEnsembleF1.py

@@ -2,8 +2,8 @@ from sklearn.metrics import f1_score as f1
 
 
 class ReportsEnsembleF1:
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
 
     def f1(self) -> float:
         predictions, labels = self.metric_necessities()

homa/ensemble/concerns/ReportsEnsembleKappa.py

@@ -2,8 +2,8 @@ from sklearn.metrics import cohen_kappa_score as kappa
 
 
 class ReportsEnsembleKappa:
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
 
     def accuracy(self) -> float:
         predictions, labels = self.metric_necessities()

homa/ensemble/concerns/ReportsEnsembleSize.py

@@ -1,6 +1,6 @@
 class ReportsEnsembleSize:
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
 
     @property
     def size(self):

homa/ensemble/concerns/ReportsLogits.py

@@ -2,14 +2,11 @@ import torch
 
 
 class ReportsLogits:
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
 
-    def logits_average(self, x: torch.Tensor) -> torch.Tensor:
-        return self.logits_sim(x) / len(self.factories)
-
-    def logits_sum(self, x: torch.Tensor) -> torch.Tensor:
-        batch_size = x.size(0)
+    def logits(self, x: torch.Tensor) -> torch.Tensor:
+        batch_size = x.shape[0]
         logits = torch.zeros((batch_size, self.num_classes))
         for factory, weight in zip(self.factories, self.weights):
             model = factory(num_classes=self.num_classes)
@@ -17,22 +14,6 @@ class ReportsLogits:
             logits += model(x)
         return logits
 
-    def check_aggregation_strategy(self, aggregation: str):
-        if aggregation not in ["mean", "average", "sum"]:
-            raise ValueError(
-                f"Ensemble aggregation strategy must be in [mean, average, sum], but found {aggregation}."
-            )
-
-    def logits(self, x: torch.Tensor, aggregation: str = "mean") -> torch.Tensor:
-        self.check_aggregation_strategy(aggregation=aggregation)
-        logits_handlers = {
-            "mean": self.logits_average,
-            "average": self.logits_average,
-            "sum": self.logits_sum,
-        }
-        handler = logits_handlers.get(aggregation)
-        return handler(x)
-
     @torch.no_grad()
     def logits_(self, *args, **kwargs):
         return self.logits(*args, **kwargs)

homa/ensemble/concerns/SavesEnsembleModels.py

@@ -1,6 +1,6 @@
 class SavesEnsembleModels:
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
 
     def save(self):
         self.save_factories()

homa/ensemble/concerns/StoresModels.py

@@ -5,8 +5,8 @@ from ...vision import Model
 
 
 class StoresModels:
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self.factories: List[Type[torch.nn.Module]] = []
         self.weights: List[OrderedDict] = []
 

homa/rl/SoftActorCritic.py

@@ -1,15 +1,14 @@
 from .sac import SoftActor, SoftCritic
 from .buffers import SoftActorCriticBuffer
-from ..core.concerns import TracksTime
 
 
-class SoftActorCritic(TracksTime):
+class SoftActorCritic:
     def __init__(
         self,
         state_dimension: int,
         action_dimension: int,
         hidden_dimension: int = 256,
-        buffer_capacity: int = 100_000,
+        buffer_capacity: int = 1_000_000,
         batch_size: int = 256,
         actor_lr: float = 0.0002,
         critic_lr: float = 0.0003,
@@ -20,13 +19,10 @@ class SoftActorCritic(TracksTime):
         gamma: float = 0.99,
         min_std: float = -20,
         max_std: float = 2,
-        warmup: int = 20_000,
+        warmup: int = 10_000,
     ):
-        super().__init__()
-
         self.batch_size: int = batch_size
         self.warmup: int = warmup
-        self.tau: float = tau
 
         self.actor = SoftActor(
             state_dimension=state_dimension,
@@ -44,6 +40,7 @@ class SoftActorCritic(TracksTime):
             hidden_dimension=hidden_dimension,
             lr=critic_lr,
             weight_decay=critic_decay,
+            tau=tau,
             gamma=gamma,
             alpha=alpha,
         )
@@ -63,5 +60,5 @@ class SoftActorCritic(TracksTime):
             next_states=data.next_states,
             actor=self.actor,
         )
-        self.actor.train(states=data.states, critic=self.critic)
-        self.critic.update(tau=self.tau)
+        self.actor.train(states=data.states, critic_network=self.critic.network)
+        self.critic.update()

homa/rl/buffers/Buffer.py

@@ -1,12 +1,10 @@
-from collections import deque
-from typing import Type
 from .concerns import ResetsCollection, HasRecordAlternatives
 
 
 class Buffer(ResetsCollection, HasRecordAlternatives):
     def __init__(self, capacity: int):
         self.capacity: int = capacity
-        self.collection: Type[deque] = deque(maxlen=self.capacity)
+        self.reset()
 
     @property
     def size(self):

homa/rl/buffers/SoftActorCriticBuffer.py

@@ -3,7 +3,6 @@ import random
 import torch
 from types import SimpleNamespace
 from .Buffer import Buffer
-from ...device import move
 
 
 class SoftActorCriticBuffer(Buffer):
@@ -23,7 +22,7 @@ class SoftActorCriticBuffer(Buffer):
             (state, action, reward, next_state, termination, probability)
         )
 
-    def sample(self, k: int, as_tensor: bool = False, move_to_device: bool = True):
+    def sample(self, k: int, as_tensor: bool = False):
         batch = random.sample(self.collection, k)
         states, actions, rewards, next_states, terminations, probabilities = zip(*batch)
 
@@ -34,21 +33,14 @@ class SoftActorCriticBuffer(Buffer):
         terminations = numpy.array(terminations)
         probabilities = numpy.array(probabilities)
 
-        # add one dimension to both rewards and terminations
-        rewards = numpy.expand_dims(rewards, axis=-1)
-        terminations = numpy.expand_dims(terminations, axis=-1)
-
         if as_tensor:
             states = torch.from_numpy(states).float()
-            actions = torch.from_numpy(actions).float()
+            actions = torch.from_numpy(actions).long()
             rewards = torch.from_numpy(rewards).float()
             next_states = torch.from_numpy(next_states).float()
             terminations = torch.from_numpy(terminations).float()
             probabilities = torch.from_numpy(probabilities).float()
 
-            if move_to_device:
-                move(states, actions, rewards, next_states, terminations, probabilities)
-
         return SimpleNamespace(
             **{
                 "states": states,

homa/rl/sac/SoftActor.py

@@ -1,11 +1,9 @@
 import torch
 import numpy
-from .SoftCritic import SoftCritic
 from .modules import SoftActorModule
-from ...core.concerns import MovesNetworkToDevice
 
 
-class SoftActor(MovesNetworkToDevice):
+class SoftActor:
     def __init__(
         self,
         state_dimension: int,
@@ -30,22 +28,23 @@ class SoftActor(MovesNetworkToDevice):
             self.network.parameters(), lr=lr, weight_decay=weight_decay
         )
 
-    def train(self, states: torch.Tensor, critic: SoftCritic):
-        self.network.train()
+    def train(self, states: torch.Tensor, critic_network: torch.nn.Module):
         self.optimizer.zero_grad()
-        loss = self.loss(states=states, critic=critic)
+        loss = self.loss(states=states, critic_network=critic_network)
         loss.backward()
         self.optimizer.step()
 
-    def loss(self, states: torch.Tensor, critic: SoftCritic) -> torch.Tensor:
+    def loss(
+        self, states: torch.Tensor, critic_network: torch.nn.Module
+    ) -> torch.Tensor:
         actions, probabilities = self.sample(states)
-        q_alpha, q_beta = critic.network(states, actions)
+        q_alpha, q_beta = critic_network(states, actions)
         q = torch.min(q_alpha, q_beta)
         return (self.alpha * probabilities - q).mean()
 
     def process_state(self, state: numpy.ndarray | torch.Tensor) -> torch.Tensor:
         if isinstance(state, numpy.ndarray):
-            state = torch.from_numpy(state).float()
+            state = torch.from_numpy(state)
 
         if state.ndim < 2:
             state = state.unsqueeze(0)
@@ -65,6 +64,6 @@ class SoftActor(MovesNetworkToDevice):
         action = torch.tanh(pre_tanh)
 
         probabilities = distribution.log_prob(pre_tanh).sum(dim=1, keepdim=True)
-        probabilities -= torch.log(1 - action.pow(2) + 1e-6).sum(dim=1, keepdim=True)
+        correction = torch.log(1 - action.pow(2) + 1e-6).sum(dim=1, keepdim=True)
 
-        return action, probabilities
+        return action, probabilities - correction

homa/rl/sac/SoftCritic.py

@@ -1,12 +1,11 @@
 import torch
 from torch.nn.functional import mse_loss as mse
+from typing import Type
 from .modules import DualSoftCriticModule
 from .SoftActor import SoftActor
-from ..utils import soft_update
-from ...core.concerns import MovesNetworkToDevice
 
 
-class SoftCritic(MovesNetworkToDevice):
+class SoftCritic:
     def __init__(
         self,
         state_dimension: int,
@@ -14,9 +13,11 @@ class SoftCritic(MovesNetworkToDevice):
         action_dimension: int,
         lr: float,
         weight_decay: float,
+        tau: float,
         gamma: float,
         alpha: float,
     ):
+        self.tau: float = tau
         self.gamma: float = gamma
         self.alpha: float = alpha
 
@@ -30,10 +31,6 @@ class SoftCritic(MovesNetworkToDevice):
             hidden_dimension=hidden_dimension,
             action_dimension=action_dimension,
         )
-
-        # copy source to target when initiated
-        self.target.load_state_dict(self.network.state_dict())
-
         self.optimizer = torch.optim.AdamW(
             self.network.parameters(), lr=lr, weight_decay=weight_decay
         )
@@ -45,9 +42,8 @@ class SoftCritic(MovesNetworkToDevice):
         rewards: torch.Tensor,
         terminations: torch.Tensor,
         next_states: torch.Tensor,
-        actor: SoftActor,
+        actor: torch.nn.Module,
     ):
-        self.network.train()
         self.optimizer.zero_grad()
         loss = self.loss(
             states=states,
@@ -69,7 +65,7 @@ class SoftCritic(MovesNetworkToDevice):
         next_states: torch.Tensor,
         actor: torch.nn.Module,
     ):
-        q_alpha, q_beta = self.network(states, actions)
+        q_alpha, q_beta = self.target(states, actions)
         target = self.calculate_target(
             rewards=rewards,
             terminations=terminations,
@@ -86,13 +82,19 @@ class SoftCritic(MovesNetworkToDevice):
         next_states: torch.Tensor,
         actor: SoftActor,
     ):
-        termination_mask = 1 - terminations
         next_actions, next_probabilities = actor.sample(next_states)
         q_alpha, q_beta = self.target(next_states, next_actions)
         q = torch.min(q_alpha, q_beta)
-        entropy_q = q - self.alpha * next_probabilities
-        return rewards + self.gamma * termination_mask * entropy_q
+        termination_mask = 1 - terminations
+        entropy_q = q - self.alpha * next_probabilities * termination_mask
+        return rewards + self.gamma * entropy_q
+
+    def soft_update(
+        self, network: Type[torch.nn.Module], target: Type[torch.nn.Module]
+    ):
+        for s, t in zip(network.parameters(), target.parameters()):
+            t.data.copy_(self.tau * s.data + (1 - self.tau) * t.data)
 
-    def update(self, tau: float):
-        soft_update(network=self.network.alpha, target=self.target.alpha, tau=tau)
-        soft_update(network=self.network.beta, target=self.target.beta, tau=tau)
+    def update(self):
+        self.soft_update(self.network.alpha, self.target.alpha)
+        self.soft_update(self.network.beta, self.target.beta)

homa/rl/sac/modules/SoftActorModule.py

@@ -30,6 +30,6 @@ class SoftActorModule(torch.nn.Module):
     def forward(self, state: torch.Tensor):
         features = self.phi(state)
         mean = self.mu(features)
-        std = self.xi(features)
+        std = self.mu(features)
         std = std.clamp(self.min_std, self.max_std)
         return mean, std

{homa-0.3.2.dist-info → homa-0.3.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: homa
-Version: 0.3.2
+Version: 0.3.11
 Summary: A curated list of machine learning and deep learning helpers.
 Author-email: Taha Shieenavaz <tahashieenavaz@gmail.com>
 Requires-Python: >=3.7

{homa-0.3.2.dist-info → homa-0.3.11.dist-info}/RECORD

@@ -1,5 +1,5 @@
 homa/__init__.py,sha256=NBYFKizG8UASiz5HLsEBqzXNGlWr78xm4sLr5hxKvjU,46
-homa/device.py,sha256=J_XpsqXOOXG15ea_9M_W4abtr1DA7VLPFuURUa0f2Qw,424
+homa/device.py,sha256=dpKI-ah_kPgNfFH_ism8YXHndEndGngBrTVnuZZ2J2I,408
 homa/settings.py,sha256=CPZDPvs1380O7SY7FcSKol8kBVFVVYFgSJl3YEyJuZ0,263
 homa/utils.py,sha256=dPp6TItJwWxBqxmkMzUuCtX_BzdPT-kMOZyXRGVMCbQ,70
 homa/activations/APLU.py,sha256=cUf6LUjY8TewXe_V1avO_7IcOtY66Hd6Dyk_1K4R3Ms,1555
@@ -73,21 +73,20 @@ homa/cli/namespaces/MakeNamespace.py,sha256=5G6LHk3lDkXROz7uq4jYE0DyO_V7JvnhJ33I
 homa/cli/namespaces/__init__.py,sha256=zAKUGPH4wcacxfH5Qvidp-uOuHdfzhan6kvVI6eMKA8,84
 homa/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 homa/core/concerns/MovesNetworkToDevice.py,sha256=OPMvO7scsM6NNy_fM0cJdkRdoVc-b2j6l4bz88cBif0,348
-homa/core/concerns/TracksTime.py,sha256=atg7iUH5HKqKJd03s9eHsl18iUO_4fzxuYmXgNtqSBQ,129
-homa/core/concerns/__init__.py,sha256=6jL3_kiqmmMs8BV789ZBbwEYNQNAhq1otVOrDJJrSXo,90
+homa/core/concerns/__init__.py,sha256=O9OXMIMYrkIgp11lAyEv-OgT3Wq0IvNdDVZr2bOmpQU,55
 homa/ensemble/Ensemble.py,sha256=mrqwbEm8OtiBmEgKuO6RzO1V8v80vrQFIJ4WHl8Yqgk,356
 homa/ensemble/__init__.py,sha256=1pk2W-NbgfDFh9WLKZVLUk2E3PTjVZ5Bap9dQEnrs9o,31
 homa/ensemble/utils.py,sha256=nn6eAgGW7ZafjjOVJWzGUWE0XYeyJAOMNEHm-lHxd6A,200
-homa/ensemble/concerns/CalculatesMetricNecessities.py,sha256=HgrLbz8O9grGZZ0LG82Au5lZwq2D1zixDRjegM4f8Wk,793
-homa/ensemble/concerns/PredictsProbabilities.py,sha256=WWUaNXQxCJQ_NrLgeTdw0OXEsDb5xU7899_2d3Pzaoc,408
-homa/ensemble/concerns/ReportsClassificationMetrics.py,sha256=S9IBH6O7dmHhQ4Mxf5c7JFirOsPokKZUyqfOmED13mM,437
-homa/ensemble/concerns/ReportsEnsembleAccuracy.py,sha256=UuaPQ7v2sCaWuo3xa4PaTZzyjciRhcIluhnt6Zla2Fo,348
-homa/ensemble/concerns/ReportsEnsembleF1.py,sha256=aXKBK2-dTB133Rjg-X2a4Khb1sTdxuffXukcSMZlkzM,264
-homa/ensemble/concerns/ReportsEnsembleKappa.py,sha256=AkWTVGuCeIanDusNdtJOHwTgSEh5RJeWwLTQJJqSEKE,268
-homa/ensemble/concerns/ReportsEnsembleSize.py,sha256=lRyHIrK_zr7pE5RlwuNLIkqXoEMoVhNmT1nYDgCaNVI,208
-homa/ensemble/concerns/ReportsLogits.py,sha256=yZobLvxPL6ep70uMFIEtz5-l4rlfaG7m9mti6jJD1E8,1338
-homa/ensemble/concerns/SavesEnsembleModels.py,sha256=d1DcZnzfJABEfxcnYy5tV9N7YOghzO_ZdCdU80VTcno,243
-homa/ensemble/concerns/StoresModels.py,sha256=dg-xP1C4A9K8DrUTnR4VfqWU9iNAdS_0DlQcRThDka8,931
+homa/ensemble/concerns/CalculatesMetricNecessities.py,sha256=QccROg_FOp_X2T_lZDg8p1DMZhPYdO-7aEdnebRXMsY,825
+homa/ensemble/concerns/PredictsProbabilities.py,sha256=7rmI66DzE7-QGoJgZEk-9fu5YQvJW-4ZnMn_dWEEhqU,440
+homa/ensemble/concerns/ReportsClassificationMetrics.py,sha256=bg__cdCKp2U1H9qN1aOJH4BoX98oIvt8XaPDGApJhSM,395
+homa/ensemble/concerns/ReportsEnsembleAccuracy.py,sha256=AX5X3VGOm7DfdonW0N7FFgUwEr7wnsojRSVEULEii7c,380
+homa/ensemble/concerns/ReportsEnsembleF1.py,sha256=hdtdCQrWaFJNUn1KP9cAmi_q_EA4FYnpkBMlYLjzRZg,296
+homa/ensemble/concerns/ReportsEnsembleKappa.py,sha256=ZRbtrFCTD84EDql6ZL1xeWtTLFxpO5Y5tQaUlR6_0jw,300
+homa/ensemble/concerns/ReportsEnsembleSize.py,sha256=eIweQHpLcfGnNLwiMuTho-9rDgxV0xXGHPTOaEOABzw,240
+homa/ensemble/concerns/ReportsLogits.py,sha256=sJZGJwTISZo2DFmJbI5zqhrt7CblNi09iGn1zaEk-ro,593
+homa/ensemble/concerns/SavesEnsembleModels.py,sha256=VIXT9wJ8FiCspIvI2-F4WPa6mBBe9SWvMLFyad3TgRg,275
+homa/ensemble/concerns/StoresModels.py,sha256=uAYbdUtadZsAJ9-Fj4jJFLWC23qfiXKo1mBm6-PZkN4,963
 homa/ensemble/concerns/__init__.py,sha256=IF5mHIgzCuCpA2EmpkctbjAr0kYW4P96v7RffK2V_iQ,548
 homa/graph/GraphAttention.py,sha256=oPXuc1s-3BXwGkHuomEIxnOcZSRBbL8b8fO0432RdDo,478
 homa/graph/__init__.py,sha256=NCtMUB-awe9UvkwDYqWXxTAZ1RW-AwSW1DD9X_kFkD0,43
@@ -100,13 +99,12 @@ homa/loss/__init__.py,sha256=4mPVzme2_-M64bgBu1cANIfBFAL0voa5I71-ceMr_qk,64
 homa/rl/DQN.py,sha256=PaNq9Z1K87IQ7Y7mhiJ1CE4TofgV7c7m1py8qT09vE4,20
 homa/rl/DRQN.py,sha256=zooojji9aeeubOP7cRPSHg31u2Assxk-qjXyGUWIO3A,49
 homa/rl/DiversityIsAllYouNeed.py,sha256=8yKzlVdLisForGyXqxaXUAWG_dozq7dNY8MBasCvniE,3322
-homa/rl/SoftActorCritic.py,sha256=0xQcjAJQAiBsPCl8RORHz02K7tPaBWoQv45Zd12Ud6Q,2044
+homa/rl/SoftActorCritic.py,sha256=N8EsiYbsLH-dpT2EmqdYFG9KvHNfO3JX8SG2LPTy94s,1962
 homa/rl/__init__.py,sha256=EaNDkIzLH1Oy0Wc0aAyyVs4HVMcZS1tdHDh631LKSXs,146
-homa/rl/utils.py,sha256=IqbN5aDLwovocpPbxgywuetjz7GQwh9aJ4WFIOtLP3g,232
-homa/rl/buffers/Buffer.py,sha256=YCESh9tFxgWOLzGQj_IA0zLJoZWDmz6gCNu1iYsGp1s,388
+homa/rl/buffers/Buffer.py,sha256=wOk8MH0Wf0cpvavpHIK2O7PrbGP6MwHTH5YFkq2Ints,288
 homa/rl/buffers/DiversityIsAllYouNeedBuffer.py,sha256=Nwcqs3Q10x6OKZ-zWug4IcBc6RR1TwEIybuFQOtmftA,1612
 homa/rl/buffers/ImageBuffer.py,sha256=HSmMt82hmkL3ooBYo7c6YUtTsMz9TAA8CvPh3y8z3yg,65
-homa/rl/buffers/SoftActorCriticBuffer.py,sha256=N2etaAOA4xkOBdybQX6RQf-H4ivFgCKMJM5QugM9CYc,2154
+homa/rl/buffers/SoftActorCriticBuffer.py,sha256=iDC2C5XFvONT3f7YX_gYXQJGU9wz2usvPOVGbQUd22M,1796
 homa/rl/buffers/__init__.py,sha256=h1AkCHs6isXbNtxpaZfLp6YudHj1KlnOvURE64vhRa4,190
 homa/rl/buffers/concerns/HasRecordAlternatives.py,sha256=D5aVlPZlnGm0GyGtikKb4wZqyO6zpyqR1IOETmAgLx4,362
 homa/rl/buffers/concerns/ResetsCollection.py,sha256=bZ8q4czYXo1jMtVCnnlG69OgiJ0AqSGY6CiKzJC6xtQ,215
@@ -119,11 +117,11 @@ homa/rl/diayn/modules/ContinuousActorModule.py,sha256=yeC117I5gkXZSidQhjwakjiY7G
 homa/rl/diayn/modules/CriticModule.py,sha256=OUenwCG0dG4PnK7Iq-jy7oCTv_Cn9s7bXRpro6Pvb40,956
 homa/rl/diayn/modules/DiscriminatorModule.py,sha256=D58dKBv4f6gtrpqMKLK8XAZpiMqKfS4sG6s3QcF8iGE,891
 homa/rl/diayn/modules/__init__.py,sha256=1Pgjr4FT5WG-AMh26NPEfbf5pK6I02B1x8HYsgyUCJ4,149
-homa/rl/sac/SoftActor.py,sha256=fCsAp5_KxzFmGplJaiF-4Cvn5qVaKGa51gst9bzHs0w,2221
-homa/rl/sac/SoftCritic.py,sha256=OPJoYgvbyBfkPfAt6DNxFCTsNydsi2__2p_4MmWBxiA,3004
+homa/rl/sac/SoftActor.py,sha256=CxR58IFrZ6xlmBj_gq_abZfgdzlVD71c6wA6wQiVL2c,2142
+homa/rl/sac/SoftCritic.py,sha256=wFIunTgKGBy64Igu7zuvE2BvGz2e-DTplviLyq4tQ7M,3031
 homa/rl/sac/__init__.py,sha256=8EIkOcVvxN94gGzcZoX2XTnvTsHqW6yBaZ2RdFwIveM,68
 homa/rl/sac/modules/DualSoftCriticModule.py,sha256=Ax28i7U-KnP4QJig-AeeCfpPYNvTT3DfvRMJI-f-TGY,749
-homa/rl/sac/modules/SoftActorModule.py,sha256=LQ4z7s8mE3wwb1JgxPs0QvnriZULK3_ULdhkt60Ffpw,1152
+homa/rl/sac/modules/SoftActorModule.py,sha256=AiWnsWkmQONjOAWAp06eO-lLWEYNJDmx8FSjPKTcjI0,1152
 homa/rl/sac/modules/SoftCriticModule.py,sha256=aOfhDZTB5og-BLTsmdBdIcRufygCJUas7P-ikBvWQ34,928
 homa/rl/sac/modules/__init__.py,sha256=h-22B5CAK1xhn75tolI5J5sQMxl--kOXbQ6r_JfHIOA,147
 homa/vision/Classifier.py,sha256=bAypqREQVuPamnc8hpbLCwmW9Uly3T1rvrlbMxXp1eA,61
@@ -144,8 +142,8 @@ homa/vision/concerns/__init__.py,sha256=mrw1YvN-GpQPvMwDF00KxnFkksPKo23RWM4KRioU
 homa/vision/modules/ResnetModule.py,sha256=eFudBnILD6OmgQtcW_CQQ8aZ62NEa4HyZ15-lobTtt0,712
 homa/vision/modules/SwinModule.py,sha256=3ZtUcfyJt0NMGmIlGpN35MIJG9QsgcLdFniZH7NxZQo,1227
 homa/vision/modules/__init__.py,sha256=zVMYB9IAO_xZylC1-N3p8ymHgEkAE2sBbuVz8K5Y1kk,74
-homa-0.3.2.dist-info/METADATA,sha256=awU-Sftb68ejizlVGd4_otzjFwpq4EIopenhQHoHlFA,1759
-homa-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-homa-0.3.2.dist-info/entry_points.txt,sha256=tJZzjs-f2QvFe3ES8Qta8IE5sAbeE8-cyZ_UtbgqG4s,51
-homa-0.3.2.dist-info/top_level.txt,sha256=tmOfy2tuaAwc3W5-i6j61_vYJsXgR4ivBWkhJ3ZtJDc,5
-homa-0.3.2.dist-info/RECORD,,
+homa-0.3.11.dist-info/METADATA,sha256=SvSxNXB1IsX3N5IfhOsnWYtvhjpfzauJPanVH7i5cRs,1760
+homa-0.3.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+homa-0.3.11.dist-info/entry_points.txt,sha256=tJZzjs-f2QvFe3ES8Qta8IE5sAbeE8-cyZ_UtbgqG4s,51
+homa-0.3.11.dist-info/top_level.txt,sha256=tmOfy2tuaAwc3W5-i6j61_vYJsXgR4ivBWkhJ3ZtJDc,5
+homa-0.3.11.dist-info/RECORD,,

homa/core/concerns/TracksTime.py

@@ -1,7 +0,0 @@
-class TracksTime:
-    def __init__(self):
-        super().__init__()
-        self.t = 0
-
-    def tick(self):
-        self.t += 1

homa/rl/utils.py

@@ -1,7 +0,0 @@
-import torch
-
-
-@torch.no_grad()
-def soft_update(network: torch.nn.Module, target: torch.nn.Module, tau: float):
-    for s, t in zip(network.parameters(), target.parameters()):
-        t.data.copy_(tau * s.data + (1 - tau) * t.data)