homa 0.1.91__tar.gz → 0.1.94__tar.gz

{homa-0.1.91 → homa-0.1.94}/PKG-INFO

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

{homa-0.1.91 → homa-0.1.94}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "homa"
-version = "0.1.91"
+version = "0.1.94"
 description = "A curated list of machine learning and deep learning helpers."
 authors = [
   { name="Taha Shieenavaz", email="tahashieenavaz@gmail.com" },

{homa-0.1.91 → homa-0.1.94}/src/homa/activations/classes/APLU.py

@@ -1,4 +1,5 @@
 import torch
+from ...device import get_device
 
 
 class APLU(torch.nn.Module):
@@ -12,6 +13,7 @@ class APLU(torch.nn.Module):
         self.psi = None
         self.mu = None
         self._num_channels = None
+        self.device = get_device()
 
     def _initialize_parameters(self, x):
         if x.ndim < 2:
@@ -25,18 +27,23 @@ class APLU(torch.nn.Module):
         param_shape = [1] * x.ndim
         param_shape[1] = num_channels
 
-        self.alpha = torch.nn.Parameter(torch.zeros(param_shape))
-        self.beta = torch.nn.Parameter(torch.zeros(param_shape))
-        self.gamma = torch.nn.Parameter(torch.zeros(param_shape))
+        self.alpha = torch.nn.Parameter(torch.zeros(param_shape), device=device())
+        self.beta = torch.nn.Parameter(torch.zeros(param_shape), device=device())
+        self.gamma = torch.nn.Parameter(torch.zeros(param_shape), device=device())
 
-        self.xi = torch.nn.Parameter(self.max_input * torch.rand(param_shape))
-        self.psi = torch.nn.Parameter(self.max_input * torch.rand(param_shape))
-        self.mu = torch.nn.Parameter(self.max_input * torch.rand(param_shape))
+        self.xi = torch.nn.Parameter(self.max_input * torch.rand(param_shape)).to(
+            self.device
+        )
+        self.psi = torch.nn.Parameter(self.max_input * torch.rand(param_shape)).to(
+            self.device
+        )
+        self.mu = torch.nn.Parameter(self.max_input * torch.rand(param_shape)).to(
+            self.device
+        )
 
     def forward(self, x):
         if self.alpha is None:
             self._initialize_parameters(x)
-
         a = torch.relu(x)
 
         # following are called hinges
@@ -44,5 +51,4 @@ class APLU(torch.nn.Module):
         c = self.beta * torch.relu(-x + self.psi)
         d = self.gamma * torch.relu(-x + self.mu)
         z = a + b + c + d
-
         return z

{homa-0.1.91 → homa-0.1.94}/src/homa/activations/classes/GALU.py

@@ -1,4 +1,5 @@
 import torch
+from ...device import get_device
 
 
 class GALU(torch.nn.Module):
@@ -12,6 +13,7 @@ class GALU(torch.nn.Module):
         self.gamma = None
         self.delta = None
         self._num_channels = None
+        self.device = get_device()
 
     def _initialize_parameters(self, x):
         if x.ndim < 2:
@@ -23,10 +25,10 @@ class GALU(torch.nn.Module):
         self._num_channels = num_channels
         param_shape = [1] * x.ndim
         param_shape[1] = num_channels
-        self.alpha = torch.nn.Parameter(torch.zeros(param_shape))
-        self.beta = torch.nn.Parameter(torch.zeros(param_shape))
-        self.gamma = torch.nn.Parameter(torch.zeros(param_shape))
-        self.delta = torch.nn.Parameter(torch.zeros(param_shape))
+        self.alpha = torch.nn.Parameter(torch.zeros(param_shape)).to(self.device)
+        self.beta = torch.nn.Parameter(torch.zeros(param_shape)).to(self.device)
+        self.gamma = torch.nn.Parameter(torch.zeros(param_shape)).to(self.device)
+        self.delta = torch.nn.Parameter(torch.zeros(param_shape)).to(self.device)
 
     def forward(self, x):
         if self.alpha is None:

{homa-0.1.91 → homa-0.1.94}/src/homa/activations/classes/MELU.py

@@ -1,4 +1,5 @@
 import torch
+from ...device import get_device
 
 
 class MELU(torch.nn.Module):
@@ -12,6 +13,7 @@ class MELU(torch.nn.Module):
         self.xi = None
         self.psi = None
         self._initialized = False
+        self.device = get_device()
 
     def _initialize_parameters(self, X: torch.Tensor):
         if X.dim() != 4:
@@ -20,12 +22,12 @@ class MELU(torch.nn.Module):
             )
         num_channels = X.shape[1]
         shape = (1, num_channels, 1, 1)
