homa 0.1.5__tar.gz → 0.1.9__tar.gz

homa-0.1.9/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: homa
+Version: 0.1.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.1.9/README.md

@@ -0,0 +1,64 @@
+# 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.1.5 → homa-0.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "homa"
-version = "0.1.5"
+version = "0.1.9"
 description = "A curated list of machine learning and deep learning helpers."
 authors = [
   { name="Taha Shieenavaz", email="tahashieenavaz@gmail.com" },

{homa-0.1.5 → homa-0.1.9}/src/homa/activations/classes/StochasticActivation.py

@@ -13,7 +13,21 @@ from .SReLU import SReLU
 class StochasticActivation(torch.nn.Module):
     def __init__(self):
         super().__init__()
-        self.gate = random.choice([APLU, GALU, SmallGALU, MELU, WideMELU, PDELU, SReLU])
+        self.gate = random.choice(
+            [
+                APLU,
+                GALU,
+                SmallGALU,
+                MELU,
+                WideMELU,
+                PDELU,
+                SReLU,
+                torch.nn.ReLU,
+                torch.nn.PReLU,
+                torch.nn.LeakyReLU,
+                torch.nn.ELU,
+            ]
+        )
         self.gate = self.gate()
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:

{homa-0.1.5 → homa-0.1.9}/src/homa/ensemble/Ensemble.py

@@ -1,8 +1,7 @@
 from .concerns import (
     ReportsSize,
-    RecordsStateDictionaries,
+    StoresModels,
     ReportsClassificationMetrics,
-    HasNetwork,
     PredictsProbabilities,
 )
 
@@ -10,9 +9,8 @@ from .concerns import (
 class Ensemble(
     ReportsSize,
     ReportsClassificationMetrics,
-    RecordsStateDictionaries,
     PredictsProbabilities,
-    HasNetwork,
+    StoresModels,
 ):
     def __init__(self):
         super().__init__()

homa-0.1.9/src/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 logits is None else sum_logits + logits
+            predictions = sum_logits.argmax(dim=1)
+            predictions.extend(predictions.cpu().numpy())
+            labels.extend(y.cpu().numpy())
+        return predictions, labels

{homa-0.1.5 → homa-0.1.9}/src/homa/ensemble/concerns/PredictsProbabilities.py

@@ -9,3 +9,7 @@ class PredictsProbabilities(ReportsLogits):
     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-0.1.5 → homa-0.1.9}/src/homa/ensemble/concerns/ReportsEnsembleAccuracy.py

@@ -1,10 +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) -> float:
-        predictions, labels = self.metric_necessities()
+    def accuracy(self, dataloader: DataLoader) -> float:
+        predictions, labels = self.metric_necessities(dataloader)
         return accuracy(labels, predictions)

{homa-0.1.5 → homa-0.1.9}/src/homa/ensemble/concerns/ReportsLogits.py

@@ -11,3 +11,7 @@ class ReportsLogits:
         for model in self.models:
             logits += model(x)
         return logits
+
+    @torch.no_grad()
+    def logits_(self, *args, **kwargs):
+        return self.logits(*args, **kwargs)

{homa-0.1.5 → homa-0.1.9}/src/homa/ensemble/concerns/ReportsSize.py

@@ -4,8 +4,8 @@ class ReportsSize:
 
     @property
     def size(self):
-        return len(self.state_dicts)
+        return len(self.models)
 
     @property
     def length(self):
-        return len(self.state_dicts)
+        return len(self.models)

homa-0.1.9/src/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-0.1.5 → homa-0.1.9}/src/homa/ensemble/concerns/__init__.py

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

homa-0.1.9/src/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-0.1.5/src/homa/vision/concerns/ReportsLogits.py → homa-0.1.9/src/homa/vision/concerns/HasLogits.py

@@ -1,9 +1,12 @@
 import torch
 
 
-class ReportsLogits:
+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-0.1.5/src/homa/vision/concerns/Predicts.py → homa-0.1.9/src/homa/vision/concerns/HasProbabilities.py

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

{homa-0.1.5 → homa-0.1.9}/src/homa/vision/concerns/ReportsAccuracy.py

