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

homa/rl/diayn/Discriminator.py

@@ -0,0 +1,45 @@
+import torch
+import numpy
+from .modules import DiscriminatorModule
+from ...core.concerns import MovesNetworkToDevice
+
+
+class Discriminator(MovesNetworkToDevice):
+    def __init__(
+        self,
+        state_dimension: int,
+        hidden_dimension: int,
+        num_skills: int,
+        decay: float,
+        lr: float,
+    ):
+        self.num_skills: int = num_skills
+        self.network = DiscriminatorModule(
+            state_dimension=state_dimension,
+            hidden_dimension=hidden_dimension,
+            num_skills=num_skills,
+        )
+        self.optimizer = torch.optim.AdamW(
+            self.network.parameters(), lr=lr, weight_decay=decay
+        )
+        self.criterion = torch.nn.CrossEntropyLoss()
+
+    def loss(self, states: torch.Tensor, skills_indices: torch.Tensor):
+        logits = self.network(states)
+        return self.criterion(logits, skills_indices)
+
+    @torch.no_grad()
+    def reward(self, state: torch.Tensor, skill_index: torch.Tensor):
+        logits = self.network(state)
+        probabilities = torch.nn.functional.log_softmax(logits, dim=-1)
+        entropy = numpy.log(1.0 / self.num_skills)
+        if skill_index.dim() == 1:
+            skill_index = skill_index.unsqueeze(-1)
+        reward = probabilities.gather(1, skill_index.long()) - entropy
+        return reward.squeeze(-1)
+
+    def train(self, states: torch.Tensor, skills_indices: torch.Tensor):
+        self.optimizer.zero_grad()
+        loss = self.loss(states=states, skills_indices=skills_indices)
+        loss.backward()
+        self.optimizer.step()

homa/rl/diayn/__init__.py

@@ -0,0 +1,3 @@
+from .Actor import Actor
+from .Critic import Critic
+from .Discriminator import Discriminator

homa/rl/diayn/modules/ContinuousActorModule.py

@@ -0,0 +1,42 @@
+import torch
+
+
+class ContinuousActorModule(torch.nn.Module):
+    def __init__(
+        self,
+        state_dimension: int,
+        action_dimension: int,
+        hidden_dimension: int,
+        num_skills: int,
+        min_std: float,
+        max_std: float,
+    ):
+        super().__init__()
+        self.state_dimension: int = state_dimension
+        self.action_dimension: int = action_dimension
+        self.num_skills: int = num_skills
+        self.hidden_dimension: int = hidden_dimension
+        self.input_dimension: int = self.state_dimension + self.num_skills
+        self.min_std: float = min_std
+        self.max_std: float = max_std
+
+        self.phi = torch.nn.Sequential(
+            torch.nn.Linear(self.input_dimension, self.hidden_dimension),
+            torch.nn.ReLU(),
+            torch.nn.Linear(self.hidden_dimension, self.hidden_dimension),
+            torch.nn.ReLU(),
+            torch.nn.Linear(self.hidden_dimension, self.hidden_dimension),
+        )
+
+        self.mu = torch.nn.Linear(self.hidden_dimension, self.action_dimension)
+        self.xi = torch.nn.Linear(self.hidden_dimension, self.action_dimension)
+
+    def forward(self, state: torch.Tensor, skill: torch.Tensor) -> torch.Tensor:
+        # fix the size to be one state per batch
+        state = state.view(state.size(0), -1)
+
+        psi = torch.cat([state, skill], dim=-1)
+        features = self.phi(psi)
+        mean = self.mu(features)
+        std = self.xi(features).clamp(self.min_std, self.max_std)
+        return mean, std

homa/rl/diayn/modules/CriticModule.py

@@ -0,0 +1,28 @@
+import torch
+
+
+class CriticModule(torch.nn.Module):
+    def __init__(
+        self,
+        state_dimension: int,
+        hidden_dimension: int,
+        num_skills: int,
+    ):
+        super().__init__()
+        self.state_dimension: int = state_dimension
+        self.num_skills: int = num_skills
+        self.hidden_dimension: int = hidden_dimension
+        self.input_dimension: int = self.state_dimension + self.num_skills
+
+        self.phi = torch.nn.Sequential(
+            torch.nn.Linear(self.input_dimension, self.hidden_dimension),
+            torch.nn.ReLU(),
+            torch.nn.Linear(self.hidden_dimension, self.hidden_dimension),
+            torch.nn.ReLU(),
+        )
+        self.fc = (torch.nn.Linear(self.hidden_dimension, 1),)
+
+    def forward(self, state: torch.Tensor, skill: torch.Tensor) -> torch.Tensor:
+        psi = torch.cat([state, skill], dim=-1)
+        features = self.phi(psi)
+        return self.fc(features).squeeze(-1)

