homa 0.0.19__tar.gz

homa-0.0.19/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: homa
+Version: 0.0.19
+Summary: A curated list of machine learning and deep learning helpers.
+Author-email: Taha Shieenavaz <tahashieenavaz@gmail.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: torch
+Requires-Dist: fire
+
+## Device Management
+
+```py
+from homa import cpu, mps, cuda, device
+
+torch.tensor([1, 2, 3, 4, 5]).to(cpu())
+torch.tensor([1, 2, 3, 4, 5]).to(cuda())
+torch.tensor([1, 2, 3, 4, 5]).to(mps())
+torch.tensor([1, 2, 3, 4, 5]).to(device())
+```

homa-0.0.19/README.md

@@ -0,0 +1,10 @@
+## Device Management
+
+```py
+from homa import cpu, mps, cuda, device
+
+torch.tensor([1, 2, 3, 4, 5]).to(cpu())
+torch.tensor([1, 2, 3, 4, 5]).to(cuda())
+torch.tensor([1, 2, 3, 4, 5]).to(mps())
+torch.tensor([1, 2, 3, 4, 5]).to(device())
+```

homa-0.0.19/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "homa"
+version = "0.0.19"
+description = "A curated list of machine learning and deep learning helpers."
+authors = [
+  { name="Taha Shieenavaz", email="tahashieenavaz@gmail.com" },
+]
+readme = "README.md"
+requires-python = ">=3.7"
+
+dependencies = [
+  "numpy",
+  "torch",
+  "fire"
+]
+
+[project.scripts]
+homa = "homa.cli.HomaCommand:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"homa.cli" = ["*"]

homa-0.0.19/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

homa-0.0.19/src/homa/__init__.py

@@ -0,0 +1,2 @@
+from .device import *
+from .settings import *

homa-0.0.19/src/homa/activations/__init__.py

@@ -0,0 +1,2 @@
+from .classes import *
+from .utils import *

homa-0.0.19/src/homa/activations/classes/APLU.py

@@ -0,0 +1,48 @@
+import torch
+
+
+class APLU(torch.nn.Module):
+    def __init__(self, max_input: float = 1.0):
+        super(APLU, self).__init__()
+        self.max_input = max_input
+        self.alpha = None
+        self.beta = None
+        self.gamma = None
+        self.xi = None
+        self.psi = None
+        self.mu = None
+        self._num_channels = None
+
+    def _initialize_parameters(self, x):
+        if x.ndim < 2:
+            raise ValueError(
+                f"Input tensor must have at least 2 dimensions (N, C), but got shape {x.shape}"
+            )
+
+        num_channels = x.shape[1]
+        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.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))
+
+    def forward(self, x):
+        if self.alpha is None:
+            self._initialize_parameters(x)
+
+        a = torch.relu(x)
+
+        # following are called hinges
+        b = self.alpha * torch.relu(-x + self.xi)
+        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.0.19/src/homa/activations/classes/GALU.py

@@ -0,0 +1,51 @@
+import torch
+
+
+class GALU(torch.nn.Module):
+    def __init__(self, max_input: float = 1.0):
+        super(GALU, self).__init__()
+        if max_input <= 0:
+            raise ValueError("max_input must be positive.")
+        self.max_input = max_input
+        self.alpha = None
+        self.beta = None
+        self.gamma = None
+        self.delta = None
+        self._num_channels = None
+
+    def _initialize_parameters(self, x):
+        if x.ndim < 2:
+            raise ValueError(
+                f"Input tensor must have at least 2 dimensions (N, C), but got shape {x.shape}"
+            )
+
+        num_channels = x.shape[1]
+        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))
+
+    def forward(self, x):
+        if self.alpha is None:
+            self._initialize_parameters(x)
+
+        zero = torch.tensor(0.0, device=x.device, dtype=x.dtype)
+        x_norm = x / self.max_input
+        part_prelu = torch.relu(x_norm) + self.alpha * torch.min(x_norm, zero)
+        part_beta = self.beta * (
+            torch.relu(1.0 - torch.abs(x_norm - 1.0))
+            + torch.min(torch.abs(x_norm - 3.0) - 1.0, zero)
+        )
+        part_gamma = self.gamma * (
+            torch.relu(0.5 - torch.abs(x_norm - 0.5))
+            + torch.min(torch.abs(x_norm - 1.5) - 0.5, zero)
+        )
+        part_delta = self.delta * (
+            torch.relu(0.5 - torch.abs(x_norm - 2.5))
+            + torch.min(torch.abs(x_norm - 3.5) - 0.5, zero)
+        )
+        z = part_prelu + part_beta + part_gamma + part_delta
+        return z * self.max_input

