homa 0.1.1__py3-none-any.whl → 0.2.9__py3-none-any.whl

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

@@ -1,3 +1,5 @@
+from .Classifier import Classifier
 from .Model import Model
 from .Resnet import Resnet
-from .StochasticResnet import StochasticResnet
+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

@@ -1,9 +1,12 @@
 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:
+class Trainable(HasLogits, HasProbabilities, HasLabels):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
@@ -16,7 +19,7 @@ class Trainable:
     def train_tensors(self, x: Tensor, y: Tensor):
         self.network.train()
         self.optimizer.zero_grad()
-        loss = self.criterion(y, self.network(x).float())
+        loss = self.criterion(self.network(x).float(), y)
         loss.backward()
         self.optimizer.step()
 

homa/vision/concerns/__init__.py

@@ -1 +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/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

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

homa/vision/utils.py

@@ -1,21 +1,12 @@
 import torch
+import random
 
 
-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)
+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.9.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: homa
+Version: 0.2.9
+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.9.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=KYtQtpLiupdyoumqNmz0kMTgRK66sSYiuLnpbr2H7Mw,509
+homa/activations/learnable/AReLU.py,sha256=-6kQ0mDGq3p9Xlg74waMa8xsTDALCtkE6pwx7DrTDeI,610
+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=p5FmWGJWlZEdLGVXmiXKg0rTxCVO-qn9bQIVcyAaa8U,616
+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=fcfm-GHEe4AQzEz9mXrWfSLkcgWaTg91ccByx7LxfX4,264
+homa/activations/learnable/concerns/ChannelBased.py,sha256=uK6FdC9mJRWSoXinjM8r5GJCZNWWxst7NMt8P6rnhKg,1143
+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=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=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.9.dist-info/METADATA,sha256=uqaBYePnoJwrTwJRFB47fx_vh073hlynKWA7JAU0hDs,1759
+homa-0.2.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+homa-0.2.9.dist-info/entry_points.txt,sha256=tJZzjs-f2QvFe3ES8Qta8IE5sAbeE8-cyZ_UtbgqG4s,51
+homa-0.2.9.dist-info/top_level.txt,sha256=tmOfy2tuaAwc3W5-i6j61_vYJsXgR4ivBWkhJ3ZtJDc,5
+homa-0.2.9.dist-info/RECORD,,

homa/activations/classes/APLU.py

@@ -1,48 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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