homa/rl/diayn/modules/DiscriminatorModule.py

@@ -0,0 +1,24 @@
+import torch
+from typing import Type
+
+
+class DiscriminatorModule(torch.nn.Module):
+    def __init__(self, state_dimension: int, hidden_dimension: int, num_skills: int):
+        super().__init__()
+        self.state_dimension: int = state_dimension
+        self.hidden_dimension: int = hidden_dimension
+        self.num_skills: int = num_skills
+
+        self.phi: Type[torch.nn.Sequential] = torch.nn.Sequential(
+            torch.nn.Linear(self.state_dimension, self.hidden_dimension),
+            torch.nn.ReLU(),
+            torch.nn.Linear(self.hidden_dimension, self.hidden_dimension),
+            torch.nn.ReLU(),
+        )
+        self.fc: Type[torch.nn.Linear] = torch.nn.Linear(
+            self.hidden_dimension, self.num_skills
+        )
+
+    def forward(self, state: torch.Tensor) -> torch.Tensor:
+        features: torch.Tensor = self.phi(state)
+        return self.fc(features)

homa/rl/diayn/modules/__init__.py

@@ -0,0 +1,3 @@
+from .DiscriminatorModule import DiscriminatorModule
+from .CriticModule import CriticModule
+from .ContinuousActorModule import ContinuousActorModule

homa/rl/sac/SoftActor.py

@@ -0,0 +1,69 @@
+import torch
+import numpy
+from .modules import SoftActorModule
+
+
+class SoftActor:
+    def __init__(
+        self,
+        state_dimension: int,
+        hidden_dimension: int,
+        action_dimension: int,
+        lr: float,
+        weight_decay: float,
+        alpha: float,
+        min_std: float,
+        max_std: float,
+    ):
+        self.alpha: float = alpha
+
+        self.network = SoftActorModule(
+            state_dimension=state_dimension,
+            hidden_dimension=hidden_dimension,
+            action_dimension=action_dimension,
+            min_std=min_std,
+            max_std=max_std,
+        )
+        self.optimizer = torch.optim.AdamW(
+            self.network.parameters(), lr=lr, weight_decay=weight_decay
+        )
+
+    def train(self, states: torch.Tensor, critic_network: torch.nn.Module):
+        self.optimizer.zero_grad()
+        loss = self.loss(states=states, critic_network=critic_network)
+        loss.backward()
+        self.optimizer.step()
+
+    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 = 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)
+
+        if state.ndim < 2:
+            state = state.unsqueeze(0)
+
+        return state
+
+    def sample(self, state: numpy.ndarray | torch.Tensor):
+        state = self.process_state(state)
+
+        mean, std = self.network(state)
+        # following line prevents standard deviations to be negative
+        std = std.exp()
+
+        distribution = torch.distributions.Normal(mean, std)
+
+        pre_tanh = distribution.rsample()
+        action = torch.tanh(pre_tanh)
+
+        probabilities = distribution.log_prob(pre_tanh).sum(dim=1, keepdim=True)
+        correction = torch.log(1 - action.pow(2) + 1e-6).sum(dim=1, keepdim=True)
+
+        return action, probabilities - correction

homa/rl/sac/SoftCritic.py

