ruffed

Author: Johanmkr

utils/dataloaders/mnist_4_9.py

@@ -5,53 +5,44 @@
 import numpy as np
 from torch.utils.data import Dataset
 
+
 class MNIST_4_9(Dataset):
-    def __init__(self,
-                 datapath: Path,
-                 train: bool = False,
-                 download: bool = False
-    ):
+    def __init__(self, datapath: Path, train: bool = False, download: bool = False):
         super.__init__()
         self.datapath = datapath
         self.mnist_path = self.datapath / "MNIST"
         self.train = train
         self.download = download
         self.num_classes: int = 6
-        
+
         if not self.download and not self._already_downloaded():
             raise FileNotFoundError(
-                'Data files are not found. Set --download-data=True to download the data'
+                "Data files are not found. Set --download-data=True to download the data"
             )
         if self.download and not self._already_downloaded():
             self._download()
-            
-        
-        
-    
+
     def _download(self):
         urls: dict = {
             "train_images": "https://storage.googleapis.com/cvdf-datasets/mnist/train-images-idx3-ubyte.gz",
             "train_labels": "https://storage.googleapis.com/cvdf-datasets/mnist/train-labels-idx1-ubyte.gz",
             "test_images": "https://storage.googleapis.com/cvdf-datasets/mnist/t10k-images-idx3-ubyte.gz",
             "test_labels": "https://storage.googleapis.com/cvdf-datasets/mnist/t10k-labels-idx1-ubyte.gz",
         }
-        
-        
+
         for url in urls.values():
-            file_path: Path = os.path.join(self.mnist_path, url.split('/')[-1])
-            file_name: Path = file_path.replace('.gz','')
+            file_path: Path = os.path.join(self.mnist_path, url.split("/")[-1])
+            file_name: Path = file_path.replace(".gz", "")
             if os.path.exists(file_name):
                 print(f"File: {file_name} already downloaded")
             else:
                 print(f"File: {file_name} is downloading...")
