ruffed and isorted

Author: hzavadil98

main.py

@@ -3,11 +3,11 @@
 import numpy as np
 import torch as th
 import torch.nn as nn
-import wandb
 from torch.utils.data import DataLoader
 from torchvision import transforms
 from tqdm import tqdm
 
+import wandb
 from utils import MetricWrapper, createfolders, get_args, load_data, load_model
 
 
@@ -27,7 +27,6 @@ def main():
 
     args = get_args()
 
-
     createfolders(args.datafolder, args.resultfolder, args.modelfolder)
 
     device = args.device
@@ -43,7 +42,9 @@ def main():
         augmentations = transforms.Compose([transforms.ToTensor()])
 
     # Dataset
-    assert args.validation_split_percentage < 1.0 and args.validation_split_percentage > 0, "Validation split should be in interval (0,1)"
+    assert (
+        args.validation_split_percentage < 1.0 and args.validation_split_percentage > 0
+    ), "Validation split should be in interval (0,1)"
     traindata = load_data(
         args.dataset,
         split="train",
@@ -177,7 +178,7 @@ def main():
                 "Validation loss": np.mean(valloss),
             }
         )
-    
+
     testloss = []
     model.eval()
     with th.no_grad():
@@ -186,13 +187,14 @@ def main():
             logits = model.forward(x)
             loss = criterion(logits, y)
             testloss.append(loss.item())
-            
+
             preds = th.argmax(logits, dim=1)
             metrics(y, preds)
 
     wandb.log(metrics.accumulate(str_prefix="Test "))
     metrics.reset()
     wandb.log({"Test loss": np.mean(testloss)})
 
+
 if __name__ == "__main__":
     main()

utils/dataloaders/mnist_0_3.py

@@ -2,9 +2,9 @@
 import os
 import urllib.request
 from pathlib import Path
-import torch
 
 import numpy as np
+import torch
 from torch.utils.data import Dataset, random_split
 
 
@@ -77,8 +77,8 @@ def __init__(
         self.num_classes = 4
 
         if self.split == "train" or self.split == "validation":
-            train = True        # used to decide whether to load training or test dataset
-        
+            train = True  # used to decide whether to load training or test dataset
+
         if not self.download and not self._chech_is_downloaded():
             raise ValueError(
                 "Data not found. Set --download-data=True to download the data."
@@ -94,14 +94,18 @@ def __init__(
         )
 
         labels = self._parse_labels()
-        
+
         self.idx = np.where(labels < 4)[0]
-        
+
         if self.split != "test":
             generator1 = torch.Generator().manual_seed(42)
-            tr, val = random_split(self.idx, [1-self.split_percentage, self.split_percentage], generator=generator1)
+            tr, val = random_split(
+                self.idx,
+                [1 - self.split_percentage, self.split_percentage],
+                generator=generator1,
+            )
             self.idx = tr if self.split == "train" else val
-                
+
         self.length = len(self.idx)
 
     def _parse_labels(self):

utils/load_metric.py

@@ -7,7 +7,6 @@
 
 
 class MetricWrapper(nn.Module):
-
     """
     Wrapper class for metrics, that runs multiple metrics on the same data.
 
@@ -46,9 +45,7 @@ class MetricWrapper(nn.Module):
     {'entropy': [], 'f1': [], 'precision': []}
     """
 
-
     def __init__(self, *metrics, num_classes):
-
         super().__init__()
         self.metrics = {}
         self.num_classes = num_classes

utils/metrics/EntropyPred.py

@@ -9,4 +9,4 @@ def __call__(self, y_true, y_false_logits):
         return
 
     def __reset__(self):
-        pass
+        pass

utils/models/magnus_model.py

@@ -2,44 +2,39 @@
 
 
 class MagnusModel(nn.Module):
-    def __init__(self,
-                 imagesize: int,
-                 imagechannels: int,
-                 n_classes:int=10):
-        
+    def __init__(self, imagesize: int, imagechannels: int, n_classes: int = 10):
         """
-        Magnus model contains the model for Magnus' part of the homeexam. 
+        Magnus model contains the model for Magnus' part of the homeexam.
         This class contains a neural network consisting of three linear layers of 133 neurons each,
         with ReLU activation between each layer.
 
         Args
         ----
             imagesize (int): Expected size of input image. This is needed to scale first layer input
             imagechannels (int): Expected number of image channels. This is needed to scale first layer input
-            n_classes (int): Number of classes we are to provide. 
+            n_classes (int): Number of classes we are to provide.
 
         Returns
         -------
             MagnusModel (nn.Module): Neural network as described above in this docstring.
         """
-        
-        
+
         super().__init__()
-        self.imagesize = imagesize 
+        self.imagesize = imagesize
         self.imagechannels = imagechannels
-        
-        self.layer1 = nn.Sequential(*([
-            nn.Linear(self.imagechannels*self.imagesize*self.imagesize, 133),
-            nn.ReLU()
-        ]))
-        self.layer2 = nn.Sequential(*([
-            nn.Linear(133, 133),
-            nn.ReLU()
-        ]))
-        self.layer3 = nn.Sequential(*([
-            nn.Linear(133, n_classes),
-            nn.ReLU()
-        ]))
+
+        self.layer1 = nn.Sequential(
+            *(
+                [
+                    nn.Linear(
+                        self.imagechannels * self.imagesize * self.imagesize, 133
+                    ),
+                    nn.ReLU(),
+                ]
+            )
+        )
+        self.layer2 = nn.Sequential(*([nn.Linear(133, 133), nn.ReLU()]))
+        self.layer3 = nn.Sequential(*([nn.Linear(133, n_classes), nn.ReLU()]))
 
     def forward(self, x):
         """
@@ -48,17 +43,17 @@ def forward(self, x):
         Args
         ----
             x (th.Tensor): Four-dimensional tensor in the form (Batch Size x Channels x Image Height x Image Width)
-                
+
         Returns
         -------
             out (th.Tensor): Class-logits of network given input x
         """
         assert len(x.size) == 4
-        
+
         x = x.view(x.size(0), -1)
-        
+
         x = self.layer1(x)
         x = self.layer2(x)
         out = self.layer3(x)
-    
+
         return out