homa 0.2.3__py3-none-any.whl

homa/__init__.py

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

homa/activations/__init__.py

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

homa/activations/classes/APLU.py

@@ -0,0 +1,49 @@
+import torch
+
+
+class APLU(torch.nn.Module):
+    def __init__(
+        self, channels: int | None = None, n: int = 2, init_b: str = "linspace"
+    ):
+        super().__init__()
+        self.n = n
+        self.init_b = init_b
+        if channels is None:
+            self.register_parameter("a", None)
+            self.register_parameter("b", None)
+        else:
+            self._init_params(channels, device=None, dtype=None)
+
+    def _init_params(self, channels, device, dtype):
+        a = torch.zeros(channels, self.n, device=device, dtype=dtype)
+        if self.init_b == "linspace":
+            b = (
+                torch.linspace(-1.0, 1.0, steps=self.n, device=device, dtype=dtype)
+                .expand(channels, -1)
+                .contiguous()
+            )
+        else:
+            b = torch.empty(channels, self.n, device=device, dtype=dtype).uniform_(
+                -1.0, 1.0
+            )
+        self.a = torch.nn.Parameter(a)
+        self.b = torch.nn.Parameter(b)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        if self.a is None or self.b is None:
+            self._init_params(x.shape[1], device=x.device, dtype=x.dtype)
+
+        y = F.relu(x)
+        x_exp = x.unsqueeze(-1)
+        expand_shape = (
+            (
+                1,
+                x.shape[1],
+            )
+            + (1,) * (x.dim() - 2)
+            + (self.n,)
+        )
+        a = self.a.view(*expand_shape)
+        b = self.b.view(*expand_shape)
+        hinges = (-x_exp + b).clamp_max(0.0)
+        return y + (a * hinges).sum(dim=-1)

homa/activations/classes/ActivationFunction.py

@@ -0,0 +1,6 @@
+import torch
+
+
+class ActivationFunction(torch.nn.Module):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)

homa/activations/classes/CaLU.py

@@ -0,0 +1,13 @@
+import torch
+import math
+from .ActivationFunction import ActivationFunction
+
+
+class CaLU(ActivationFunction):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        a = torch.arctan(x) / math.pi
+        b = 0.5
+        return x * (a + b)

homa/activations/classes/ERF.py

@@ -0,0 +1,10 @@
+import torch
+
+
+class ERF(torch.nn.Module):
+    def __init__(self, alpha=1.0):
+        super().__init__()
+        self.alpha = torch.nn.Parameter(torch.tensor(alpha))
+
+    def forward(self, x: torch.Tensor):
+        return x * torch.erf(self.alpha * x)

homa/activations/classes/Elliot.py

@@ -0,0 +1,10 @@
+import torch
+from .ActivationFunction import ActivationFunction
+
+
+class Elliot(ActivationFunction):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return 0.5 + torch.div(0.5 * x, 1 + torch.abs(x))

homa/activations/classes/GCU.py

@@ -0,0 +1,9 @@
+import torch
+
+
+class GCU(torch.nn.Module):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def forward(self, x: torch.Tensor):
+        return x * torch.cos(x)

homa/activations/classes/GaLU.py

@@ -0,0 +1,11 @@
+from .GaussianReLU import GaussianReLU
+
+
+class GaLU(GaussianReLU):
+    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)]
+        super().__init__(self.hats, channels=channels, max_input=max_input)

homa/activations/classes/GaussianReLU.py