-        self.alpha = torch.nn.Parameter(torch.zeros(shape))
-        self.beta = torch.nn.Parameter(torch.zeros(shape))
-        self.gamma = torch.nn.Parameter(torch.zeros(shape))
-        self.delta = torch.nn.Parameter(torch.zeros(shape))
-        self.xi = torch.nn.Parameter(torch.zeros(shape))
-        self.psi = torch.nn.Parameter(torch.zeros(shape))
+        self.alpha = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
+        self.beta = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
+        self.gamma = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
+        self.delta = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
+        self.xi = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
+        self.psi = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
         self._initialized = True
 
     def forward(self, X: torch.Tensor) -> torch.Tensor:

{homa-0.1.91 → homa-0.1.94}/src/homa/activations/classes/PDELU.py

@@ -1,4 +1,5 @@
 import torch
+from ...device import get_device
 
 
 class PDELU(torch.nn.Module):
@@ -12,6 +13,7 @@ class PDELU(torch.nn.Module):
         self._power_val = 1.0 / (1.0 - self.theta)
         self.alpha = torch.nn.UninitializedParameter()
         self._num_channels = None
+        self.device = get_device()
 
     def _initialize_parameters(self, x: torch.Tensor):
         if x.ndim < 2:
@@ -23,14 +25,14 @@ class PDELU(torch.nn.Module):
         self._num_channels = num_channels
         param_shape = [1] * x.ndim
         param_shape[1] = num_channels
-        init_tensor = torch.zeros(param_shape) + 0.1
-        self.alpha = torch.nn.Parameter(init_tensor)
+        init_tensor = torch.zeros(param_shape, device=self.device) + 0.1
+        self.alpha = torch.nn.Parameter(init_tensor).to(self.device)
 
     def forward(self, x: torch.Tensor):
         if self.alpha is None:
             self._initialize_parameters(x)
 
-        zero = torch.tensor(0.0, device=x.device, dtype=x.dtype)
+        zero = torch.tensor(0.0, device=self.device, dtype=x.dtype)
         positive_part = torch.relu(x)
         inner_term = torch.relu(1.0 + (1.0 - self.theta) * x)
         powered_term = torch.pow(inner_term, self._power_val)

{homa-0.1.91 → homa-0.1.94}/src/homa/activations/classes/SReLU.py

@@ -1,4 +1,5 @@
 import torch
+from ...device import get_device
 
 
 class SReLU(torch.nn.Module):
@@ -18,6 +19,7 @@ class SReLU(torch.nn.Module):
         self.beta = torch.nn.UninitializedParameter()
         self.gamma = torch.nn.UninitializedParameter()
         self.delta = torch.nn.UninitializedParameter()
+        self.device = get_device()
 
     def _initialize_parameters(self, x: torch.Tensor):
         if isinstance(self.alpha, torch.nn.UninitializedParameter):
@@ -31,14 +33,16 @@ class SReLU(torch.nn.Module):
             param_shape[1] = num_channels
             self.alpha = torch.nn.Parameter(
                 torch.full(param_shape, self.alpha_init_val)
-            )
-            self.beta = torch.nn.Parameter(torch.full(param_shape, self.beta_init_val))
+            ).to(self.device)
+            self.beta = torch.nn.Parameter(
+                torch.full(param_shape, self.beta_init_val)
+            ).to(self.device)
             self.gamma = torch.nn.Parameter(
                 torch.full(param_shape, self.gamma_init_val)
-            )
+            ).to(self.device)
             self.delta = torch.nn.Parameter(
                 torch.full(param_shape, self.delta_init_val)
-            )
+            ).to(self.device)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         self._initialize_parameters(x)

{homa-0.1.91 → homa-0.1.94}/src/homa/activations/classes/SmallGALU.py

@@ -1,4 +1,5 @@
 import torch
+from ...device import get_device
 
 
 class SmallGALU(torch.nn.Module):
@@ -10,6 +11,7 @@ class SmallGALU(torch.nn.Module):
         self.alpha = None
         self.beta = None
         self._num_channels = None