@@ -7,17 +7,15 @@ class ReportsAccuracy:
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
-    @no_grad()
     def accuracy_tensors(self, x: Tensor, y: Tensor) -> float:
-        predictions = self.predict(x)
+        predictions = self.predict_(x)
         return (predictions == y).float().mean().item()
 
-    @no_grad()
     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)
+            predictions = self.predict_(x)
             correct += (predictions == y).sum().item()
             total += y.numel()
         return correct / total if total > 0 else 0.0

{homa-0.1.5 → homa-0.1.9}/src/homa/vision/concerns/Trainable.py

@@ -1,11 +1,12 @@
 from torch import Tensor
 from torch.utils.data.dataloader import DataLoader
-from .ReportsLogits import ReportsLogits
-from .Predicts import Predicts
+from .HasLogits import HasLogits
+from .HasProbabilities import HasProbabilities
+from .HasLabels import HasLabels
 from ...device import get_device
 
 
-class Trainable(ReportsLogits, Predicts):
+class Trainable(HasLogits, HasProbabilities, HasLabels):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 

{homa-0.1.5 → homa-0.1.9}/src/homa/vision/concerns/__init__.py

@@ -1,5 +1,6 @@
-from .Predicts import Predicts
+from .HasLabels import HasLabels
+from .HasLogits import HasLogits
+from .HasProbabilities import HasProbabilities
 from .ReportsAccuracy import ReportsAccuracy
-from .ReportsLogits import ReportsLogits
 from .ReportsMetrics import ReportsMetrics
 from .Trainable import Trainable

{homa-0.1.5 → homa-0.1.9}/src/homa/vision/utils.py

@@ -19,3 +19,7 @@ def replace_modules(
 
 def replace_relu(model: torch.nn.Module, replacement: torch.nn.Module):
     return replace_modules(model, torch.nn.ReLU, replacement)
+
+
+def replace_gelu(model: torch.nn.Module, replacement: torch.nn.Module):
+    return replace_modules(model, torch.nn.GELU, replacement)

homa-0.1.9/src/homa.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: homa
+Version: 0.1.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.1.5 → homa-0.1.9}/src/homa.egg-info/SOURCES.txt

@@ -28,16 +28,14 @@ src/homa/cli/namespaces/__init__.py
 src/homa/ensemble/Ensemble.py
 src/homa/ensemble/__init__.py
 src/homa/ensemble/concerns/CalculatesMetricNecessities.py
-src/homa/ensemble/concerns/HasNetwork.py
-src/homa/ensemble/concerns/HasStateDicts.py
 src/homa/ensemble/concerns/PredictsProbabilities.py
-src/homa/ensemble/concerns/RecordsStateDictionaries.py
 src/homa/ensemble/concerns/ReportsClassificationMetrics.py
 src/homa/ensemble/concerns/ReportsEnsembleAccuracy.py
 src/homa/ensemble/concerns/ReportsEnsembleF1.py
 src/homa/ensemble/concerns/ReportsEnsembleKappa.py
 src/homa/ensemble/concerns/ReportsLogits.py
 src/homa/ensemble/concerns/ReportsSize.py
+src/homa/ensemble/concerns/StoresModels.py
 src/homa/ensemble/concerns/__init__.py
 src/homa/torch/__init__.py
 src/homa/torch/helpers.py
@@ -47,15 +45,13 @@ src/homa/vision/Resnet.py
 src/homa/vision/StochasticResnet.py
 src/homa/vision/__init__.py
 src/homa/vision/utils.py
-src/homa/vision/concerns/Predicts.py
+src/homa/vision/concerns/HasLabels.py
+src/homa/vision/concerns/HasLogits.py
+src/homa/vision/concerns/HasProbabilities.py
 src/homa/vision/concerns/ReportsAccuracy.py
-src/homa/vision/concerns/ReportsLogits.py
 src/homa/vision/concerns/ReportsMetrics.py
 src/homa/vision/concerns/Trainable.py
 src/homa/vision/concerns/__init__.py
 src/homa/vision/modules/ResnetModule.py
 src/homa/vision/modules/StochasticResnetModule.py