@@ -0,0 +1,50 @@
+import torch
+from typing import Sequence, Tuple
+
+
+class GaussianReLU(torch.nn.Module):
+    def __init__(
+        self,
+        alphas_lambdas: Sequence[Tuple[float, float]],
+        channels: int | None = None,
+        max_input: float = 1.0,
+    ):
+        super().__init__()
+        self.M = float(max_input)
+        self.register_buffer(
+            "alphas", torch.tensor([a for a, _ in alphas_lambdas], dtype=torch.float32)
+        )
+        self.register_buffer(
+            "lambdas", torch.tensor([l for _, l in alphas_lambdas], dtype=torch.float32)
+        )
+        self.K = len(alphas_lambdas)
+
+        if channels is None:
+            self.register_parameter("c0", None)  # per-channel (PReLU slope)
+            self.register_parameter("c", None)  # (C, K) coefficients
+        else:
+            self._init_params(channels, None, None)
+
+    def _init_params(self, C: int, device, dtype):
+        self.c0 = torch.nn.Parameter(torch.zeros(C, device=device, dtype=dtype))
+        self.c = torch.nn.Parameter(torch.zeros(C, self.K, device=device, dtype=dtype))
+
+    def _expand_param(p: torch.Tensor, x: torch.Tensor, add_K: bool = False):
+        shape = (
+            (1, x.shape[1]) + (1,) * (x.dim() - 2) + ((p.shape[-1],) if add_K else ())
+        )
+        return p.view(shape)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        if self.c0 is None or self.c is None:
+            self._init_params(x.shape[1], x.device, x.dtype)
+        c0 = self._expand_param(self.c0, x)
+        y = torch.nn.functional.relu(x) - c0 * torch.nn.functional.relu(-x)
+        a = self.alphas.to(x.device, x.dtype).view(*((1,) * x.dim()), -1)
+        l = self.lambdas.to(x.device, x.dtype).view(*((1,) * x.dim()), -1)
+        xE = x.unsqueeze(-1)
+        term1 = (l * self.M - (xE - a * self.M).abs()).clamp_min(0.0)
+        term2 = ((xE - a * self.M - 2 * l * self.M).abs() - l * self.M).clamp_max(0.0)
+        hats = term1 + term2
+        c = self._expand_param(self.c, x, add_K=True)  # (1,C,...,K)
+        return y + (c * hats).sum(dim=-1)

homa/activations/classes/LaLU.py

@@ -0,0 +1,11 @@
+import torch
+from .ActivationFunction import ActivationFunction
+
+
+class LaLU(ActivationFunction):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        phi_laplace = torch.where(x >= 0, 1 - 0.5 * torch.exp(-x), 0.5 * torch.exp(x))
+        return x * phi_laplace

homa/activations/classes/Logish.py

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

homa/activations/classes/MeLU.py

@@ -0,0 +1,11 @@
+from .MexicanReLU import MexicanReLU
+
+
+class MeLU(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),
+        ]
+        super().__init__(self.hats, channels=channels, max_input=max_input)

homa/activations/classes/MexicanReLU.py

@@ -0,0 +1,49 @@
+import torch
+from typing import Sequence, Tuple
+
+
+class MexicanReLU(torch.nn.Module):
+    def __init__(
+        self,
+        alphas_lambdas: Sequence[Tuple[float, float]],
+        channels: int | None = None,
+        max_input: float = 1.0,
+    ):
+        super().__init__()
+        self.M = float(max_input)
+        self.register_buffer(
+            "alphas", torch.tensor([a for a, _ in alphas_lambdas], dtype=torch.float32)
+        )
+        self.register_buffer(
+            "lambdas", torch.tensor([l for _, l in alphas_lambdas], dtype=torch.float32)
+        )
+        self.K = len(alphas_lambdas)
+
+        if channels is None:
+            self.register_parameter("c0", None)  # PReLU negative slope (per-channel)
+            self.register_parameter("c", None)  # (C, K) coefficients
+        else:
+            self._init_params(channels, device=None, dtype=None)
+
+    def _init_params(self, C: int, device, dtype):
+        self.c0 = torch.nn.Parameter(torch.zeros(C, device=device, dtype=dtype))
+        self.c = torch.nn.Parameter(torch.zeros(C, self.K, device=device, dtype=dtype))
+
+    def _expand_param(p: torch.Tensor, x: torch.Tensor, n_extra: int = 0):
+        shape = (
+            (1, x.shape[1]) + (1,) * (x.dim() - 2) + ((p.shape[-1],) if n_extra else ())
+        )
+        return p.view(shape)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        if self.c0 is None or self.c is None:
+            self._init_params(x.shape[1], x.device, x.dtype)
+        c0 = self._expand_param(self.c0, x)
+        y = F.relu(x) - c0 * F.relu(-x)
+        xE = x.unsqueeze(-1)
+        cE = self._expand_param(self.c, x, n_extra=1)
+        aE = self.alphas.to(x.device, x.dtype).view(*((1,) * x.dim()), -1)  # (..., K)
+        lE = self.lambdas.to(x.device, x.dtype).view(*((1,) * x.dim()), -1)  # (..., K)
+        hats = (lE * self.M - (xE - aE * self.M).abs()).clamp_min(0.0)
+        y = y + (cE * hats).sum(dim=-1)
+        return y