homa-0.0.19/src/homa/activations/classes/MELU.py

@@ -0,0 +1,50 @@
+import torch
+
+
+class MELU(torch.nn.Module):
+    def __init__(self, maxInput: float = 1.0):
+        super().__init__()
+        self.maxInput = float(maxInput)
+        self.alpha = None
+        self.beta = None
+        self.gamma = None
+        self.delta = None
+        self.xi = None
+        self.psi = None
+        self._initialized = False
+
+    def _initialize_parameters(self, X: torch.Tensor):
+        if X.dim() != 4:
+            raise ValueError(
+                f"Expected 4D input (B, C, H, W), but got {X.dim()}D input."
+            )
+        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._initialized = True
+
+    def forward(self, X: torch.Tensor) -> torch.Tensor:
+        if not self._initialized:
+            self._initialize_parameters(X)
+        X_norm = X / self.maxInput
+        Y = torch.roll(X_norm, shifts=-1, dims=1)
+        term1 = torch.relu(X_norm)
+        term2 = self.alpha * torch.clamp(X_norm, max=0)
+        dist_sq_beta = (X_norm - 2) ** 2 + (Y - 2) ** 2
+        dist_sq_gamma = (X_norm - 1) ** 2 + (Y - 1) ** 2
+        dist_sq_delta = (X_norm - 1) ** 2 + (Y - 3) ** 2
+        dist_sq_xi = (X_norm - 3) ** 2 + (Y - 1) ** 2
+        dist_sq_psi = (X_norm - 3) ** 2 + (Y - 3) ** 2
+        term3 = self.beta * torch.sqrt(torch.relu(2 - dist_sq_beta))
+        term4 = self.gamma * torch.sqrt(torch.relu(1 - dist_sq_gamma))
+        term5 = self.delta * torch.sqrt(torch.relu(1 - dist_sq_delta))
+        term6 = self.xi * torch.sqrt(torch.relu(1 - dist_sq_xi))
+        term7 = self.psi * torch.sqrt(torch.relu(1 - dist_sq_psi))
+        Z_norm = term1 + term2 + term3 + term4 + term5 + term6 + term7
+        Z = Z_norm * self.maxInput
+        return Z

homa-0.0.19/src/homa/activations/classes/PDELU.py

@@ -0,0 +1,39 @@
+import torch
+
+
+class PDELU(torch.nn.Module):
+    def __init__(self, theta: float = 0.5):
+        super(PDELU, self).__init__()
+        if theta == 1.0:
+            raise ValueError(
+                "theta cannot be 1.0, as it would cause a division by zero."
+            )
+        self.theta = theta
+        self._power_val = 1.0 / (1.0 - self.theta)
+        self.alpha = torch.nn.UninitializedParameter()
+        self._num_channels = None
+
+    def _initialize_parameters(self, x: torch.Tensor):
+        if x.ndim < 2:
+            raise ValueError(
+                f"Input tensor must have at least 2 dimensions (N, C), but got shape {x.shape}"
+            )
+
+        num_channels = x.shape[1]
+        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)
+
+    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)
+        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)
+        subtracted_term = powered_term - 1.0
+        negative_part = self.alpha * torch.min(subtracted_term, zero)
+        return positive_part + negative_part

homa-0.0.19/src/homa/activations/classes/SReLU.py

