homa 0.2.94__py3-none-any.whl

homa/activations/TBSReLU.py

@@ -0,0 +1,13 @@
+import torch
+from .ActivationFunction import ActivationFunction
+
+
+class TBSReLU(ActivationFunction):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        a = 1 - torch.exp(-x)
+        b = 1 + torch.exp(-x)
+        c = a / b
+        return x * torch.tanh(c)

homa/activations/TSReLU.py

@@ -0,0 +1,10 @@
+import torch
+from .ActivationFunction import ActivationFunction
+
+
+class TSReLU(ActivationFunction):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x * torch.tanh(torch.sigmoid(x))

homa/activations/TangentBipolarSigmoidReLU.py

@@ -0,0 +1,6 @@
+from .TBSReLU import TBSReLU
+
+
+class TangentBipolarSigmoidReLU(TBSReLU):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)

homa/activations/TangentSigmoidReLU.py

@@ -0,0 +1,6 @@
+from .TSReLU import TSReLU
+
+
+class TangentSigmoidReLU(TSReLU):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)

homa/activations/TeLU.py

@@ -0,0 +1,9 @@
+import torch
+
+
+class TeLU(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x: torch.Tensor):
+        return x * torch.tanh(torch.exp(x))

homa/activations/TripleStateSwish.py