homa/activations/classes/SGELU.py

@@ -0,0 +1,12 @@
+import torch
+import math
+from .ActivationFunction import ActivationFunction
+
+
+class SGELU(ActivationFunction):
+    def __init__(self, alpha: float = 0.1, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.alpha = alpha
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.alpha * x * torch.erf(x / math.sqrt(2))

homa/activations/classes/SReLU.py

@@ -0,0 +1,37 @@
+import torch
+
+
+class SReLU(torch.nn.Module):
+    def __init__(self, channels: int | None = None, max_input: float = 1.0):
+        super().__init__()
+        self.M = float(max_input)
+        if channels is None:
+            self.register_parameter("t_l", None)
+            self.register_parameter("t_r", None)
+            self.register_parameter("a_l", None)
+            self.register_parameter("a_r", None)
+        else:
+            self._init_params(channels, None, None)
+
+    def _init_params(self, C: int, device, dtype):
+        self.t_l = torch.nn.Parameter(torch.zeros(C, device=device, dtype=dtype))
+        self.t_r = torch.nn.Parameter(
+            torch.full((C,), self.M, device=device, dtype=dtype)
+        )
+        self.a_l = torch.nn.Parameter(torch.zeros(C, device=device, dtype=dtype))
+        self.a_r = torch.nn.Parameter(torch.ones(C, device=device, dtype=dtype))
+
+    def _expand_param(p: torch.Tensor, x: torch.Tensor):
+        return p.view((1, x.shape[1]) + (1,) * (x.dim() - 2))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        if self.t_l is None:
+            self._init_params(x.shape[1], x.device, x.dtype)
+
+        t_l = self._expand_param(self.t_l, x)
+        t_r = self._expand_param(self.t_r, x)
+        a_l = self._expand_param(self.a_l, x)
+        a_r = self._expand_param(self.a_r, x)
+        y = torch.where(x < t_l, t_l + a_l * (x - t_l), x)
+        y = torch.where(x > t_r, t_r + a_r * (x - t_r), y)
+        return y

homa/activations/classes/SmallGaLU.py

@@ -0,0 +1,11 @@
+from .GaussianReLU import GaussianReLU
+
+
+class SmallGaLU(GaussianReLU):
+    def __init__(
+        self,
+        channels: int | None = None,
+        max_input: float = 1.0,
+    ):
+        self.hats = [(2.0, 2.0)]
+        super().__init__(self.hats, channels=channels, max_input=max_input)

homa/activations/classes/Smish.py

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

homa/activations/classes/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/classes/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/classes/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/classes/__init__.py

@@ -0,0 +1,19 @@
+from .ActivationFunction import ActivationFunction
+from .APLU import APLU
+from .CaLU import CaLU
+from .Elliot import Elliot
+from .ERF import ERF
+from .GaLU import GaLU
+from .GaussianReLU import GaussianReLU
+from .GCU import GCU
+from .LaLU import LaLU
+from .Logish import Logish
+from .MeLU import MeLU
+from .MexicanReLU import MexicanReLU
+from .SGELU import SGELU
+from .SmallGaLU import SmallGaLU
+from .Smish import Smish
+from .SReLU import SReLU
+from .TeLU import TeLU
+from .TripleStateSwish import TripleStateSwish
+from .WideMeLU import WideMeLU

homa/activations/utils.py

@@ -0,0 +1,22 @@
+import torch
+from typing import Type
+
+
+def replace_layers(
+    module: torch.nn.Module,
+    target_class: Type[torch.nn.Module],
+    replacement_class: Type[torch.nn.Module],
+) -> None:
+    for name, child in module.named_children():
+        if isinstance(child, target_class):
+            inplace = getattr(child, "inplace", False)
+            try:
+                new_layer = replacement_class(inplace=inplace)
+            except TypeError:
+                try:
+                    new_layer = replacement_class()
+                except:
+                    continue
+            setattr(module, name, new_layer)
+        else:
+            replace_layers(child, target_class, replacement_class)

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/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)

