homa 0.0.1__py3-none-any.whl → 0.0.19__py3-none-any.whl

homa/activations/__init__.py

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

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/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/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/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/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/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/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/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/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/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/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/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/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/cli/namespaces/__init__.py

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

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/ensemble/__init__.py

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

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/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/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/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/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/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/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/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/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/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/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/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/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/torch/__init__.py

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

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/utils.py

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

homa/vision/Model.py

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

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/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/vision/__init__.py

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

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/vision/concerns/__init__.py

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

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/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/vision/modules/__init__.py

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

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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,51 @@
+homa/__init__.py,sha256=NBYFKizG8UASiz5HLsEBqzXNGlWr78xm4sLr5hxKvjU,46
+homa/device.py,sha256=9kKXfpYfnEk2cFQWPfcJrVloHgC_SSbP4I8IRY9TYk4,343
+homa/settings.py,sha256=CPZDPvs1380O7SY7FcSKol8kBVFVVYFgSJl3YEyJuZ0,263
+homa/utils.py,sha256=dPp6TItJwWxBqxmkMzUuCtX_BzdPT-kMOZyXRGVMCbQ,70
+homa/activations/__init__.py,sha256=zrEyWrYuQAD9R8GJBJUChfkW8_lsMUEwHvAcASoac3k,44
+homa/activations/utils.py,sha256=asXbV7tl48ORLiggXHo6hjYNIjWuHvmuhVv311IJebA,734
+homa/activations/classes/APLU.py,sha256=tjdHYrOqO6vA6qFVAbUuu1O9kB_bPq4AYuiXpbyk2vg,1499
+homa/activations/classes/GALU.py,sha256=LNH-iO89cDXoL6iXtny5DxW3n7sO34s4_GWXcFlzgQM,1864
+homa/activations/classes/MELU.py,sha256=80_0H4pjGXngiGsyT09c4h2MFRkds8Ypn-zXRJ45NQY,2060
+homa/activations/classes/PDELU.py,sha256=tRdxa1RLQuXEjXrSD283qgIulbOPX1mQtV5GGqrVUH0,1418
+homa/activations/classes/SReLU.py,sha256=TxTxcAvRQHYykGq0uXP2QthNIK_BNsLaoqzHPHSFRIY,1828
+homa/activations/classes/SmallGALU.py,sha256=LS92S4lgIOrqbJPMA1pBJSkkm3lIChd1dRE_XV-YRd8,1342
+homa/activations/classes/StochasticActivation.py,sha256=0A2iTQmtvA7Yx9hOf4fuqTvTSi_8bIT3dsKLe--Od3o,515
+homa/activations/classes/WideMELU.py,sha256=7-p-mhOt8kc_qniXqF6wGYVxtLveL7bUIUJSFKQYD0M,2507
+homa/activations/classes/__init__.py,sha256=RBI51Jc9EBPrpwLNCmzLkz3fhJCRRSI46HjsI1CL1Es,238
+homa/cli/HomaCommand.py,sha256=zUWDLpXb6zO6DWZ71MuhPNawjXTqkXJPEwZxWN7Ejx0,226
+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=gYfQfdKSZdLlWNGMUGCOEv3vQj0nhYYpJmznETizXfA,346
+homa/ensemble/__init__.py,sha256=1pk2W-NbgfDFh9WLKZVLUk2E3PTjVZ5Bap9dQEnrs9o,31
+homa/ensemble/concerns/CalculatesMetricNecessities.py,sha256=hU0Nn-4UYQXUy7gQmWL638w4vZjwigAMkxyFnqRboiM,706
+homa/ensemble/concerns/HasNetwork.py,sha256=WlE-gpt7WlCOW0vIlnqJJsYCi2Ids7uE6CDjolOoElw,227
+homa/ensemble/concerns/HasStateDicts.py,sha256=EAQj01qC_wnJUgQ6ReZI9kc1fFC-tqPrXjeGhE2Ka6M,215
+homa/ensemble/concerns/PredictsProbabilities.py,sha256=qdCpS-NdoYQdtXJXRKz96MY1VW06baJ-pu_7zP3X_JU,330
+homa/ensemble/concerns/RecordsStateDictionaries.py,sha256=FeIyDDxm60p5DCNVjq7xRyuhM04gvJI0ftigtjfXXLA,635
+homa/ensemble/concerns/ReportsClassificationMetrics.py,sha256=YDFH7nMStudtc6pJqBGDNzQmknKIVDLgwCWsr4NFXc4,395
+homa/ensemble/concerns/ReportsEnsembleAccuracy.py,sha256=x_cfPsikXc4dUsta2-gnOUoiSCb5J-gq4ao4ESZPDFs,306
+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=H0AFvCcRDYjGtgrpinVLUyhvumF4Lmo2nyvtNOa_ARM,355
+homa/ensemble/concerns/ReportsSize.py,sha256=6XJYc24isbbnoNV8DJWwaFfhi__qAnYEQZQJMDPL4VA,248
+homa/ensemble/concerns/__init__.py,sha256=UtEqGhxlNypLa29bxw59Z1W4SN3Tju1ynJI72luIiAo,538
+homa/torch/Module.py,sha256=UuRTJXxp7hlQHHL2dBGVlHlyA2OFgJ1Xz9SAff8Iv3c,171
+homa/torch/__init__.py,sha256=Z-sIT4UjMBo2BgGoEPyQ20xJWVeX1W5Q4_C7CDa0SdE,50
+homa/torch/helpers.py,sha256=CLbTCXRrroM0n4PfM-K_xFavs4dCZJEu_L7hdgb1DCI,134
+homa/vision/Model.py,sha256=JIeVpHJwirHfsDfYYbLsu0kt7bGf4nhMQGIOagUDKw4,22
+homa/vision/Resnet.py,sha256=Kh5QLYp8X8o9vFHYqTeOs1uRb6n36FsENdHTIiFZTAs,409
+homa/vision/StochasticResnet.py,sha256=mLgKBfqRJtOgWdgfVHHTnIJVg2SHQDYz4ywXiTWqcIY,241
+homa/vision/__init__.py,sha256=9M65-r8ykfncoPS3UYJC536vi2ytyzHAf4ZZ4ZlMz1g,99
+homa/vision/utils.py,sha256=O58TkXooa31mXJ1JQTykO2OXzmUm9H8Qvvk9lsIZnZ0,623
+homa/vision/concerns/Trainable.py,sha256=pgwFoesMLNuz4ejPyHAoJLO0NPYhRsbBjNbtBYZgiRs,813
+homa/vision/concerns/__init__.py,sha256=UnZfL_YH4IwNqip1wokoWJHe6fn4pE0ePtchTuykxJY,33
+homa/vision/modules/ResnetModule.py,sha256=eFudBnILD6OmgQtcW_CQQ8aZ62NEa4HyZ15-lobTtt0,712
+homa/vision/modules/StochasticResnetModule.py,sha256=zSfx6FW5c5NfHMDGw7MTbaxQ3EmyKV1WVnWqH7G7CDc,298
+homa/vision/modules/__init__.py,sha256=kGlcc0BvYjuT_pBijI54VXLoWluPMfLzif1eO_9RoJc,98
+homa-0.0.19.dist-info/METADATA,sha256=jut1aYkO2ByRxiuJbSLpjT9_F70lleWcUb261_wBhcs,540
+homa-0.0.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+homa-0.0.19.dist-info/entry_points.txt,sha256=tJZzjs-f2QvFe3ES8Qta8IE5sAbeE8-cyZ_UtbgqG4s,51
+homa-0.0.19.dist-info/top_level.txt,sha256=tmOfy2tuaAwc3W5-i6j61_vYJsXgR4ivBWkhJ3ZtJDc,5
+homa-0.0.19.dist-info/RECORD,,

homa-0.0.19.dist-info/entry_points.txt

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

homa-0.0.1.dist-info/METADATA

@@ -1,12 +0,0 @@
-Metadata-Version: 2.4
-Name: homa
-Version: 0.0.1
-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
-
-# homa
-A curated collection of machine learning and deep learning helper functions.

homa-0.0.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-homa/__init__.py,sha256=NBYFKizG8UASiz5HLsEBqzXNGlWr78xm4sLr5hxKvjU,46
-homa/device.py,sha256=9kKXfpYfnEk2cFQWPfcJrVloHgC_SSbP4I8IRY9TYk4,343
-homa/settings.py,sha256=CPZDPvs1380O7SY7FcSKol8kBVFVVYFgSJl3YEyJuZ0,263
-homa-0.0.1.dist-info/METADATA,sha256=TMXUMO31Dt-5DrlD4maXJTNtWYlzMBFJvg3JONUhXj4,366
-homa-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-homa-0.0.1.dist-info/top_level.txt,sha256=tmOfy2tuaAwc3W5-i6j61_vYJsXgR4ivBWkhJ3ZtJDc,5
-homa-0.0.1.dist-info/RECORD,,