homa 0.2.94__py3-none-any.whl

homa/ensemble/concerns/StoresModels.py

@@ -0,0 +1,36 @@
+import torch
+import io
+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")
+
+        device = model_.device
+        buffer = io.BytesIO()
+        torch.save(model_.to("cpu"), buffer)
+        buffer.seek(0)
+        model_ = torch.load(buffer, map_location=device)
+        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,29 @@
+from ..activations import (
+    AOAF,
+    AReLU,
+    DPReLU,
+    DualLine,
+    FReLU,
+    LeLeLU,
+    PERU,
+    PiLU,
+    ShiLU,
+    StarReLU,
+)
+
+
+class StochasticClassifier:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._activation_pool = [
+            AOAF,
+            AReLU,
+            DPReLU,
+            DualLine,
+            FReLU,
+            LeLeLU,
+            PERU,
+            PiLU,
+            ShiLU,
+            StarReLU,
+        ]

homa/vision/StochasticSwin.py

@@ -0,0 +1,11 @@
+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)
+        replace_activations(self.network, torch.nn.ReLU, self._activation_pool)

homa/vision/Swin.py

@@ -0,0 +1,13 @@
+import torch
+from .Classifier import Classifier
+from .concerns import Trainable, ReportsMetrics
+from .modules import SwinModule
+from ..device import get_device
+
+
+class Swin(Classifier, Trainable, ReportsMetrics):
+    def __init__(self, num_classes: int, lr: float = 0.0001):
+        super().__init__()
+        self.network = SwinModule(num_classes=num_classes).to(get_device())
+        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 .Swin import Swin
+from .StochasticSwin import StochasticSwin

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, child in module.named_children():
+        if isinstance(child, needle):
+            new_activation = random.choice(candidates)
+            setattr(module, name, new_activation())
+        else:
+            replace_activations(child, needle, candidates)
+    return module

homa-0.2.94.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: homa
+Version: 0.2.94
+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.94.dist-info/RECORD