-src/homa/vision/modules/__init__.py
-tests/test_ensemble.py
-tests/test_resnet.py
-tests/test_stochastic_resnet.py
+src/homa/vision/modules/__init__.py

homa-0.1.5/PKG-INFO

@@ -1,21 +0,0 @@
-Metadata-Version: 2.4
-Name: homa
-Version: 0.1.5
-Summary: A curated list of machine learning and deep learning helpers.
-Author-email: Taha Shieenavaz <tahashieenavaz@gmail.com>
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Requires-Dist: numpy
-Requires-Dist: torch
-Requires-Dist: fire
-
-## Device Management
-
-```py
-from homa import cpu, mps, cuda, device
-
-torch.tensor([1, 2, 3, 4, 5]).to(cpu())
-torch.tensor([1, 2, 3, 4, 5]).to(cuda())
-torch.tensor([1, 2, 3, 4, 5]).to(mps())
-torch.tensor([1, 2, 3, 4, 5]).to(device())
-```

homa-0.1.5/README.md

@@ -1,10 +0,0 @@
-## Device Management
-
-```py
-from homa import cpu, mps, cuda, device
-
-torch.tensor([1, 2, 3, 4, 5]).to(cpu())
-torch.tensor([1, 2, 3, 4, 5]).to(cuda())
-torch.tensor([1, 2, 3, 4, 5]).to(mps())
-torch.tensor([1, 2, 3, 4, 5]).to(device())
-```

homa-0.1.5/src/homa/ensemble/concerns/CalculatesMetricNecessities.py

@@ -1,20 +0,0 @@
-import torch
-
-
-class CalculatesMetricNecessities:
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def metric_necessities(self, dataloader):
-        all_predictions = []
-        all_labels = []
-        for x, y in dataloader:
-            batch_logits_list = []
-            for model in self.models:
-                batch_logits_list.append(model(x))
-            all_batch_logits = torch.stack(batch_logits_list)
-            avg_logits = torch.mean(all_batch_logits, dim=0)
-            _, preds = torch.max(avg_logits, 1)
-            all_predictions.extend(preds.cpu().numpy())
-            all_labels.extend(y.cpu().numpy())
-        return all_predictions, all_labels

homa-0.1.5/src/homa/ensemble/concerns/HasNetwork.py

@@ -1,5 +0,0 @@
-class HasNetwork:
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        # This property is going to be filled with the first model that is fed into the ensemble.
-        self.network = None

homa-0.1.5/src/homa/ensemble/concerns/HasStateDicts.py

@@ -1,8 +0,0 @@
-from typing import List
-from collections import OrderedDict
-
-
-class HasStateDicts:
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.state_dicts: List[OrderedDict] = []

homa-0.1.5/src/homa/ensemble/concerns/RecordsStateDictionaries.py

@@ -1,23 +0,0 @@
-from copy import deepcopy
-from .HasStateDicts import HasStateDicts
-from ...vision import Model
-
-
-class RecordsStateDictionaries(HasStateDicts):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def record(self, model: Model):
-        if self.network is None:
-            self.network = deepcopy(model.network)
-
-        self.state_dicts.append(model.network.state_dict())
-
-    def push(self, *args, **kwargs):
-        self.record(*args, **kwargs)
-
-    def append(self, *args, **kwargs):
-        self.record(*args, **kwargs)
-
-    def add(self, *args, **kwargs):
-        self.record(*args, **kwargs)

homa-0.1.5/src/homa.egg-info/PKG-INFO

@@ -1,21 +0,0 @@
-Metadata-Version: 2.4
-Name: homa
-Version: 0.1.5
-Summary: A curated list of machine learning and deep learning helpers.
-Author-email: Taha Shieenavaz <tahashieenavaz@gmail.com>
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Requires-Dist: numpy
-Requires-Dist: torch
-Requires-Dist: fire
-
-## Device Management
-
-```py
-from homa import cpu, mps, cuda, device
-
-torch.tensor([1, 2, 3, 4, 5]).to(cpu())
-torch.tensor([1, 2, 3, 4, 5]).to(cuda())
-torch.tensor([1, 2, 3, 4, 5]).to(mps())
-torch.tensor([1, 2, 3, 4, 5]).to(device())
-```