+        self.device = get_device()
 
     def _initialize_parameters(self, x):
         if x.ndim < 2:
@@ -21,8 +23,8 @@ class SmallGALU(torch.nn.Module):
         self._num_channels = num_channels
         param_shape = [1] * x.ndim
         param_shape[1] = num_channels
-        self.alpha = torch.nn.Parameter(torch.zeros(param_shape))
-        self.beta = torch.nn.Parameter(torch.zeros(param_shape))
+        self.alpha = torch.nn.Parameter(torch.zeros(param_shape)).to(self.device)
+        self.beta = torch.nn.Parameter(torch.zeros(param_shape)).to(self.device)
 
     def forward(self, x):
         if self.alpha is None:

{homa-0.1.91 → homa-0.1.94}/src/homa/activations/classes/WideMELU.py

@@ -1,4 +1,5 @@
 import torch
+from ...device import get_device
 
 
 class WideMELU(torch.nn.Module):
@@ -14,6 +15,7 @@ class WideMELU(torch.nn.Module):
         self.theta = None
         self.lam = None
         self._initialized = False
+        self.device = get_device()
 
     def _initialize_parameters(self, X: torch.Tensor):
         if X.dim() != 4:
@@ -24,14 +26,14 @@ class WideMELU(torch.nn.Module):
         num_channels = X.shape[1]
         shape = (1, num_channels, 1, 1)
 
-        self.alpha = torch.nn.Parameter(torch.zeros(shape))
-        self.beta = torch.nn.Parameter(torch.zeros(shape))
-        self.gamma = torch.nn.Parameter(torch.zeros(shape))
-        self.delta = torch.nn.Parameter(torch.zeros(shape))
-        self.xi = torch.nn.Parameter(torch.zeros(shape))
-        self.psi = torch.nn.Parameter(torch.zeros(shape))
-        self.theta = torch.nn.Parameter(torch.zeros(shape))
-        self.lam = torch.nn.Parameter(torch.zeros(shape))
+        self.alpha = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
+        self.beta = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
+        self.gamma = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
+        self.delta = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
+        self.xi = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
+        self.psi = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
+        self.theta = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
+        self.lam = torch.nn.Parameter(torch.zeros(shape)).to(self.device)
         self._initialized = True
 
     def forward(self, X: torch.Tensor) -> torch.Tensor:

{homa-0.1.91 → homa-0.1.94}/src/homa/ensemble/concerns/CalculatesMetricNecessities.py

@@ -18,7 +18,7 @@ class CalculatesMetricNecessities:
                 model.eval()
                 logits = model(x)
                 sum_logits = logits if sum_logits is None else sum_logits + logits
-            predictions = sum_logits.argmax(dim=1)
-            predictions.extend(predictions.cpu().numpy())
+            batch_predictions = sum_logits.argmax(dim=1)
+            predictions.extend(batch_predictions.cpu().numpy())
             labels.extend(y.cpu().numpy())
         return predictions, labels

homa-0.1.94/src/homa/loss/LogitNormLoss.py

@@ -0,0 +1,12 @@
+import torch
+from .Loss import Loss
+
+
+class LogitNormLoss(Loss):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def forward(self, logits, target):
+        norms = torch.norm(logits, p=2, dim=-1, keepdim=True) + 1e-7
+        normalized_logits = torch.div(logits, norms)
+        return torch.nn.functional.cross_entropy(normalized_logits, target)

homa-0.1.94/src/homa/loss/Loss.py

@@ -0,0 +1,2 @@
+class Loss:
+    pass

homa-0.1.94/src/homa/loss/__init__.py

@@ -0,0 +1,2 @@
+from .LogitNormLoss import LogitNormLoss
+from .Loss import Loss

homa-0.1.94/src/homa/vision/StochasticResnet.py

@@ -0,0 +1,9 @@
+from .Resnet import Resnet
+from .utils import replace_relu
+from ..activations import StochasticActivation
+
+
+class StochasticResnet(Resnet):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        replace_relu(self.network, StochasticActivation)

homa-0.1.94/src/homa/vision/StochasticSwin.py

@@ -0,0 +1,9 @@
+from .Swin import Swin
+from .utils import replace_gelu
+from ..activations import StochasticActivation
+
+
+class StochasticSwin(Swin):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        replace_gelu(self.network.encoder, StochasticActivation)