@@ -0,0 +1,113 @@
+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/APLU.py,sha256=cUf6LUjY8TewXe_V1avO_7IcOtY66Hd6Dyk_1K4R3Ms,1555
+homa/activations/ActivationFunction.py,sha256=XUw7Pa5E-CPG6rPL8Us_pDH7xCZqY0c2P9xtnJMyX44,141
+homa/activations/AdaptiveActivationFunction.py,sha256=p_bqAq7527UOhVm47kdUtgdC1DlApxgiLOA4ZPBFdCE,386
+homa/activations/BaseDLReLU.py,sha256=iRmDhhbFaO8N9G8u5M01s8-y-09t7poP96oA6uQkVq8,1186
+homa/activations/CaLU.py,sha256=n0drKwp4GstHql69p4S58KeVctdaQ1B5oK_AIoI_okk,331
+homa/activations/DLReLU.py,sha256=Q8l2zpR5q_tSgfgbz90uDXbXMbBT3b_7BWKw6JbtpQE,191
+homa/activations/ERF.py,sha256=tDgHbo7UNFU93XPlcQCBRRxPMksr-FOE19mlsqfzmU8,252
+homa/activations/Elliot.py,sha256=RDxERH9vFh6FYwtZXKHMDmLVG2ia1UfOoW18Gm2_8hM,298
+homa/activations/ExpExpish.py,sha256=iq_uOmmV9EIz2eKowEy7SCeW-OMgGcEeMcivTnPc-Y0,202
+homa/activations/ExponentialDLReLU.py,sha256=aVtah3c4sokB-aSdbVa5F_uq06IyXHwovnHtXlKGYlw,199
+homa/activations/ExponentialSwish.py,sha256=nJtGu1TRHa2GSQ35w2MN0HEWzFogVvA9R2pGEkFvJX4,266
+homa/activations/GCU.py,sha256=hXwty6WPovnhPGAxQDd4bIixujdoMOORN-77imVri7s,199
+homa/activations/GaLU.py,sha256=5QHnHsUsLAy28s-LTxtwRN-t1hO1tg9xtWmkzE1T7Ck,308
+homa/activations/GaussianReLU.py,sha256=ufNeVnod6dxkPLmdd9ye-xt0SIWap2dehX14_YxSZVM,2051
+homa/activations/GeneralizedSwish.py,sha256=zv6CX83cOTVnN0yoCIXIvIgkjXLnmm_T_LsvyoN7lOY,236
+homa/activations/Gish.py,sha256=Xohk5tTmeGTmQ4PXtHF5sPBDikmoNTjdEJzy2KPDmOI,249
+homa/activations/LaLU.py,sha256=UiulXzSTmnoU_Gp8qKigFoL6efonqbldUlsBBlm9mB8,356
+homa/activations/LogLogish.py,sha256=lfVRNhnDGbYYakTsUmePmr5azkzz_NQwEy6NvSSD-Do,205
+homa/activations/LogSigmoid.py,sha256=PUvr84dRRd6L-VZ_9UeWAN9lhUFr2Otj8VrAIQ3eOEM,239
+homa/activations/Logish.py,sha256=CnL-10b76C2EaDm56N4n2GYCaYJUKl_k7H82UBJI5to,257
+homa/activations/MeLU.py,sha256=f13h2AAQCwp9soR3RWbMAA4Bl38oqRdBAsdzh6Bf4k8,321
+homa/activations/MexicanReLU.py,sha256=vfDa1lWI-PgY4ztDY34aeBMaJ2rOyAYt5ifZBG0DS0c,1946
+homa/activations/MinSin.py,sha256=JzQsmuffRAGGcD40nlz2ZnOGhQMEU0JYBIeFHIC1qcE,250
+homa/activations/NReLU.py,sha256=mX4B2OXw28M8zyd6RpkaSoOCGZuB3FaksO4oFyr3YD8,314
+homa/activations/NoisyReLU.py,sha256=2YFkOS_h8EijvCugYQTfq_gQg5uNEkcypcm0iDgEHIg,134
+homa/activations/PLogish.py,sha256=ia_V0xewAS6mmX3G8JNQTxWl66ea8P3MuRLQkEPv-I8,165
+homa/activations/ParametricLogish.py,sha256=grCGG61xTDytA4iOK3kS70V9m2bYoiSmuilJV3U8vIw,360
+homa/activations/Phish.py,sha256=CLAV1fLHRAq-GxBut-_FsSYJRMlk5sOFVlcXs3G3w9c,280
+homa/activations/RReLU.py,sha256=ILpkmoWk8WatXusrPqSLu15xMWQALwRQVZjhzwmw1PM,476
+homa/activations/RandomizedSlopedReLU.py,sha256=O20XX3vRRmkERxwhLSNgue-fn0qSRoF7rlIN1LSWlyI,169
+homa/activations/SGELU.py,sha256=AaNmXRoFQ68Xsgt4sSWMZxnSCTR5OD5ZEuqxxg1mvfg,358
+homa/activations/SReLU.py,sha256=xyChK3G2HPpM7C8icQNfMzrOm142boDLY31n9yXqPtg,1472
+homa/activations/SelfArctan.py,sha256=Sq3yWGXjxdP32J-rSZ38BQ5S_XErr5H1ZyPsMF1VKfI,193
+homa/activations/ShiftedReLU.py,sha256=JVsf2F6C13PRICjnVOSVEsx9IoQ9rcM2TFn55DguZQs,229
+homa/activations/SigmoidDerivative.py,sha256=4PPT-QX4MW9ySKU4Qv9K-y--lxlqFxvKVviC2S3e6Z0,274
+homa/activations/SineReLU.py,sha256=gzYF1ZEZAFYmUuABWJf18LIer1oPAS38i_5NLcIhP-I,357
+homa/activations/SlopedReLU.py,sha256=j6YfM4msg6It-ANbpMzEaXkiHvgEdhFNFbB6NkY6KpE,421
+homa/activations/SmallGaLU.py,sha256=ERrK-g3QMZTNFDzUyiSLAovymEpV5h1x1696CN5K4Zg,289
+homa/activations/Smish.py,sha256=hsr5FS4KywsCmsuFUKP-4pKoXkJK0hhRVDleq_CFGX0,198
+homa/activations/SoftsignRReLU.py,sha256=bBSjYDLUVKxXPyaJExYXndEO3oORnP3M6NKoU-hiCCQ,564
+homa/activations/Suish.py,sha256=I459CV24NV1JlLbko4oHUOh98fxoLaM-2SH71pVMcwA,279
+homa/activations/TBSReLU.py,sha256=ZfYY_M6msDimJAOHr1HyrG1HHnWiJ7hnZ5hWjCFPecU,320
+homa/activations/TSReLU.py,sha256=gbU0Q7zhf3X6oWvKUSry6sVdRhuaxIQt8keFH3WsxV8,256
+homa/activations/TangentBipolarSigmoidReLU.py,sha256=YtrFHkFbEbx7aeIpIRc9TLCxhpveUFSgAnvTKaKLZ4E,156
+homa/activations/TangentSigmoidReLU.py,sha256=C47UK6ADWsG2ueaZe9FUt-sPBzeuBLkiNjpkDZOCYGc,146
+homa/activations/TeLU.py,sha256=qU5x0EskjQs6d5rCtbL91C6cMAm8vjDnjQNMX0LcEt8,180
+homa/activations/TripleStateSwish.py,sha256=UG5BGY29wUEJaryClB2rDM90s0jt5vMJF9Kv-5M4Rgo,507
+homa/activations/WideMeLU.py,sha256=ieJjTjnK9JJtApPFGpmTynu3G8YlyH5jw6qnhkJkStI,421
+homa/activations/__init__.py,sha256=2GHNqrOp6WoLAtFFJcSj6j4GP-W8-YAYRZGX9vZbcmU,1659
+homa/activations/learnable/AOAF.py,sha256=1ArhgpI6PfCRePgvFq8VqKDQ9rDMHZb0bm6g4Tiz13s,510
+homa/activations/learnable/AReLU.py,sha256=Pfyv_7EEwGgW4_UyKc8CiSg7lhTcO7LZ7uIUeVQWLpA,737
+homa/activations/learnable/DPReLU.py,sha256=xQhYTJ0-mfRGdld950xoTh8c9O08WIY50K0FjPtVVFs,507
+homa/activations/learnable/DualLine.py,sha256=cgqyE7dVqXflT8ulCuOyKQQa09FYSj8vJkeVUEOaeIU,600
+homa/activations/learnable/FReLU.py,sha256=qQ8GjjWWGeoE6qW9tw49mZPs29app0QK1AFOuMc5ASU,413
+homa/activations/learnable/LeLeLU.py,sha256=ya2m60QRcpVlTwMejJTgMTxM3RRHF0RgNe72_EdD1-U,425
+homa/activations/learnable/PERU.py,sha256=y2OxRLIA1HTUnFyRHs0zgLhLMJhQz9Q4F6QrqBSkQ00,513
+homa/activations/learnable/PiLU.py,sha256=w7LkBBs_hr07pvizUie5Z49UkHg3O8LHA-wFK4hbnjE,612
+homa/activations/learnable/ShiLU.py,sha256=35VC1pCAWMaxHKWYBeXd2DrXn1tepvQaT7a-KwoNdHY,475
+homa/activations/learnable/StarReLU.py,sha256=hrscp-A0HnIvebFPLGr86K5Uf_U--EWtpNDqdNgonA0,485
+homa/activations/learnable/__init__.py,sha256=yDzcgM_n5sNEU0kz9I0aVgGihpw_2RvtkCCylaTCPEQ,260
+homa/activations/learnable/concerns/ChannelBased.py,sha256=pSKnWOKVOdb0GoiBobSSUANaZPGNwT9rxBnJUpZ9Eac,1206
+homa/activations/learnable/concerns/__init__.py,sha256=CubRRYQEQMAK2-igsYKD8tcyesPOYoZYF_IlHzRZXi4,39
+homa/cli/HomaCommand.py,sha256=w-Dg6dFpoXbQx2tvWSLdND2pdhqB2cPSORyi4MfY8XY,307
+homa/cli/Commands/Command.py,sha256=DnmsEwpaxdQaLjzyYBO7qtIQTLwYzyhJS31YazA1IHg,24
+homa/cli/Commands/InitCommand.py,sha256=3whh2mWLuevXpUyRpDEMbo_KNeAIdO2aLMFnC2nz_0c,1159
+homa/cli/Commands/__init__.py,sha256=PYKkcG06R5LqLnp2x8otuimzRpL4oMbziL3xEMkCffc,66
+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=VWTBZbRepa_AW82BX5FMhTlUZ0OFthiRPY71Rvx0mYs,1047
+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=6-o0TaH4iWXiPFefL7DOdLr3ZrTnjnJ9PIgQLlygN8w,497
+homa/vision/StochasticSwin.py,sha256=FggzfaVYrP4fnjAFcdMpDozwQHc7CQhl3iRw78oQh0o,425
+homa/vision/Swin.py,sha256=W3XbfUTrjaIhMH8fI_whPP6XO9fVA2R34LlGfQ1hoyo,508
+homa/vision/__init__.py,sha256=w5OkcmdU6Ik5wHIJzeV1Z2UElQtvCsUZks1Q-xViSVg,153
+homa/vision/utils.py,sha256=WB2b7eMDaf6UO3SuS7cB6IJk-9NRQesLavuzWUZRZyg,389
+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.94.dist-info/METADATA,sha256=BHw_3Yfudz7Q8NC1ukYYINXLS7hR_dehKMhy4mtS24g,1760
+homa-0.2.94.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+homa-0.2.94.dist-info/entry_points.txt,sha256=tJZzjs-f2QvFe3ES8Qta8IE5sAbeE8-cyZ_UtbgqG4s,51
+homa-0.2.94.dist-info/top_level.txt,sha256=tmOfy2tuaAwc3W5-i6j61_vYJsXgR4ivBWkhJ3ZtJDc,5
+homa-0.2.94.dist-info/RECORD,,

homa-0.2.94.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.94.dist-info/entry_points.txt

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

homa-0.2.94.dist-info/top_level.txt

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