@@ -0,0 +1,100 @@
+import torch
+from torch.nn.functional import mse_loss as mse
+from typing import Type
+from .modules import DualSoftCriticModule
+from .SoftActor import SoftActor
+
+
+class SoftCritic:
+    def __init__(
+        self,
+        state_dimension: int,
+        hidden_dimension: int,
+        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
+
+        self.network = DualSoftCriticModule(
+            state_dimension=state_dimension,
+            hidden_dimension=hidden_dimension,
+            action_dimension=action_dimension,
+        )
+        self.target = DualSoftCriticModule(
+            state_dimension=state_dimension,
+            hidden_dimension=hidden_dimension,
+            action_dimension=action_dimension,
+        )
+        self.optimizer = torch.optim.AdamW(
+            self.network.parameters(), lr=lr, weight_decay=weight_decay
+        )
+
+    def train(
+        self,
+        states: torch.Tensor,
+        actions: torch.Tensor,
+        rewards: torch.Tensor,
+        terminations: torch.Tensor,
+        next_states: torch.Tensor,
+        actor: torch.nn.Module,
+    ):
+        self.optimizer.zero_grad()
+        loss = self.loss(
+            states=states,
+            actions=actions,
+            rewards=rewards,
+            terminations=terminations,
+            next_states=next_states,
+            actor=actor,
+        )
+        loss.backward()
+        self.optimizer.step()
+
+    def loss(
+        self,
+        states: torch.Tensor,
+        actions: torch.Tensor,
+        rewards: torch.Tensor,
+        terminations: torch.Tensor,
+        next_states: torch.Tensor,
+        actor: torch.nn.Module,
+    ):
+        q_alpha, q_beta = self.target(states, actions)
+        target = self.calculate_target(
+            rewards=rewards,
+            terminations=terminations,
+            next_states=next_states,
+            actor=actor,
+        )
+        return mse(q_alpha, target) + mse(q_beta, target)
+
+    @torch.no_grad()
+    def calculate_target(
+        self,
+        rewards: torch.Tensor,
+        terminations: torch.Tensor,
+        next_states: torch.Tensor,
+        actor: SoftActor,
+    ):
+        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)
+        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):
+        self.soft_update(self.network.alpha, self.target.alpha)
+        self.soft_update(self.network.beta, self.target.beta)

homa/rl/sac/__init__.py

@@ -0,0 +1,2 @@
+from .SoftActor import SoftActor
+from .SoftCritic import SoftCritic

homa/rl/sac/modules/DualSoftCriticModule.py

@@ -0,0 +1,22 @@
+import torch
+from .SoftCriticModule import SoftCriticModule
+
+
+class DualSoftCriticModule(torch.nn.Module):
+    def __init__(
+        self, state_dimension: int, hidden_dimension: int, action_dimension: int
+    ):
+        super().__init__()
+        self.alpha = SoftCriticModule(
+            state_dimension=state_dimension,
+            hidden_dimension=hidden_dimension,
+            action_dimension=action_dimension,
+        )
+        self.beta = SoftCriticModule(
+            state_dimension=state_dimension,
+            hidden_dimension=hidden_dimension,
+            action_dimension=action_dimension,
+        )
+
+    def forward(self, state: torch.Tensor, action: torch.Tensor):
+        return self.alpha(state, action), self.beta(state, action)

homa/rl/sac/modules/SoftActorModule.py

@@ -0,0 +1,35 @@
+import torch
+
+
+class SoftActorModule(torch.nn.Module):
+    def __init__(
+        self,
+        state_dimension: int,
+        hidden_dimension: int,
+        action_dimension: int,
+        min_std: float,
+        max_std: float,
+    ):
+        super().__init__()
+
+        self.state_dimension: int = state_dimension
+        self.hidden_dimension: int = hidden_dimension
+        self.action_dimension: int = action_dimension
+        self.min_std: float = float(min_std)
+        self.max_std: float = float(max_std)
+
+        self.phi = torch.nn.Sequential(
+            torch.nn.Linear(self.state_dimension, self.hidden_dimension),
+            torch.nn.ReLU(),
+            torch.nn.Linear(self.hidden_dimension, self.hidden_dimension),
+            torch.nn.ReLU(),
+        )
+        self.mu = torch.nn.Linear(self.hidden_dimension, self.action_dimension)
+        self.xi = torch.nn.Linear(self.hidden_dimension, self.action_dimension)
+
+    def forward(self, state: torch.Tensor):
+        features = self.phi(state)
+        mean = self.mu(features)
+        std = self.mu(features)
+        std = std.clamp(self.min_std, self.max_std)
+        return mean, std

homa/rl/sac/modules/SoftCriticModule.py