homa-0.1.5/tests/test_ensemble.py

@@ -1,28 +0,0 @@
-import pytest
-from homa.ensemble import Ensemble
-from homa.vision import Resnet
-
-
-@pytest.fixture
-def ensemble():
-    return Ensemble()
-
-
-@pytest.fixture
-def resnet():
-    return Resnet(lr=0.001, num_classes=10)
-
-
-def test_ensemble_initialization(ensemble):
-    assert isinstance(ensemble, Ensemble)
-
-
-def test_ensemble_records_models(ensemble, resnet):
-    assert ensemble.network is None
-    ensemble.record(resnet)
-    assert ensemble.network is not None
-    ensemble.append(resnet)
-    ensemble.push(resnet)
-    ensemble.add(resnet)
-    assert ensemble.size == 4
-    assert ensemble.length == 4

homa-0.1.5/tests/test_resnet.py

@@ -1,34 +0,0 @@
-import pytest
-import torch
-from homa.vision import Resnet, Model
-from homa.vision.modules import ResnetModule
-from homa import get_device
-
-
-@pytest.fixture
-def resnet_model():
-    model = Resnet(num_classes=5, lr=0.001)
-    return model
-
-
-def test_resnet_initialization(resnet_model):
-    assert isinstance(resnet_model, Resnet)
-    assert isinstance(resnet_model, Model)
-    assert hasattr(resnet_model, "network")
-    assert hasattr(resnet_model, "optimizer")
-    assert hasattr(resnet_model, "criterion")
-    assert isinstance(resnet_model.network, ResnetModule)
-    assert isinstance(resnet_model.optimizer, torch.optim.SGD)
-    assert isinstance(resnet_model.criterion, torch.nn.CrossEntropyLoss)
-
-
-def test_reports_accuracy(resnet_model):
-    x = torch.randn(10, 3, 84, 84).to(get_device())
-    y = torch.randint(0, 3, (10, 1)).to(get_device())
-    accuracy = resnet_model.accuracy(x, y)
-    assert isinstance(accuracy, float)
-
-    dataset = torch.utils.data.TensorDataset(x, y)
-    dataloader = torch.utils.data.DataLoader(dataset, batch_size=2, shuffle=True)
-    accuracy = resnet_model.accuracy(dataloader)
-    assert isinstance(accuracy, float)

homa-0.1.5/tests/test_stochastic_resnet.py

@@ -1,20 +0,0 @@
-import pytest
-import torch
-from homa.vision import StochasticResnet, Model
-from homa.vision.modules import ResnetModule
-
-
-@pytest.fixture
-def stochastic_resnet_model():
-    return StochasticResnet(num_classes=5, lr=0.001)
-
-
-def test_resnet_initialization(stochastic_resnet_model):
-    assert isinstance(stochastic_resnet_model, StochasticResnet)
-    assert isinstance(stochastic_resnet_model, Model)
-    assert hasattr(stochastic_resnet_model, "network")
-    assert hasattr(stochastic_resnet_model, "optimizer")
-    assert hasattr(stochastic_resnet_model, "criterion")
-    assert isinstance(stochastic_resnet_model.network, ResnetModule)
-    assert isinstance(stochastic_resnet_model.optimizer, torch.optim.SGD)
-    assert isinstance(stochastic_resnet_model.criterion, torch.nn.CrossEntropyLoss)

{homa-0.1.5 → homa-0.1.9}/src/homa/ensemble/concerns/ReportsClassificationMetrics.py

@@ -6,8 +6,8 @@ from .CalculatesMetricNecessities import CalculatesMetricNecessities
 
 class ReportsClassificationMetrics(
     CalculatesMetricNecessities,
-    ReportsEnsembleF1,
     ReportsEnsembleAccuracy,
+    ReportsEnsembleF1,
     ReportsEnsembleKappa,
 ):
     pass