homa-0.1.94/src/homa/vision/Swin.py

@@ -0,0 +1,12 @@
+import torch
+from .ClassificationModel import ClassificationModel
+from .concerns import Trainable, ReportsMetrics
+from .modules import SwinModule
+
+
+class Swin(ClassificationModel, Trainable, ReportsMetrics):
+    def __init__(self, num_classes: int, lr: float = 0.0001):
+        super().__init__()
+        self.network = SwinModule(num_classes=num_classes)
+        self.optimizer = torch.optim.AdamW(self.network.parameters(), lr=lr)
+        self.criterion = torch.nn.CrossEntropyLoss()

{homa-0.1.91 → homa-0.1.94}/src/homa/vision/__init__.py

@@ -1,3 +1,4 @@
 from .Model import Model
 from .Resnet import Resnet
 from .StochasticResnet import StochasticResnet
+from .Swin import Swin

homa-0.1.94/src/homa/vision/modules/SwinModule.py

@@ -0,0 +1,23 @@
+import torch
+from torchvision.models import swin_v2_b
+from torch.nn.init import kaiming_uniform_ as kaiming
+
+
+class SwinModule(torch.nn.Module):
+    def __init__(self, num_classes: int):
+        super().__init__()
+        self.num_classes = num_classes
+        self._create_encoder()
+        self._create_fc()
+
+    def _create_encoder(self):
+        self.encoder = swin_v2_b(weights="DEFAULT")
+        self.encoder.head = torch.nn.Identity()
+
+    def _create_fc(self):
+        self.fc = torch.nn.Linear(1024, self.num_classes)
+        kaiming(self.fc.weight, mode="fan_in", nonlinearity="relu")
+
+    def forward(self, images: torch.Tensor):
+        features = self.encoder(images)
+        return self.fc(features)

homa-0.1.94/src/homa/vision/modules/__init__.py

@@ -0,0 +1,2 @@
+from .ResnetModule import ResnetModule
+from .SwinModule import SwinModule

{homa-0.1.91 → homa-0.1.94}/src/homa.egg-info/PKG-INFO

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

{homa-0.1.91 → homa-0.1.94}/src/homa.egg-info/SOURCES.txt

@@ -37,12 +37,17 @@ src/homa/ensemble/concerns/ReportsLogits.py
 src/homa/ensemble/concerns/ReportsSize.py
 src/homa/ensemble/concerns/StoresModels.py
 src/homa/ensemble/concerns/__init__.py
+src/homa/loss/LogitNormLoss.py
+src/homa/loss/Loss.py
+src/homa/loss/__init__.py
 src/homa/torch/__init__.py
 src/homa/torch/helpers.py
 src/homa/vision/ClassificationModel.py
 src/homa/vision/Model.py
 src/homa/vision/Resnet.py
 src/homa/vision/StochasticResnet.py
+src/homa/vision/StochasticSwin.py
+src/homa/vision/Swin.py
 src/homa/vision/__init__.py
 src/homa/vision/utils.py
 src/homa/vision/concerns/HasLabels.py
@@ -53,5 +58,5 @@ src/homa/vision/concerns/ReportsMetrics.py
 src/homa/vision/concerns/Trainable.py
 src/homa/vision/concerns/__init__.py
 src/homa/vision/modules/ResnetModule.py
-src/homa/vision/modules/StochasticResnetModule.py
+src/homa/vision/modules/SwinModule.py
 src/homa/vision/modules/__init__.py

homa-0.1.91/src/homa/vision/StochasticResnet.py

@@ -1,8 +0,0 @@
-from .modules import StochasticResnetModule
-from .Resnet import Resnet
-
-
-class StochasticResnet(Resnet):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.model = StochasticResnetModule(kwargs["num_classes"])

homa-0.1.91/src/homa/vision/modules/StochasticResnetModule.py

@@ -1,9 +0,0 @@
-from .ResnetModule import ResnetModule
-from ..utils import replace_relu
-from ...activations import StochasticActivation
-
-
-class StochasticResnetModule(ResnetModule):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        replace_relu(self, StochasticActivation)

homa-0.1.91/src/homa/vision/modules/__init__.py

@@ -1,2 +0,0 @@
-from .ResnetModule import ResnetModule
-from .StochasticResnetModule import StochasticResnetModule