@@ -0,0 +1,30 @@
+import torch
+
+
+class SoftCriticModule(torch.nn.Module):
+    def __init__(
+        self,
+        state_dimension: int,
+        hidden_dimension: int,
+        action_dimension: int,
+    ):
+        super().__init__()
+
+        self.state_dimension: int = state_dimension
+        self.action_dimension: int = action_dimension
+        self.hidden_dimension: int = hidden_dimension
+
+        self.phi = torch.nn.Sequential(
+            torch.nn.Linear(
+                self.state_dimension + self.action_dimension, self.hidden_dimension
+            ),
+            torch.nn.ReLU(),
+            torch.nn.Linear(self.hidden_dimension, self.hidden_dimension),
+            torch.nn.ReLU(),
+        )
+        self.fc = torch.nn.Linear(self.hidden_dimension, 1)
+
+    def forward(self, state: torch.Tensor, action: torch.Tensor):
+        psi = torch.cat([state, action], dim=1)
+        features = self.phi(psi)
+        return self.fc(features)

homa/rl/sac/modules/__init__.py

@@ -0,0 +1,3 @@
+from .SoftActorModule import SoftActorModule
+from .SoftCriticModule import SoftCriticModule
+from .DualSoftCriticModule import DualSoftCriticModule

homa/vision/Resnet.py

@@ -2,12 +2,12 @@ import torch
 from .modules import ResnetModule
 from .Classifier import Classifier
 from .concerns import Trainable, ReportsMetrics
-from ..device import get_device
+from ..core.concerns import MovesNetworkToDevice
 
 
-class Resnet(Classifier, Trainable, ReportsMetrics):
+class Resnet(Classifier, Trainable, ReportsMetrics, MovesNetworkToDevice):
     def __init__(self, num_classes: int, lr: float = 0.001):
         super().__init__()
-        self.network = ResnetModule(num_classes).to(get_device())
+        self.network = ResnetModule(num_classes)
         self.criterion = torch.nn.CrossEntropyLoss()
         self.optimizer = torch.optim.SGD(self.network.parameters(), lr=lr, momentum=0.9)

homa/vision/Swin.py

@@ -2,12 +2,24 @@ import torch
 from .Classifier import Classifier
 from .concerns import Trainable, ReportsMetrics
 from .modules import SwinModule
-from ..device import get_device
+from ..core.concerns import MovesNetworkToDevice
 
 
-class Swin(Classifier, Trainable, ReportsMetrics):
-    def __init__(self, num_classes: int, lr: float = 0.0001):
+class Swin(Classifier, Trainable, ReportsMetrics, MovesNetworkToDevice):
+    def __init__(
+        self,
+        num_classes: int,
+        lr: float = 0.0001,
+        decay: float = 0.0,
+        variant: str = "base",
+        weights="DEFAULT",
+    ):
         super().__init__()
-        self.network = SwinModule(num_classes=num_classes).to(get_device())
-        self.optimizer = torch.optim.AdamW(self.network.parameters(), lr=lr)
+        self.num_classes = num_classes
+        self.network = SwinModule(
+            num_classes=self.num_classes, variant=variant, weights=weights
+        )
+        self.optimizer = torch.optim.AdamW(
+            self.network.parameters(), lr=lr, weight_decay=decay
+        )
         self.criterion = torch.nn.CrossEntropyLoss()

homa/vision/modules/SwinModule.py

@@ -1,21 +1,29 @@
 import torch
-from torchvision.models import swin_v2_b
+from torchvision.models import swin_v2_b, swin_v2_s, swin_v2_t
 from torch.nn.init import kaiming_uniform_ as kaiming
 
 
 class SwinModule(torch.nn.Module):
-    def __init__(self, num_classes: int):
+    def __init__(self, num_classes: int, variant: str, weights):
         super().__init__()
-        self.num_classes = num_classes
-        self._create_encoder()
-        self._create_fc()
+        self._create_encoder(variant=variant, weights=weights)
+        self._create_fc(num_classes=num_classes)
 
-    def _create_encoder(self):
-        self.encoder = swin_v2_b(weights="DEFAULT")
+    def variant_instance(self, variant: str):
+        variant_map = {"tiny": swin_v2_t, "small": swin_v2_s, "base": swin_v2_b}
+        return variant_map.get(variant)
+
+    def _create_encoder(self, variant: str, weights):
+        if variant not in ["tiny", "small", "base"]:
+            raise ValueError(
+                f"Swin variant needs to be one of [tiny, small, base]. Invalid {variant} was provided."
+            )
+        instance = self.variant_instnace(variant)
+        self.encoder = instance(weights=weights)
         self.encoder.head = torch.nn.Identity()
 
-    def _create_fc(self):
-        self.fc = torch.nn.Linear(1024, self.num_classes)
+    def _create_fc(self, num_classes: int):
+        self.fc = torch.nn.Linear(1024, num_classes)
         kaiming(self.fc.weight, mode="fan_in", nonlinearity="relu")
 
     def forward(self, images: torch.Tensor):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: homa