homa/ensemble/concerns/StoresModels.py

@@ -0,0 +1,29 @@
+import torch
+from copy import deepcopy
+from typing import List
+from ...vision import Model
+
+
+class StoresModels:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.models: List[torch.nn.Module] = []
+
+    def record(self, model: Model | torch.nn.Module):
+        model_: torch.nn.Module | None = None
+        if isinstance(model, Model):
+            model_ = deepcopy(model.network)
+        elif isinstance(model, torch.nn.Module):
+            model_ = deepcopy(model)
+        else:
+            raise TypeError("Wrong input to ensemble record")
+        self.models.append(model_)
+
+    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/__init__.py

@@ -0,0 +1,9 @@
+from .CalculatesMetricNecessities import CalculatesMetricNecessities
+from .PredictsProbabilities import PredictsProbabilities
+from .ReportsClassificationMetrics import ReportsClassificationMetrics
+from .ReportsEnsembleAccuracy import ReportsEnsembleAccuracy
+from .ReportsEnsembleF1 import ReportsEnsembleF1
+from .ReportsEnsembleKappa import ReportsEnsembleKappa
+from .ReportsLogits import ReportsLogits
+from .ReportsSize import ReportsSize
+from .StoresModels import StoresModels

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/loss/Loss.py

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

homa/loss/__init__.py

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

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

@@ -0,0 +1 @@
+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/Classifier.py

@@ -0,0 +1,5 @@
+from .Model import Model
+
+
+class Classifier(Model):
+    pass

homa/vision/Model.py

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

homa/vision/Resnet.py

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

homa/vision/StochasticClassifier.py

@@ -0,0 +1,23 @@
+import torch
+from ..activations import SGELU, LaLU, CaLU, TripleStateSwish
+
+
+class StochasticClassifier:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._activation_pool = [
+            torch.nn.ELU,
+            torch.nn.PReLU,
+            torch.nn.ReLU,
+            torch.nn.ReLU6,
+            torch.nn.RReLU,
+            torch.nn.SELU,
+            torch.nn.CELU,
+            torch.nn.GELU,
+            torch.nn.SiLU,
+            torch.nn.Mish,
+            SGELU,
+            LaLU,
+            CaLU,
+            TripleStateSwish,
+        ]

homa/vision/StochasticResnet.py

@@ -0,0 +1,10 @@
+import torch
+from .Resnet import Resnet
+from .StochasticClassifier import StochasticClassifier
+from .utils import replace_activations
+
+
+class StochasticResnet(Resnet, StochasticClassifier):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        replace_activations(self.network, torch.nn.ReLU, self._activation_pool)

homa/vision/StochasticSwin.py

@@ -0,0 +1,10 @@
+import torch
+from .Swin import Swin
+from .StochasticClassifier import StochasticClassifier
+from .utils import replace_activations
+
+
+class StochasticSwin(Swin, StochasticClassifier):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        replace_activations(self.network, torch.nn.GELU, self._activation_pool)