@@ -0,0 +1,15 @@
+import torch
+from .ActivationFunction import ActivationFunction
+
+
+class TripleStateSwish(ActivationFunction):
+    def __init__(self, alpha: float = 20, beta: float = 40, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.alpha = alpha
+        self.beta = beta
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        a = 1 / (1 + torch.exp(-x))
+        b = 1 / (1 + torch.exp(-x + self.alpha))
+        c = 1 / (1 + torch.exp(-x + self.beta))
+        return x * a * (a + b + c)

homa/activations/WideMeLU.py

@@ -0,0 +1,15 @@
+from .MexicanReLU import MexicanReLU
+
+
+class WideMeLU(MexicanReLU):
+    def __init__(self, channels: int | None = None, max_input: float = 1.0):
+        self.hats = [
+            (2.0, 2.0),
+            (1.0, 1.0),
+            (3.0, 1.0),
+            (0.5, 0.5),
+            (1.5, 0.5),
+            (2.5, 0.5),
+            (3.5, 0.5),
+        ]
+        super().__init__(self.hats, channels=channels, max_input=max_input)

homa/activations/__init__.py

@@ -0,0 +1,49 @@
+from .ShiftedReLU import ShiftedReLU
+from .PLogish import PLogish
+from .ParametricLogish import ParametricLogish
+from .ExpExpish import ExpExpish
+from .GeneralizedSwish import GeneralizedSwish
+from .TBSReLU import TBSReLU
+from .NoisyReLU import NoisyReLU
+from .ExponentialDLReLU import ExponentialDLReLU
+from .SReLU import SReLU
+from .TangentSigmoidReLU import TangentSigmoidReLU
+from .Phish import Phish
+from .WideMeLU import WideMeLU
+from .SelfArctan import SelfArctan
+from .LogSigmoid import LogSigmoid
+from .SlopedReLU import SlopedReLU
+from .SmallGaLU import SmallGaLU
+from .MinSin import MinSin
+from .LaLU import LaLU
+from .MexicanReLU import MexicanReLU
+from .APLU import APLU
+from .ERF import ERF
+from .TangentBipolarSigmoidReLU import TangentBipolarSigmoidReLU
+from .BaseDLReLU import BaseDLReLU
+from .Logish import Logish
+from .TripleStateSwish import TripleStateSwish
+from .ExponentialSwish import ExponentialSwish
+from .TeLU import TeLU
+from .Elliot import Elliot
+from .MeLU import MeLU
+from .GaussianReLU import GaussianReLU
+from .ActivationFunction import ActivationFunction
+from .RReLU import RReLU
+from .Suish import Suish
+from .SoftsignRReLU import SoftsignRReLU
+from .Gish import Gish
+from .NReLU import NReLU
+from .LogLogish import LogLogish
+from .SGELU import SGELU
+from .GaLU import GaLU
+from .TSReLU import TSReLU
+from .SineReLU import SineReLU
+from .DLReLU import DLReLU
+from .CaLU import CaLU
+from .RandomizedSlopedReLU import RandomizedSlopedReLU
+from .GCU import GCU
+from .SigmoidDerivative import SigmoidDerivative
+from .Smish import Smish
+from .AdaptiveActivationFunction import AdaptiveActivationFunction
+from .learnable import *

homa/activations/learnable/AOAF.py

@@ -0,0 +1,16 @@
+import torch
+from .concerns import ChannelBased
+from ..AdaptiveActivationFunction import AdaptiveActivationFunction
+
+
+class AOAF(AdaptiveActivationFunction, ChannelBased):
+    def __init__(self, b: float = 0.17, c: float = 0.17):
+        super().__init__()
+        self.a = None
+        self.b = b
+        self.c = c
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        self.initialize(x, "a")
+        a = self.a.view(self.parameter_shape(x))
+        return torch.relu(x - self.b * a) + self.c * a

homa/activations/learnable/AReLU.py

@@ -0,0 +1,19 @@
+import torch
+from ..AdaptiveActivationFunction import AdaptiveActivationFunction
+from ...device import get_device
+
+
+class AReLU(AdaptiveActivationFunction):
+    def __init__(self):
+        super(AReLU, self).__init__()
+        self.a = torch.nn.Parameter(torch.tensor(0.9, requires_grad=True))
+        self.b = torch.nn.Parameter(torch.tensor(2.0, requires_grad=True))
+        self.a.to(get_device())
+        self.b.to(get_device())
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        negative_slope = torch.clamp(self.a, 0.01, 0.99)
+        positive_slope = 1 + torch.sigmoid(self.b)
+        positive = positive_slope * torch.relu(x)
+        negative = negative_slope * (-torch.relu(-x))
+        return positive + negative

homa/activations/learnable/DPReLU.py

@@ -0,0 +1,16 @@
+import torch
+from ..AdaptiveActivationFunction import AdaptiveActivationFunction
+from .concerns import ChannelBased
+
+
+class DPReLU(AdaptiveActivationFunction, ChannelBased):
+    def __init__(self):
+        super().__init__()
+        self.a = None
+        self.b = None
+
+    def forward(self, x: torch.Tensor):
+        self.initialize(x, ["a", "b"], [1, 0.01])
+        a = self.a.view(self.parameter_shape(x))
+        b = self.b.view(self.parameter_shape(x))
+        return torch.where(x >= 0, a * x, b * x)

homa/activations/learnable/DualLine.py

@@ -0,0 +1,18 @@
+import torch
+from ..AdaptiveActivationFunction import AdaptiveActivationFunction
+from .concerns import ChannelBased
+
+
+class DualLine(AdaptiveActivationFunction, ChannelBased):
+    def __init__(self):
+        super().__init__()
+        self.a = None
+        self.b = None
+        self.m = None
+
+    def forward(self, x: torch.Tensor):
+        self.initialize(x, ["a", "b", "m"], [1, 0.01, -0.22])
+        a = self.a.view(self.parameter_shape(x))
+        b = self.b.view(self.parameter_shape(x))
+        m = self.m.view(self.parameter_shape(x))
+        return torch.where(x >= 0, a * x + m, b * x + m)

homa/activations/learnable/FReLU.py

@@ -0,0 +1,14 @@
+import torch
+from ..AdaptiveActivationFunction import AdaptiveActivationFunction
+from .concerns import ChannelBased
+
+
+class FReLU(AdaptiveActivationFunction, ChannelBased):
+    def __init__(self):
+        super().__init__()
+        self.b = None
+
+    def forward(self, x: torch.Tensor):
+        self.initialize(x, "b")
+        b = self.b.view(self.parameter_shape(x))
+        return torch.where(x >= 0, x + b, b)

homa/activations/learnable/LeLeLU.py

@@ -0,0 +1,14 @@
+import torch
+from ..AdaptiveActivationFunction import AdaptiveActivationFunction
+from .concerns import ChannelBased
+
+
+class LeLeLU(AdaptiveActivationFunction, ChannelBased):
+    def __init__(self):
+        super().__init__()
+        self.a = None
+
+    def forward(self, x: torch.Tensor):
+        self.initialize(x, "a")
+        a = self.a.view(self.parameter_shape(x))
+        return torch.where(x >= 0, a * x, 0.01 * a * x)

homa/activations/learnable/PERU.py

@@ -0,0 +1,16 @@
+import torch
+from .concerns import ChannelBased
+from ..AdaptiveActivationFunction import AdaptiveActivationFunction
+
+
+class PERU(AdaptiveActivationFunction, ChannelBased):
+    def __init__(self):
+        super().__init__()
+        self.a = None
+        self.b = None
+
+    def forward(self, x: torch.Tensor):
+        self.initialize(x, ["a", "b"])
+        a = self.a.view(self.parameter_shape(x))
+        b = self.b.view(self.parameter_shape(x))
+        return torch.where(x >= 0, a * x, a * x * torch.exp(b * x))

homa/activations/learnable/PiLU.py

@@ -0,0 +1,18 @@
+import torch
+from ..AdaptiveActivationFunction import AdaptiveActivationFunction
+from .concerns import ChannelBased
+
+
+class PiLU(AdaptiveActivationFunction, ChannelBased):
+    def __init__(self):
+        super().__init__()
+        self.a = None
+        self.b = None
+        self.c = None
+
+    def forward(self, x: torch.Tensor):
+        self.initialize(x, ["a", "b", "c"], [1, 0.01, 1])
+        a = self.a.view(self.parameter_shape(x))
+        b = self.b.view(self.parameter_shape(x))
+        c = self.c.view(self.parameter_shape(x))
+        return torch.where(x >= c, a * x + c * (1 - a), b * x + c * (1 - b))

homa/activations/learnable/ShiLU.py

@@ -0,0 +1,16 @@
+import torch
+from ..ActivationFunction import ActivationFunction
+from .concerns import ChannelBased
+
+
+class ShiLU(ActivationFunction, ChannelBased):
+    def __init__(self):
+        super().__init__()
+        self.a = None
+        self.b = None
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        self.initialize(x, ["a", "b"])
+        a = self.a.view(self.parameter_shape(x))
+        b = self.b.view(self.parameter_shape(x))
+        return torch.relu(x) * a + b

homa/activations/learnable/StarReLU.py

@@ -0,0 +1,16 @@
+import torch
+from ..ActivationFunction import ActivationFunction
+from .concerns import ChannelBased
+
+
+class StarReLU(ActivationFunction, ChannelBased):
+    def __init__(self):
+        super().__init__()
+        self.a = None
+        self.b = None
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        self.initialize(x, ["a", "b"])
+        a = self.a.view(self.parameter_shape(x))
+        b = self.b.view(self.parameter_shape(x))
+        return a * torch.relu(x).pow(2) + b

homa/activations/learnable/__init__.py

@@ -0,0 +1,10 @@
+from .DualLine import DualLine
+from .LeLeLU import LeLeLU
+from .AReLU import AReLU
+from .PERU import PERU
+from .ShiLU import ShiLU
+from .StarReLU import StarReLU
+from .DPReLU import DPReLU
+from .PiLU import PiLU
+from .FReLU import FReLU
+from .AOAF import AOAF

homa/activations/learnable/concerns/ChannelBased.py

@@ -0,0 +1,38 @@
+import torch
+from typing import List
+
+
+class ChannelBased:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._initialized = False
+        self.num_channels = None
+
+    def initialize(
+        self, x: torch.Tensor, attrs: List[str] | str, values: List[float] | float = []
+    ):
+        if getattr(self, "_initialized", False):
+            return
+
+        if not isinstance(values, list):
+            values = [values]
+
+        if not isinstance(attrs, list):
+            attrs = [attrs]
+
+        self.num_channels = x.shape[1]
+        device = x.device
+        for index, attr in enumerate(attrs):
+            if index < len(values) and values[index] is not None:
+                default_value = float(values[index])
+            else:
+                default_value = 1.0
+            param = torch.nn.Parameter(torch.full((self.num_channels,), default_value))
+            param = param.to(device)
+            setattr(self, attr, param)
+        self._initialized = True
+
+    def parameter_shape(self, x: torch.Tensor) -> tuple | None:
+        if hasattr(self, "num_channels"):
+            return (1, self.num_channels) + (1,) * (x.ndim - 2)
+        return None

homa/activations/learnable/concerns/__init__.py

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

homa/cli/Commands/Command.py

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

homa/cli/Commands/InitCommand.py

@@ -0,0 +1,34 @@
+import ast
+from pathlib import Path
+from .Command import Command
+
+
+class InitCommand(Command):
+    @staticmethod
+    def run():
+        path = Path(".")
+        init_file = path / "__init__.py"
+        init_file.write_text("")
+        for file in path.iterdir():
+            if file.name == "__init__.py" or file.suffix != ".py":
+                continue
+            tree = ast.parse(file.read_text())
+            classes = [
+                node.name
+                for node in tree.body
+                if isinstance(node, ast.ClassDef) and not node.name.startswith("_")
+            ]
+            functions = [
+                node.name
+                for node in tree.body
+                if isinstance(node, ast.FunctionDef) and not node.name.startswith("_")
+            ]
+            if not (classes or functions):
+                continue
+            module = file.stem
+            lines = [
+                f"from .{module} import {name}\n" for name in (*classes, *functions)
+            ]
+            with init_file.open("a") as f:
+                f.writelines(lines)
+            print(f"Processed {file}: classes={classes}, functions={functions}")

homa/cli/Commands/__init__.py

@@ -0,0 +1,2 @@
+from .Command import Command
+from .InitCommand import InitCommand

homa/cli/HomaCommand.py

@@ -0,0 +1,16 @@
+import fire
+from .namespaces import MakeNamespace, CacheNamespace
+from .Commands import InitCommand
+
+
+class HomaCommand:
+    def __init__(self):
+        self.make = MakeNamespace()
+        self.cache = CacheNamespace()
+
+    def init(self):
+        InitCommand.run()
+
+
+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/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/ensemble/Ensemble.py

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

homa/ensemble/__init__.py

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

homa/ensemble/concerns/CalculatesMetricNecessities.py

@@ -0,0 +1,24 @@
+import torch
+from ...device import get_device
+
+
+class CalculatesMetricNecessities:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @torch.no_grad()
+    def metric_necessities(self, dataloader):
+        predictions, labels = [], []
+        device = get_device()
+        for x, y in dataloader:
+            x, y = x.to(device), y.to(device)
+            sum_logits = None
+            for model in self.models:
+                model.to(device)
+                model.eval()
+                logits = model(x)
+                sum_logits = logits if sum_logits is None else sum_logits + logits
+            batch_predictions = sum_logits.argmax(dim=1)
+            predictions.extend(batch_predictions.cpu().numpy())
+            labels.extend(y.cpu().numpy())
+        return predictions, labels

homa/ensemble/concerns/PredictsProbabilities.py

@@ -0,0 +1,15 @@
+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)
+
+    @torch.no_grad()
+    def predict_(self, x: torch.Tensor) -> torch.Tensor:
+        return self.predict(x)

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,
+    ReportsEnsembleAccuracy,
+    ReportsEnsembleF1,
+    ReportsEnsembleKappa,
+):
+    pass

homa/ensemble/concerns/ReportsEnsembleAccuracy.py

@@ -0,0 +1,11 @@
+from sklearn.metrics import accuracy_score as accuracy
+from torch.utils.data import DataLoader
+
+
+class ReportsEnsembleAccuracy:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def accuracy(self, dataloader: DataLoader) -> float:
+        predictions, labels = self.metric_necessities(dataloader)
+        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,17 @@
+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
+
+    @torch.no_grad()
+    def logits_(self, *args, **kwargs):
+        return self.logits(*args, **kwargs)

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.models)
+
+    @property
+    def length(self):
+        return len(self.models)