-Version: 0.2.95
+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.2.95.dist-info → homa-0.3.11.dist-info}/RECORD

@@ -1,5 +1,5 @@
 homa/__init__.py,sha256=NBYFKizG8UASiz5HLsEBqzXNGlWr78xm4sLr5hxKvjU,46
-homa/device.py,sha256=9kKXfpYfnEk2cFQWPfcJrVloHgC_SSbP4I8IRY9TYk4,343
+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
@@ -71,29 +71,65 @@ homa/cli/Commands/__init__.py,sha256=PYKkcG06R5LqLnp2x8otuimzRpL4oMbziL3xEMkCffc
 homa/cli/namespaces/CacheNamespace.py,sha256=QXGljzj287stzTx0y_MXnqvCgPLqd7WjSPop2WDe14E,784
 homa/cli/namespaces/MakeNamespace.py,sha256=5G6LHk3lDkXROz7uq4jYE0DyO_V7JvnhJ33IFCiqYro,590
 homa/cli/namespaces/__init__.py,sha256=zAKUGPH4wcacxfH5Qvidp-uOuHdfzhan6kvVI6eMKA8,84
-homa/ensemble/Ensemble.py,sha256=GNkXEV7Nli8lHSTQ3qTTCTeSBwST1PLZS5wxpKpeC5U,290
+homa/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+homa/core/concerns/MovesNetworkToDevice.py,sha256=OPMvO7scsM6NNy_fM0cJdkRdoVc-b2j6l4bz88cBif0,348
+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=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/ReportsLogits.py,sha256=vTGuC9NR4rno3Mkbm0MhL8f7YopuCErGyjIorxamKTM,461
-homa/ensemble/concerns/ReportsSize.py,sha256=S7lo_Wu6rDnuqyAcv6AI6jspaBhcpfsirpp9RVD8c20,238
-homa/ensemble/concerns/StoresModels.py,sha256=tfql0sr_Y27cHEJxZkc9AUQYlQRe0HtbN4JD940lKqY,1001
-homa/ensemble/concerns/__init__.py,sha256=X0F_b2Jsv0XpiNhYwJsl-dfPsBOdEeW53LQPE4xQD0w,479
+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
+homa/graph/modules/GraphAttentionHeadModule.py,sha256=R47ScMnOgpRLNR9encaqbM8tFiYfb2UA2X18f55NMek,1397
+homa/graph/modules/MultiHeadGraphAttentionModule.py,sha256=tmxCGLxIVlvn_mvnPsqT8zrSCH_UVEIMLkR9VHky670,792
+homa/graph/modules/__init__.py,sha256=R-wuNFJvRZ8U-6v7GNGrigxPfh1BlupVZo-MPd0HiR8,136
 homa/loss/LogitNormLoss.py,sha256=LJMzRA1WoJ7aDYTV-FYGhgo8DMkcpv7e8_74qiJ4zT8,386
-homa/loss/Loss.py,sha256=COUr_idShYgAP8xKCxcaXbyUyAoJg7IOON0ARTQykmQ,21
+homa/loss/Loss.py,sha256=OROjusRHg4F3PA92SjU1utCgS1D_5KqELlcVFhvQOoU,53
 homa/loss/__init__.py,sha256=4mPVzme2_-M64bgBu1cANIfBFAL0voa5I71-ceMr_qk,64
-homa/torch/__init__.py,sha256=HTxCVaw1TLgpHMH8guB3hHYQ80cX6_fSEoPT_hz2Y8w,23
-homa/torch/helpers.py,sha256=CLbTCXRrroM0n4PfM-K_xFavs4dCZJEu_L7hdgb1DCI,134
+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=N8EsiYbsLH-dpT2EmqdYFG9KvHNfO3JX8SG2LPTy94s,1962
+homa/rl/__init__.py,sha256=EaNDkIzLH1Oy0Wc0aAyyVs4HVMcZS1tdHDh631LKSXs,146
+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=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
+homa/rl/buffers/concerns/__init__.py,sha256=g9EKH503NhO0clJhxRMFD-upSw1nkzjKLCxH4SVE-wk,104
+homa/rl/diayn/Actor.py,sha256=SYh1gKQ6DgKFYYPq0BEV10B1QVNQw6bDk08GmdwazNc,1868
+homa/rl/diayn/Critic.py,sha256=ML2FQj6dH8gJakDHlDQRCOChUA2z4pPDM52zCrp_6xk,1188
+homa/rl/diayn/Discriminator.py,sha256=m2faov_tZned7Tcogci5X_prHmncqyqPuPrm3xWZWIo,1566
+homa/rl/diayn/__init__.py,sha256=HV0LWJ-FbTPNf3kBH_GFWoxUGFwvsi6SrHRsz7QRYVQ,93
+homa/rl/diayn/modules/ContinuousActorModule.py,sha256=yeC117I5gkXZSidQhjwakjiY7Gi8ycZQeGDq8uzKlDI,1522
+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=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=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
 homa/vision/Model.py,sha256=JIeVpHJwirHfsDfYYbLsu0kt7bGf4nhMQGIOagUDKw4,22