homa/vision/Swin.py

@@ -0,0 +1,12 @@
+import torch
+from .Classifier import Classifier
+from .concerns import Trainable, ReportsMetrics
+from .modules import SwinModule
+
+
+class Swin(Classifier, 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/vision/__init__.py

@@ -0,0 +1,5 @@
+from .Classifier import Classifier
+from .Model import Model
+from .Resnet import Resnet
+from .StochasticResnet import StochasticResnet
+from .Swin import Swin

homa/vision/concerns/HasLabels.py

@@ -0,0 +1,13 @@
+import torch
+
+
+class HasLabels:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def predict(self, x: torch.Tensor):
+        return torch.argmax(self.logits(x), dim=1)
+
+    @torch.no_grad()
+    def predict_(self, x: torch.Tensor):
+        return torch.argmax(self.logits(x), dim=1)

homa/vision/concerns/HasLogits.py

@@ -0,0 +1,12 @@
+import torch
+
+
+class HasLogits:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def logits(self, x: torch.Tensor) -> torch.Tensor:
+        return self.network(x)
+
+    def logits_(self, x: torch.Tensor) -> torch.Tensor:
+        return self.network(x)

homa/vision/concerns/HasProbabilities.py

@@ -0,0 +1,9 @@
+import torch
+
+
+class HasProbabilities:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def probabilities(self, x: torch.Tensor):
+        return torch.softmax(self.logits(x), dim=1)

homa/vision/concerns/ReportsAccuracy.py

@@ -0,0 +1,27 @@
+from torch import Tensor, no_grad
+from torch.utils.data.dataloader import DataLoader
+from ...device import get_device
+
+
+class ReportsAccuracy:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def accuracy_tensors(self, x: Tensor, y: Tensor) -> float:
+        predictions = self.predict_(x)
+        return (predictions == y).float().mean().item()
+
+    def accuracy_dataloader(self, dataloader: DataLoader):
+        correct, total = 0, 0
+        for x, y in dataloader:
+            x, y = x.to(get_device()), y.to(get_device())
+            predictions = self.predict_(x)
+            correct += (predictions == y).sum().item()
+            total += y.numel()
+        return correct / total if total > 0 else 0.0
+
+    def accuracy(self, x: Tensor | DataLoader, y: Tensor | None = None) -> float:
+        self.network.eval()
+        if isinstance(x, DataLoader):
+            return self.accuracy_dataloader(x)
+        return self.accuracy_tensors(x, y)

homa/vision/concerns/ReportsMetrics.py

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

homa/vision/concerns/Trainable.py

@@ -0,0 +1,29 @@
+from torch import Tensor
+from torch.utils.data.dataloader import DataLoader
+from .HasLogits import HasLogits
+from .HasProbabilities import HasProbabilities
+from .HasLabels import HasLabels
+from ...device import get_device
+
+
+class Trainable(HasLogits, HasProbabilities, HasLabels):
+    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(self.network(x).float(), 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,6 @@
+from .HasLabels import HasLabels
+from .HasLogits import HasLogits
+from .HasProbabilities import HasProbabilities
+from .ReportsAccuracy import ReportsAccuracy
+from .ReportsMetrics import ReportsMetrics
+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/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/vision/modules/__init__.py

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

homa/vision/utils.py

@@ -0,0 +1,12 @@
+import torch
+import random
+
+
+def replace_activations(module, needle: torch.nn.Module, candidates: list):
+    for name, module in module.named_children():
+        if isinstance(module, needle):
+            factory = random.choice(candidates)
+            new_module = factory()
+            setattr(module, name, new_module)
+        else:
+            replace_activations(module, needle, candidates)

homa-0.2.3.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: homa
+Version: 0.2.3
+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
+
+# Core
+
+### 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())
+```
+
+# Vision
+
+## Resnet
+
+This is the standard ResNet50 module.
+
+You can train the model with a `DataLoader` object.
+
+```py
+from homa.vision import Resnet
+
+model = Resnet(num_classes=10, lr=0.001)
+for epoch in range(10):
+    model.train(train_dataloader)
+```
+
+Similarly you can manually take care of decomposition of data from the `DataLoader`.
+
+```py
+from homa.vision import Resnet
+
+model = Resnet(num_classes=10, lr=0.001)
+for epoch in range(10):
+    for x, y in train_dataloader:
+        model.train(x, y)
+```
+
+## StochasticResnet
+
+This is a ResNet module whose activation functions are replaced from a pool of different activation functions randomly. Read more on the [(paper)](https://www.mdpi.com/1424-8220/22/16/6129).
+
+You can train the model with a `DataLoader` object.
+
+```py
+from homa.vision import StochasticResnet
+
+model = StochasticResnet(num_classes=10, lr=0.001)
+for epoch in range(10):
+    model.train(train_dataloader)
+```
+
+Similarly you can manually take care of decomposition of data from the `DataLoader`.
+
+```py
+from homa.vision import StochasticResnet
+
+model = StochasticResnet(num_classes=10, lr=0.001)
+for epoch in range(10):
+    for x, y in train_dataloader:
+        model.train(x, y)
+```

homa-0.2.3.dist-info/RECORD

@@ -0,0 +1,71 @@
+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=4Tw5gdeWcxtOeAHVUb0sH1fjy3E0GPe-Z_2DfQQfNU0,695
+homa/activations/classes/APLU.py,sha256=cUf6LUjY8TewXe_V1avO_7IcOtY66Hd6Dyk_1K4R3Ms,1555
+homa/activations/classes/ActivationFunction.py,sha256=XUw7Pa5E-CPG6rPL8Us_pDH7xCZqY0c2P9xtnJMyX44,141
+homa/activations/classes/CaLU.py,sha256=n0drKwp4GstHql69p4S58KeVctdaQ1B5oK_AIoI_okk,331
+homa/activations/classes/ERF.py,sha256=tDgHbo7UNFU93XPlcQCBRRxPMksr-FOE19mlsqfzmU8,252
+homa/activations/classes/Elliot.py,sha256=RDxERH9vFh6FYwtZXKHMDmLVG2ia1UfOoW18Gm2_8hM,298
+homa/activations/classes/GCU.py,sha256=hXwty6WPovnhPGAxQDd4bIixujdoMOORN-77imVri7s,199
+homa/activations/classes/GaLU.py,sha256=5QHnHsUsLAy28s-LTxtwRN-t1hO1tg9xtWmkzE1T7Ck,308
+homa/activations/classes/GaussianReLU.py,sha256=ufNeVnod6dxkPLmdd9ye-xt0SIWap2dehX14_YxSZVM,2051
+homa/activations/classes/LaLU.py,sha256=UiulXzSTmnoU_Gp8qKigFoL6efonqbldUlsBBlm9mB8,356
+homa/activations/classes/Logish.py,sha256=DQzmqSoCN6V1HTbwpWPDnft7EEg1lSU5uCBNQY3J6t8,187
+homa/activations/classes/MeLU.py,sha256=f13h2AAQCwp9soR3RWbMAA4Bl38oqRdBAsdzh6Bf4k8,321
+homa/activations/classes/MexicanReLU.py,sha256=vfDa1lWI-PgY4ztDY34aeBMaJ2rOyAYt5ifZBG0DS0c,1946
+homa/activations/classes/SGELU.py,sha256=AaNmXRoFQ68Xsgt4sSWMZxnSCTR5OD5ZEuqxxg1mvfg,358
+homa/activations/classes/SReLU.py,sha256=xyChK3G2HPpM7C8icQNfMzrOm142boDLY31n9yXqPtg,1472
+homa/activations/classes/SmallGaLU.py,sha256=ERrK-g3QMZTNFDzUyiSLAovymEpV5h1x1696CN5K4Zg,289
+homa/activations/classes/Smish.py,sha256=hsr5FS4KywsCmsuFUKP-4pKoXkJK0hhRVDleq_CFGX0,198
+homa/activations/classes/TeLU.py,sha256=qU5x0EskjQs6d5rCtbL91C6cMAm8vjDnjQNMX0LcEt8,180
+homa/activations/classes/TripleStateSwish.py,sha256=UG5BGY29wUEJaryClB2rDM90s0jt5vMJF9Kv-5M4Rgo,507
+homa/activations/classes/WideMeLU.py,sha256=ieJjTjnK9JJtApPFGpmTynu3G8YlyH5jw6qnhkJkStI,421
+homa/activations/classes/__init__.py,sha256=A3tViJPce5NM1sLA6C2_sacUB63_uUsNqVq1vBV2NZ4,547
+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=GNkXEV7Nli8lHSTQ3qTTCTeSBwST1PLZS5wxpKpeC5U,290
+homa/ensemble/__init__.py,sha256=1pk2W-NbgfDFh9WLKZVLUk2E3PTjVZ5Bap9dQEnrs9o,31
+homa/ensemble/concerns/CalculatesMetricNecessities.py,sha256=QccROg_FOp_X2T_lZDg8p1DMZhPYdO-7aEdnebRXMsY,825
+homa/ensemble/concerns/PredictsProbabilities.py,sha256=7rmI66DzE7-QGoJgZEk-9fu5YQvJW-4ZnMn_dWEEhqU,440
+homa/ensemble/concerns/ReportsClassificationMetrics.py,sha256=bg__cdCKp2U1H9qN1aOJH4BoX98oIvt8XaPDGApJhSM,395
+homa/ensemble/concerns/ReportsEnsembleAccuracy.py,sha256=AX5X3VGOm7DfdonW0N7FFgUwEr7wnsojRSVEULEii7c,380
+homa/ensemble/concerns/ReportsEnsembleF1.py,sha256=hdtdCQrWaFJNUn1KP9cAmi_q_EA4FYnpkBMlYLjzRZg,296
+homa/ensemble/concerns/ReportsEnsembleKappa.py,sha256=ZRbtrFCTD84EDql6ZL1xeWtTLFxpO5Y5tQaUlR6_0jw,300
+homa/ensemble/concerns/ReportsLogits.py,sha256=vTGuC9NR4rno3Mkbm0MhL8f7YopuCErGyjIorxamKTM,461
+homa/ensemble/concerns/ReportsSize.py,sha256=S7lo_Wu6rDnuqyAcv6AI6jspaBhcpfsirpp9RVD8c20,238
+homa/ensemble/concerns/StoresModels.py,sha256=PNoaoAOx4v8rercxXHmf7zqVIPGYM4APzIHHEb3RwT0,850
+homa/ensemble/concerns/__init__.py,sha256=X0F_b2Jsv0XpiNhYwJsl-dfPsBOdEeW53LQPE4xQD0w,479
+homa/loss/LogitNormLoss.py,sha256=LJMzRA1WoJ7aDYTV-FYGhgo8DMkcpv7e8_74qiJ4zT8,386
+homa/loss/Loss.py,sha256=COUr_idShYgAP8xKCxcaXbyUyAoJg7IOON0ARTQykmQ,21
+homa/loss/__init__.py,sha256=4mPVzme2_-M64bgBu1cANIfBFAL0voa5I71-ceMr_qk,64
+homa/torch/__init__.py,sha256=HTxCVaw1TLgpHMH8guB3hHYQ80cX6_fSEoPT_hz2Y8w,23
+homa/torch/helpers.py,sha256=CLbTCXRrroM0n4PfM-K_xFavs4dCZJEu_L7hdgb1DCI,134
+homa/vision/Classifier.py,sha256=bAypqREQVuPamnc8hpbLCwmW9Uly3T1rvrlbMxXp1eA,61
+homa/vision/Model.py,sha256=JIeVpHJwirHfsDfYYbLsu0kt7bGf4nhMQGIOagUDKw4,22
+homa/vision/Resnet.py,sha256=Uitf58bEzIKkZd-F4FTvJ8nmhoFHlzZjJTvBPXEt2Iw,513
+homa/vision/StochasticClassifier.py,sha256=dQaN0hYZYRRj5OrSJ-g_gj4pQw-KbjHzoak2sYjs07g,589
+homa/vision/StochasticResnet.py,sha256=cEL_wbMAy_TbINOlHGDQIalWfIb_GR4m7s-XkecQknY,353
+homa/vision/StochasticSwin.py,sha256=tV6g0NF9aMGEVyFRJjXLGkke4VpzcZjsLMkH9AKPCVM,345
+homa/vision/Swin.py,sha256=6_lkPjgNt5d8TtMJ-LFwDtFt5DQkB4hXs3n7SiaglvU,459
+homa/vision/__init__.py,sha256=byjM7ZijxY-FzukuohutbZKb2g7qgIMEKXYrtAx0MQU,157
+homa/vision/utils.py,sha256=vKpkP_-8VvoxNc8s6oVtdhTM2TScYrj8C25zld3nnko,396
+homa/vision/concerns/HasLabels.py,sha256=fM6nHLeQaEaWDlV6R8NQ5hgOSiwspPxOIwj-nvYXbP0,321
+homa/vision/concerns/HasLogits.py,sha256=oStX4NCV7zwxI7Vj23M8wQSlY1xoSmAYJ_6cBNJpVCk,290
+homa/vision/concerns/HasProbabilities.py,sha256=m1_ObS2BNYO-WVCNVMiHXzC3XAsyb88_0N4BWVDwCw0,221
+homa/vision/concerns/ReportsAccuracy.py,sha256=DD0YTr5i8JMllIJTQn88Dn711yjZ2uiecaTi7WqpOEw,986
+homa/vision/concerns/ReportsMetrics.py,sha256=93Hw_JBUbwfkrJNJA1xFSQ4cqRwzbSv4nPU524PGF6I,169
+homa/vision/concerns/Trainable.py,sha256=SRCW3XpG9_DQgubyqhALlYDHwAWNzVVFjshUv1ecuEQ,988
+homa/vision/concerns/__init__.py,sha256=mrw1YvN-GpQPvMwDF00KxnFkksPKo23RWM4KRioURsg,234
+homa/vision/modules/ResnetModule.py,sha256=eFudBnILD6OmgQtcW_CQQ8aZ62NEa4HyZ15-lobTtt0,712
+homa/vision/modules/SwinModule.py,sha256=h7wq1YdKoN6-7C3FVFA0bpkAET_30002iTRbjZxziFQ,714
+homa/vision/modules/__init__.py,sha256=zVMYB9IAO_xZylC1-N3p8ymHgEkAE2sBbuVz8K5Y1kk,74
+homa-0.2.3.dist-info/METADATA,sha256=W_8QUBx6Ii1kJf6eMXy9SfkYAW9n6FbYs_q9JuYM_Qc,1759
+homa-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+homa-0.2.3.dist-info/entry_points.txt,sha256=tJZzjs-f2QvFe3ES8Qta8IE5sAbeE8-cyZ_UtbgqG4s,51
+homa-0.2.3.dist-info/top_level.txt,sha256=tmOfy2tuaAwc3W5-i6j61_vYJsXgR4ivBWkhJ3ZtJDc,5
+homa-0.2.3.dist-info/RECORD,,

homa-0.2.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

homa-0.2.3.dist-info/entry_points.txt

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

homa-0.2.3.dist-info/top_level.txt

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