-                ur.urlretrieve(url, file_path) # Download file
-                with gzip.open(file_path, 'rb') as infile:
-                    with open(file_name, 'wb') as outfile:
-                        outfile.write(infile.read()) # Write from url to local file
-                    os.remove(file_path) # remove .gz file
-                    
-                    
-    
+                ur.urlretrieve(url, file_path)  # Download file
+                with gzip.open(file_path, "rb") as infile:
+                    with open(file_name, "wb") as outfile:
+                        outfile.write(infile.read())  # Write from url to local file
+                    os.remove(file_path)  # remove .gz file
+
     def _already_downloaded(self):
         if self.mnist_path.exists():
             required_files: list = [
@@ -65,11 +56,9 @@ def _already_downloaded(self):
         else:
             self.mnist_path.mkdir(parents=True, exist_ok=True)
             return False
-    
+
     def __len__(self):
         pass
-    
+
     def __getitem__(self):
         pass
-    
-    

utils/load_metric.py

@@ -75,13 +75,21 @@ def _get_metric(self, key):
             case "entropy":
                 return EntropyPrediction(num_classes=self.num_classes)
             case "f1":
-                return F1Score(num_classes=self.num_classes, macro_averaging=self.macro_averaging)
+                return F1Score(
+                    num_classes=self.num_classes, macro_averaging=self.macro_averaging
+                )
             case "recall":
-                return Recall(num_classes=self.num_classes, macro_averaging=self.macro_averaging)
+                return Recall(
+                    num_classes=self.num_classes, macro_averaging=self.macro_averaging
+                )
             case "precision":
-                return Precision(num_classes=self.num_classes, macro_averaging=self.macro_averaging)
+                return Precision(
+                    num_classes=self.num_classes, macro_averaging=self.macro_averaging
+                )
             case "accuracy":
-                return Accuracy(num_classes=self.num_classes, macro_averaging=self.macro_averaging)
+                return Accuracy(
+                    num_classes=self.num_classes, macro_averaging=self.macro_averaging
+                )
             case _:
                 raise ValueError(f"Metric {key} not supported")
 

utils/metrics/F1.py

@@ -76,7 +76,9 @@ def _micro_F1(self):
         precision = tp / (tp + fp + 1e-8)  # Avoid division by zero
         recall = tp / (tp + fn + 1e-8)  # Avoid division by zero
 
-        f1 = 2 * precision * recall / (precision + recall + 1e-8)  # Avoid division by zero
+        f1 = (
+            2 * precision * recall / (precision + recall + 1e-8)
+        )  # Avoid division by zero
         return f1
 
     def _macro_F1(self):
@@ -91,10 +93,18 @@ def _macro_F1(self):
         torch.Tensor
             The macro-averaged F1 score.
         """
-        precision_per_class = self.tp / (self.tp + self.fp + 1e-8)  # Avoid division by zero
-        recall_per_class = self.tp / (self.tp + self.fn + 1e-8)  # Avoid division by zero
-        f1_per_class = 2 * precision_per_class * recall_per_class / (
-                    precision_per_class + recall_per_class + 1e-8)  # Avoid division by zero
+        precision_per_class = self.tp / (
+            self.tp + self.fp + 1e-8
+        )  # Avoid division by zero
+        recall_per_class = self.tp / (
+            self.tp + self.fn + 1e-8
+        )  # Avoid division by zero
+        f1_per_class = (
+            2
+            * precision_per_class
+            * recall_per_class
+            / (precision_per_class + recall_per_class + 1e-8)
+        )  # Avoid division by zero
 
         # Take the average of F1 scores across all classes
         f1_score = torch.mean(f1_per_class)
@@ -136,4 +146,4 @@ def forward(self, preds, target):
             # Calculate Micro F1 score
             f1_score = self._micro_F1()
 
-        return f1_score
+        return f1_score

utils/metrics/accuracy.py

@@ -7,7 +7,7 @@ def __init__(self, num_classes, macro_averaging=False):
         super().__init__()
         self.num_classes = num_classes
         self.macro_averaging = macro_averaging
-        
+
     def forward(self, y_true, y_pred):
         """
         Compute the accuracy of the model.
@@ -30,7 +30,7 @@ def forward(self, y_true, y_pred):
             return self._macro_acc(y_true, y_pred)
         else:
             return self._micro_acc(y_true, y_pred)
-    
+
     def _macro_acc(self, y_true, y_pred):
         """
         Compute the macro-average accuracy.
@@ -51,15 +51,15 @@ def _macro_acc(self, y_true, y_pred):
 
         classes = torch.unique(y_true)  # Find unique class labels
         acc_per_class = []
-        
+
         for c in classes:
-            mask = (y_true == c)  # Mask for class c
+            mask = y_true == c  # Mask for class c
             acc = (y_pred[mask] == y_true[mask]).float().mean()  # Accuracy for class c
             acc_per_class.append(acc)
-        
+
         macro_acc = torch.stack(acc_per_class).mean().item()  # Average across classes
         return macro_acc
-    
+
     def _micro_acc(self, y_true, y_pred):
         """
         Compute the micro-average accuracy.
@@ -82,13 +82,21 @@ def _micro_acc(self, y_true, y_pred):
 if __name__ == "__main__":
     accuracy = Accuracy(5)
     macro_accuracy = Accuracy(5, macro_averaging=True)
-    
+
     y_true = torch.tensor([0, 3, 2, 3, 4])
     y_pred = torch.tensor([0, 1, 2, 3, 4])
     print(accuracy(y_true, y_pred))
     print(macro_accuracy(y_true, y_pred))
-    
+
     y_true = torch.tensor([0, 3, 2, 3, 4])
-    y_onehot_pred = torch.tensor([[1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1]])
+    y_onehot_pred = torch.tensor(
+        [
+            [1, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0],
+            [0, 0, 1, 0, 0],
+            [0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 1],
+        ]
+    )
     print(accuracy(y_true, y_onehot_pred))
     print(macro_accuracy(y_true, y_onehot_pred))