-homa/vision/Resnet.py,sha256=Uitf58bEzIKkZd-F4FTvJ8nmhoFHlzZjJTvBPXEt2Iw,513
+homa/vision/Resnet.py,sha256=BuDMMcu8J_mVlEHaMDche2mVl-SApT80OKmoDA4eAPQ,535
 homa/vision/StochasticClassifier.py,sha256=6-o0TaH4iWXiPFefL7DOdLr3ZrTnjnJ9PIgQLlygN8w,497
 homa/vision/StochasticSwin.py,sha256=FggzfaVYrP4fnjAFcdMpDozwQHc7CQhl3iRw78oQh0o,425
-homa/vision/Swin.py,sha256=W3XbfUTrjaIhMH8fI_whPP6XO9fVA2R34LlGfQ1hoyo,508
+homa/vision/Swin.py,sha256=8sNm8S3uzyTIhu6msp4hUV0dKIcTBid_EBNr7H_iK20,789
 homa/vision/__init__.py,sha256=w5OkcmdU6Ik5wHIJzeV1Z2UElQtvCsUZks1Q-xViSVg,153
 homa/vision/utils.py,sha256=WB2b7eMDaf6UO3SuS7cB6IJk-9NRQesLavuzWUZRZyg,389
 homa/vision/concerns/HasLabels.py,sha256=fM6nHLeQaEaWDlV6R8NQ5hgOSiwspPxOIwj-nvYXbP0,321
@@ -104,10 +140,10 @@ homa/vision/concerns/ReportsMetrics.py,sha256=93Hw_JBUbwfkrJNJA1xFSQ4cqRwzbSv4nP
 homa/vision/concerns/Trainable.py,sha256=SRCW3XpG9_DQgubyqhALlYDHwAWNzVVFjshUv1ecuEQ,988
 homa/vision/concerns/__init__.py,sha256=mrw1YvN-GpQPvMwDF00KxnFkksPKo23RWM4KRioURsg,234
 homa/vision/modules/ResnetModule.py,sha256=eFudBnILD6OmgQtcW_CQQ8aZ62NEa4HyZ15-lobTtt0,712
-homa/vision/modules/SwinModule.py,sha256=h7wq1YdKoN6-7C3FVFA0bpkAET_30002iTRbjZxziFQ,714
+homa/vision/modules/SwinModule.py,sha256=3ZtUcfyJt0NMGmIlGpN35MIJG9QsgcLdFniZH7NxZQo,1227
 homa/vision/modules/__init__.py,sha256=zVMYB9IAO_xZylC1-N3p8ymHgEkAE2sBbuVz8K5Y1kk,74
-homa-0.2.95.dist-info/METADATA,sha256=Tt_dtrzp2O9_bhBkhZAjId_k_kRQI6z9ze6aQJhId_s,1760
-homa-0.2.95.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-homa-0.2.95.dist-info/entry_points.txt,sha256=tJZzjs-f2QvFe3ES8Qta8IE5sAbeE8-cyZ_UtbgqG4s,51
-homa-0.2.95.dist-info/top_level.txt,sha256=tmOfy2tuaAwc3W5-i6j61_vYJsXgR4ivBWkhJ3ZtJDc,5
-homa-0.2.95.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/torch/__init__.py

@@ -1 +0,0 @@
-from .helpers import *

homa/torch/helpers.py

@@ -1,6 +0,0 @@
-import torch
-from ..device import get_device
-
-
-def tensor(*args, **kwargs):
-    return torch.tensor(*args, **kwargs).to(get_device())