@@ -0,0 +1,49 @@
+import torch
+
+
+class SReLU(torch.nn.Module):
+    def __init__(
+        self,
+        alpha_init: float = 0.0,
+        beta_init: float = 0.0,
+        gamma_init: float = 1.0,
+        delta_init: float = 1.0,
+    ):
+        super().__init__()
+        self.alpha_init_val = alpha_init
+        self.beta_init_val = beta_init
+        self.gamma_init_val = gamma_init
+        self.delta_init_val = delta_init
+        self.alpha = torch.nn.UninitializedParameter()
+        self.beta = torch.nn.UninitializedParameter()
+        self.gamma = torch.nn.UninitializedParameter()
+        self.delta = torch.nn.UninitializedParameter()
+
+    def _initialize_parameters(self, x: torch.Tensor):
+        if isinstance(self.alpha, torch.nn.UninitializedParameter):
+            if x.dim() < 2:
+                raise ValueError(
+                    f"Input tensor must have at least 2 dimensions (N, C), but got {x.dim()}"
+                )
+
+            num_channels = x.shape[1]
+            param_shape = [1] * x.dim()
+            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))
+            self.gamma = torch.nn.Parameter(
+                torch.full(param_shape, self.gamma_init_val)
+            )
+            self.delta = torch.nn.Parameter(
+                torch.full(param_shape, self.delta_init_val)
+            )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        self._initialize_parameters(x)
+        start = self.beta + self.alpha * (x - self.beta)
+        finish = self.delta + self.gamma * (x - self.delta)
+        out = torch.where(x < self.beta, start, x)
+        out = torch.where(x > self.delta, finish, out)
+        return out

homa-0.0.19/src/homa/activations/classes/SmallGALU.py

@@ -0,0 +1,39 @@
+import torch
+
+
+class SmallGALU(torch.nn.Module):
+    def __init__(self, max_input: float = 1.0):
+        super(SmallGALU, self).__init__()
+        if max_input <= 0:
+            raise ValueError("max_input must be positive.")
+        self.max_input = max_input
+        self.alpha = None
+        self.beta = None
+        self._num_channels = None
+
+    def _initialize_parameters(self, x):
+        if x.ndim < 2:
+            raise ValueError(
+                f"Input tensor must have at least 2 dimensions (N, C), but got shape {x.shape}"
+            )
+
+        num_channels = x.shape[1]
+        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))
+
+    def forward(self, x):
+        if self.alpha is None:
+            self._initialize_parameters(x)
+
+        zero = torch.tensor(0.0, device=x.device, dtype=x.dtype)
+        x_norm = x / self.max_input
+        part_prelu = torch.relu(x_norm) + self.alpha * torch.min(x_norm, zero)
+        part_beta = self.beta * (
+            torch.relu(1.0 - torch.abs(x_norm - 1.0))
+            + torch.min(torch.abs(x_norm - 3.0) - 1.0, zero)
+        )
+        z = part_prelu + part_beta
+        return z * self.max_input

homa-0.0.19/src/homa/activations/classes/StochasticActivation.py

@@ -0,0 +1,20 @@
+import torch
+import random
+
+from .APLU import APLU
+from .GALU import GALU
+from .SmallGALU import SmallGALU
+from .MELU import MELU
+from .WideMELU import WideMELU
+from .PDELU import PDELU
+from .SReLU import SReLU
+
+
+class StochasticActivation(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.gate = random.choice([APLU, GALU, SmallGALU, MELU, WideMELU, PDELU, SReLU])
+        self.gate = self.gate()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.gate(x)

homa-0.0.19/src/homa/activations/classes/WideMELU.py

@@ -0,0 +1,61 @@
+import torch
+
+
+class WideMELU(torch.nn.Module):
+    def __init__(self, maxInput: float = 1.0):
+        super().__init__()
+        self.maxInput = float(maxInput)
+        self.alpha = None
+        self.beta = None
+        self.gamma = None
+        self.delta = None
+        self.xi = None
+        self.psi = None
+        self.theta = None
+        self.lam = None
+        self._initialized = False
+
+    def _initialize_parameters(self, X: torch.Tensor):
+        if X.dim() != 4:
+            raise ValueError(
+                f"Expected 4D input (B, C, H, W), but got {X.dim()}D input."
+            )
+
+        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._initialized = True
+
+    def forward(self, X: torch.Tensor) -> torch.Tensor:
+        if not self._initialized:
+            self._initialize_parameters(X)
+        X_norm = X / self.maxInput
+        Y = torch.roll(X_norm, shifts=-1, dims=1)
+        term1 = torch.relu(X_norm)
+        term2 = self.alpha * torch.clamp(X_norm, max=0)
+        dist_sq_beta = (X_norm - 2) ** 2 + (Y - 2) ** 2
+        dist_sq_gamma = (X_norm - 1) ** 2 + (Y - 1) ** 2
+        dist_sq_delta = (X_norm - 1) ** 2 + (Y - 3) ** 2
+        dist_sq_xi = (X_norm - 3) ** 2 + (Y - 1) ** 2
+        dist_sq_psi = (X_norm - 3) ** 2 + (Y - 3) ** 2
+        dist_sq_theta = (X_norm - 1) ** 2 + (Y - 2) ** 2
+        dist_sq_lambda = (X_norm - 3) ** 2 + (Y - 2) ** 2
+
+        term3 = self.beta * torch.sqrt(torch.relu(2 - dist_sq_beta))
+        term4 = self.gamma * torch.sqrt(torch.relu(1 - dist_sq_gamma))
+        term5 = self.delta * torch.sqrt(torch.relu(1 - dist_sq_delta))
+        term6 = self.xi * torch.sqrt(torch.relu(1 - dist_sq_xi))
+        term7 = self.psi * torch.sqrt(torch.relu(1 - dist_sq_psi))
+        term8 = self.theta * torch.sqrt(torch.relu(1 - dist_sq_theta))
+        term9 = self.lam * torch.sqrt(torch.relu(1 - dist_sq_lambda))
+        Z_norm = term1 + term2 + term3 + term4 + term5 + term6 + term7 + term8 + term9
+        Z = Z_norm * self.maxInput
+        return Z

homa-0.0.19/src/homa/activations/classes/__init__.py

@@ -0,0 +1,8 @@
+from .APLU import APLU
+from .GALU import GALU
+from .SmallGALU import SmallGALU
+from .MELU import MELU
+from .WideMELU import WideMELU
+from .PDELU import PDELU
+from .SReLU import SReLU
+from .StochasticActivation import StochasticActivation

homa-0.0.19/src/homa/activations/utils.py

@@ -0,0 +1,27 @@
+import torch
+
+
+def negative_part(x):
+    return torch.minimum(x, torch.zeros_like(x))
+
+
+def positive_part(x):
+    return torch.maximum(x, torch.zeros_like(x))
+
+
+def as_channel_parameters(parameter: torch.Tensor, x: torch.Tensor):
+    shape = [1] * x.dim()
+    shape[1] = -1
+    return parameter.view(*shape)
+
+
+def device_compatibility_check(model, x: torch.Tensor):
+    for p in model.parameters():
+        if p.device != x.device or p.dtype != x.dtype:
+            p.data = p.data.to(device=x.device, dtype=x.dtype)
+
+
+def phi_hat(x, a, lam):
+    term_pos = torch.maximum(lam - torch.abs(x - a), torch.zeros_like(x))
+    term_neg = torch.minimum(torch.abs(x - (a + 2 * lam)) - lam, torch.zeros_like(x))
+    return term_pos + term_neg

homa-0.0.19/src/homa/cli/HomaCommand.py

@@ -0,0 +1,12 @@
+import fire
+from .namespaces import MakeNamespace, CacheNamespace
+
+
+class HomaCommand:
+    def __init__(self):
+        self.make = MakeNamespace()
+        self.cache = CacheNamespace()
+
+
+def main():
+    fire.Fire(HomaCommand)

homa-0.0.19/src/homa/cli/namespaces/CacheNamespace.py

@@ -0,0 +1,29 @@
+import shutil
+import sys
+from pathlib import Path
+
+
+class CacheNamespace:
+    def clear(self):
+        root = Path.cwd()
+        removed = 0
+        errors: list[str] = []
+
+        for candidate in root.rglob("__pycache__"):
+            if not candidate.is_dir():
+                continue
+            try:
+                shutil.rmtree(candidate)
+                removed += 1
+            except OSError as exc:
+                errors.append(f"{candidate}: {exc}")
+
+        if errors:
+            print("Failed to remove the following paths:", file=sys.stderr)
+            for error in errors:
+                print(f"  - {error}", file=sys.stderr)
+            return 1
+
+        return (
+            f"Removed {removed} __pycache__ director{'ies' if removed != 1 else 'y'}."
+        )

homa-0.0.19/src/homa/cli/namespaces/MakeNamespace.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+
+class MakeNamespace:
+    def trait(self, name: str):
+        class_name = name.split(".")[-1]
+        file = name.replace(".", "/") + ".py"
+        path = Path(file)
+        parent = path.parent
+        parent.mkdir(parents=True, exist_ok=True)
+        path.touch()
+
+        # copy the tempalte path
+        current_path = Path(__file__).parent.parent.resolve()
+        template_path = current_path / "templates" / "trait.txt"
+        content = template_path.read_text()
+        content = content.replace("{{CLASS}}", class_name)
+        path.write_text(content)

homa-0.0.19/src/homa/cli/namespaces/__init__.py

@@ -0,0 +1,2 @@
+from .MakeNamespace import MakeNamespace
+from .CacheNamespace import CacheNamespace

homa-0.0.19/src/homa/device.py

@@ -0,0 +1,25 @@
+import torch
+
+
+def get_device():
+    if torch.backends.mps.is_available():
+        return mps()
+    if torch.cuda.is_available():
+        return cuda()
+    return cpu()
+
+
+def cpu():
+    return torch.device("cpu")
+
+
+def cuda():
+    return torch.device("cuda")
+
+
+def mps():
+    return torch.device("mps")
+
+
+def device():
+    return get_device()

homa-0.0.19/src/homa/ensemble/Ensemble.py

@@ -0,0 +1,18 @@
+from .concerns import (
+    ReportsSize,
+    RecordsStateDictionaries,
+    ReportsClassificationMetrics,
+    HasNetwork,
+    PredictsProbabilities,
+)
+
+
+class Ensemble(
+    ReportsSize,
+    ReportsClassificationMetrics,
+    RecordsStateDictionaries,
+    PredictsProbabilities,
+    HasNetwork,
+):
+    def __init__(self):
+        super().__init__()

homa-0.0.19/src/homa/ensemble/__init__.py

@@ -0,0 +1 @@
+from .Ensemble import Ensemble

homa-0.0.19/src/homa/ensemble/concerns/CalculatesMetricNecessities.py

@@ -0,0 +1,20 @@
+import torch
+
+
+class CalculatesMetricNecessities:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def metric_necessities(self, dataloader):
+        all_predictions = []
+        all_labels = []
+        for x, y in dataloader:
+            batch_logits_list = []
+            for model in self.models:
+                batch_logits_list.append(model(x))
+            all_batch_logits = torch.stack(batch_logits_list)
+            avg_logits = torch.mean(all_batch_logits, dim=0)
+            _, preds = torch.max(avg_logits, 1)
+            all_predictions.extend(preds.cpu().numpy())
+            all_labels.extend(y.cpu().numpy())
+        return all_predictions, all_labels

homa-0.0.19/src/homa/ensemble/concerns/HasNetwork.py

@@ -0,0 +1,5 @@
+class HasNetwork:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # This property is going to be filled with the first model that is fed into the ensemble.
+        self.network = None

homa-0.0.19/src/homa/ensemble/concerns/HasStateDicts.py

@@ -0,0 +1,8 @@
+from typing import List
+from collections import OrderedDict
+
+
+class HasStateDicts:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.state_dicts: List[OrderedDict] = []

homa-0.0.19/src/homa/ensemble/concerns/PredictsProbabilities.py

@@ -0,0 +1,11 @@
+import torch
+from .ReportsLogits import ReportsLogits
+
+
+class PredictsProbabilities(ReportsLogits):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def predict(self, x: torch.Tensor) -> torch.Tensor:
+        logits = self.logits(x)
+        return torch.nn.functional.softmax(logits, dim=1)

homa-0.0.19/src/homa/ensemble/concerns/RecordsStateDictionaries.py

@@ -0,0 +1,23 @@
+from copy import deepcopy
+from .HasStateDicts import HasStateDicts
+from ...vision import Model
+
+
+class RecordsStateDictionaries(HasStateDicts):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def record(self, model: Model):
+        if self.network is None:
+            self.network = deepcopy(model.network)
+
+        self.state_dicts.append(model.network.state_dict())
+
+    def push(self, *args, **kwargs):
+        self.record(*args, **kwargs)
+
+    def append(self, *args, **kwargs):
+        self.record(*args, **kwargs)
+
+    def add(self, *args, **kwargs):
+        self.record(*args, **kwargs)

homa-0.0.19/src/homa/ensemble/concerns/ReportsClassificationMetrics.py

@@ -0,0 +1,13 @@
+from .ReportsEnsembleF1 import ReportsEnsembleF1
+from .ReportsEnsembleAccuracy import ReportsEnsembleAccuracy
+from .ReportsEnsembleKappa import ReportsEnsembleKappa
+from .CalculatesMetricNecessities import CalculatesMetricNecessities
+
+
+class ReportsClassificationMetrics(
+    CalculatesMetricNecessities,
+    ReportsEnsembleF1,
+    ReportsEnsembleAccuracy,
+    ReportsEnsembleKappa,
+):
+    pass

homa-0.0.19/src/homa/ensemble/concerns/ReportsEnsembleAccuracy.py

@@ -0,0 +1,10 @@
+from sklearn.metrics import accuracy_score as accuracy
+
+
+class ReportsEnsembleAccuracy:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def accuracy(self) -> float:
+        predictions, labels = self.metric_necessities()
+        return accuracy(labels, predictions)

homa-0.0.19/src/homa/ensemble/concerns/ReportsEnsembleF1.py

@@ -0,0 +1,10 @@
+from sklearn.metrics import f1_score as f1
+
+
+class ReportsEnsembleF1:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def f1(self) -> float:
+        predictions, labels = self.metric_necessities()
+        return f1(labels, predictions, average="weighted")

homa-0.0.19/src/homa/ensemble/concerns/ReportsEnsembleKappa.py

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

homa-0.0.19/src/homa/ensemble/concerns/ReportsLogits.py

@@ -0,0 +1,13 @@
+import torch
+
+
+class ReportsLogits:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def logits(self, x: torch.Tensor) -> torch.Tensor:
+        batch_size = x.shape[0]
+        logits = torch.zeros((batch_size, self.num_classes))
+        for model in self.models:
+            logits += model(x)
+        return logits

homa-0.0.19/src/homa/ensemble/concerns/ReportsSize.py

@@ -0,0 +1,11 @@
+class ReportsSize:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @property
+    def size(self):
+        return len(self.state_dicts)
+
+    @property
+    def length(self):
+        return len(self.state_dicts)

homa-0.0.19/src/homa/ensemble/concerns/__init__.py

@@ -0,0 +1,10 @@
+from .CalculatesMetricNecessities import CalculatesMetricNecessities
+from .HasNetwork import HasNetwork
+from .PredictsProbabilities import PredictsProbabilities
+from .RecordsStateDictionaries import RecordsStateDictionaries
+from .ReportsClassificationMetrics import ReportsClassificationMetrics
+from .ReportsEnsembleAccuracy import ReportsEnsembleAccuracy
+from .ReportsEnsembleF1 import ReportsEnsembleF1
+from .ReportsEnsembleKappa import ReportsEnsembleKappa
+from .ReportsLogits import ReportsLogits
+from .ReportsSize import ReportsSize

homa-0.0.19/src/homa/settings.py

@@ -0,0 +1,12 @@
+import json
+
+
+def settings(key: str, _cache: dict = {}):
+    if not _cache:
+        with open("settings.json", "r") as f:
+            _cache.update(json.load(f))
+    return _cache.get(key)
+
+
+def get_settings(*args, **kwargs):
+    return settings(*args, **kwargs)

homa-0.0.19/src/homa/torch/Module.py

@@ -0,0 +1,8 @@
+import torch
+from ..device import get_device
+
+
+class Module(torch.nn.Module):
+    def __init__(self):
+        super(Module, self).__init__()
+        self.to(get_device())

homa-0.0.19/src/homa/torch/__init__.py

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

homa-0.0.19/src/homa/torch/helpers.py

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

homa-0.0.19/src/homa/utils.py

@@ -0,0 +1,2 @@
+def invoke(base, *args, **kwargs):
+    return base()(*args, **kwargs)

homa-0.0.19/src/homa/vision/Model.py

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

homa-0.0.19/src/homa/vision/Resnet.py

@@ -0,0 +1,12 @@
+import torch
+from .modules import ResnetModule
+from .Model import Model
+from .concerns import Trainable
+
+
+class Resnet(Model, Trainable):
+    def __init__(self, num_classes: int, lr: float):
+        super().__init__()
+        self.network = ResnetModule(num_classes)
+        self.criterion = torch.nn.CrossEntropyLoss()
+        self.optimizer = torch.optim.SGD(self.network.parameters(), lr=lr, momentum=0.9)

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

@@ -0,0 +1,8 @@
+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.0.19/src/homa/vision/__init__.py

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

homa-0.0.19/src/homa/vision/concerns/Trainable.py

@@ -0,0 +1,26 @@
+from torch import Tensor
+from torch.utils.data.dataloader import DataLoader
+from ...device import get_device
+
+
+class Trainable:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def train(self, x: Tensor | DataLoader, y: Tensor | None = None):
+        if y is None and isinstance(x, DataLoader):
+            self.train_dataloader(x)
+            return
+        self.train_tensors(x, y)
+
+    def train_tensors(self, x: Tensor, y: Tensor):
+        self.network.train()
+        self.optimizer.zero_grad()
+        loss = self.criterion(x, y)
+        loss.backward()
+        self.optimizer.step()
+
+    def train_dataloader(self, dataloader: DataLoader):
+        for x, y in dataloader:
+            x, y = x.to(get_device()), y.to(get_device())
+            self.train_tensors(x, y)

homa-0.0.19/src/homa/vision/concerns/__init__.py

@@ -0,0 +1 @@
+from .Trainable import Trainable

homa-0.0.19/src/homa/vision/modules/ResnetModule.py

@@ -0,0 +1,23 @@
+import torch
+from torchvision.models import resnet50
+from torch.nn.init import kaiming_uniform_ as kaiming
+
+
+class ResnetModule(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 = resnet50(weights="DEFAULT")
+        self.encoder.fc = torch.nn.Identity()
+
+    def _create_fc(self):
+        self.fc = torch.nn.Linear(2048, 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.0.19/src/homa/vision/modules/StochasticResnetModule.py

@@ -0,0 +1,9 @@
+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.0.19/src/homa/vision/modules/__init__.py

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

homa-0.0.19/src/homa/vision/utils.py

@@ -0,0 +1,21 @@
+import torch
+
+
+def replace_modules(
+    model: torch.nn.Module, find: list | torch.Tensor, replacement: torch.nn.Module
+) -> int:
+    if not isinstance(find, list):
+        find = [find]
+
+    replaced = 0
+    for parent in model.modules():
+        for name, child in list(parent.named_children()):
+            for needle in find:
+                if isinstance(child, needle):
+                    setattr(parent, name, replacement())
+                    replaced += 1
+    return replaced
+
+
+def replace_relu(model: torch.nn.Module, replacement: torch.nn.Module):
+    return replace_modules(model, torch.nn.ReLU, replacement)

homa-0.0.19/src/homa.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: homa
+Version: 0.0.19
+Summary: A curated list of machine learning and deep learning helpers.
+Author-email: Taha Shieenavaz <tahashieenavaz@gmail.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: torch
+Requires-Dist: fire
+
+## Device Management
+
+```py
+from homa import cpu, mps, cuda, device
+
+torch.tensor([1, 2, 3, 4, 5]).to(cpu())
+torch.tensor([1, 2, 3, 4, 5]).to(cuda())
+torch.tensor([1, 2, 3, 4, 5]).to(mps())
+torch.tensor([1, 2, 3, 4, 5]).to(device())
+```

homa-0.0.19/src/homa.egg-info/SOURCES.txt

@@ -0,0 +1,57 @@
+README.md
+pyproject.toml
+src/homa/__init__.py
+src/homa/device.py
+src/homa/settings.py
+src/homa/utils.py
+src/homa.egg-info/PKG-INFO
+src/homa.egg-info/SOURCES.txt
+src/homa.egg-info/dependency_links.txt
+src/homa.egg-info/entry_points.txt
+src/homa.egg-info/requires.txt
+src/homa.egg-info/top_level.txt
+src/homa/activations/__init__.py
+src/homa/activations/utils.py
+src/homa/activations/classes/APLU.py
+src/homa/activations/classes/GALU.py
+src/homa/activations/classes/MELU.py
+src/homa/activations/classes/PDELU.py
+src/homa/activations/classes/SReLU.py
+src/homa/activations/classes/SmallGALU.py
+src/homa/activations/classes/StochasticActivation.py
+src/homa/activations/classes/WideMELU.py
+src/homa/activations/classes/__init__.py
+src/homa/cli/HomaCommand.py
+src/homa/cli/namespaces/CacheNamespace.py
+src/homa/cli/namespaces/MakeNamespace.py
+src/homa/cli/namespaces/__init__.py
+src/homa/ensemble/Ensemble.py
+src/homa/ensemble/__init__.py
+src/homa/ensemble/concerns/CalculatesMetricNecessities.py
+src/homa/ensemble/concerns/HasNetwork.py
+src/homa/ensemble/concerns/HasStateDicts.py
+src/homa/ensemble/concerns/PredictsProbabilities.py
+src/homa/ensemble/concerns/RecordsStateDictionaries.py
+src/homa/ensemble/concerns/ReportsClassificationMetrics.py
+src/homa/ensemble/concerns/ReportsEnsembleAccuracy.py
+src/homa/ensemble/concerns/ReportsEnsembleF1.py
+src/homa/ensemble/concerns/ReportsEnsembleKappa.py
+src/homa/ensemble/concerns/ReportsLogits.py
+src/homa/ensemble/concerns/ReportsSize.py
+src/homa/ensemble/concerns/__init__.py
+src/homa/torch/Module.py
+src/homa/torch/__init__.py
+src/homa/torch/helpers.py
+src/homa/vision/Model.py
+src/homa/vision/Resnet.py
+src/homa/vision/StochasticResnet.py
+src/homa/vision/__init__.py
+src/homa/vision/utils.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/__init__.py
+tests/test_ensemble.py
+tests/test_resnet.py
+tests/test_stochastic_resnet.py

homa-0.0.19/src/homa.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

homa-0.0.19/src/homa.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+homa = homa.cli.HomaCommand:main

homa-0.0.19/src/homa.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+torch
+fire

homa-0.0.19/src/homa.egg-info/top_level.txt

@@ -0,0 +1 @@
+homa

homa-0.0.19/tests/test_ensemble.py

@@ -0,0 +1,28 @@
+import pytest
+from homa.ensemble import Ensemble
+from homa.vision import Resnet
+
+
+@pytest.fixture
+def ensemble():
+    return Ensemble()
+
+
+@pytest.fixture
+def resnet():
+    return Resnet(lr=0.001, num_classes=10)
+
+
+def test_ensemble_initialization(ensemble):
+    assert isinstance(ensemble, Ensemble)
+
+
+def test_ensemble_records_models(ensemble, resnet):
+    assert ensemble.network is None
+    ensemble.record(resnet)
+    assert ensemble.network is not None
+    ensemble.append(resnet)
+    ensemble.push(resnet)
+    ensemble.add(resnet)
+    assert ensemble.size == 4
+    assert ensemble.length == 4

homa-0.0.19/tests/test_resnet.py

@@ -0,0 +1,21 @@
+import pytest
+import torch
+from homa.vision import Resnet, Model
+from homa.vision.modules import ResnetModule
+
+
+@pytest.fixture
+def resnet_model():
+    model = Resnet(num_classes=5, lr=0.001)
+    return model
+
+
+def test_resnet_initialization(resnet_model):
+    assert isinstance(resnet_model, Resnet)
+    assert isinstance(resnet_model, Model)
+    assert hasattr(resnet_model, "network")
+    assert hasattr(resnet_model, "optimizer")
+    assert hasattr(resnet_model, "criterion")
+    assert isinstance(resnet_model.network, ResnetModule)
+    assert isinstance(resnet_model.optimizer, torch.optim.SGD)
+    assert isinstance(resnet_model.criterion, torch.nn.CrossEntropyLoss)

homa-0.0.19/tests/test_stochastic_resnet.py

@@ -0,0 +1,20 @@
+import pytest
+import torch
+from homa.vision import StochasticResnet, Model
+from homa.vision.modules import ResnetModule
+
+
+@pytest.fixture
+def stochastic_resnet_model():
+    return StochasticResnet(num_classes=5, lr=0.001)
+
+
+def test_resnet_initialization(stochastic_resnet_model):
+    assert isinstance(stochastic_resnet_model, StochasticResnet)
+    assert isinstance(stochastic_resnet_model, Model)
+    assert hasattr(stochastic_resnet_model, "network")
+    assert hasattr(stochastic_resnet_model, "optimizer")
+    assert hasattr(stochastic_resnet_model, "criterion")
+    assert isinstance(stochastic_resnet_model.network, ResnetModule)
+    assert isinstance(stochastic_resnet_model.optimizer, torch.optim.SGD)
+    assert isinstance(stochastic_resnet_model.criterion, torch.nn.CrossEntropyLoss)