:wqerge:|erge branch 'main' of github.com:SFI-Visual-Intelligence/Collaborative-Coding-Exam into johan/devbranch

Author: Johanmkr

.github/workflows/create_release.yml

@@ -0,0 +1,29 @@
+on:
+  push:
+    # Sequence of patterns matched against refs/tags
+    tags:
+      - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
+
+name: Create Release
+
+jobs:
+  build:
+    name: Create Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@master
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@latest
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: Release ${{ github.ref }}
+          body: |
+            Changes in this Release
+            - First Change
+            - Second Change
+          draft: false
+          prerelease: false

CollaborativeCoding/dataloaders/download.py

@@ -98,11 +98,11 @@ def download_svhn(path, train: bool = True):
         train_data = parent_path / "train_32x32.mat"
         test_data = parent_path / "test_32x32.mat"
 
-        if not train_data.is_file():
+        if not train_data.exists():
             download_svhn(parent_path, train=True)
-        if not test_data.is_file():
+        if not test_data.exists():
             download_svhn(parent_path, train=False)
-        print(test_data)
+
         train_labels = loadmat(train_data)["y"]
         test_labels = loadmat(test_data)["y"]
 

CollaborativeCoding/dataloaders/svhn.py

@@ -6,7 +6,6 @@
 from PIL import Image
 from scipy.io import loadmat
 from torch.utils.data import Dataset
-from torchvision.datasets import SVHN
 
 
 class SVHNDataset(Dataset):
@@ -31,7 +30,7 @@ def __init__(
         """
         super().__init__()
 
-        self.data_path = data_path
+        self.data_path = data_path / "SVHN"
         self.indexes = sample_ids
         self.split = "train" if train else "test"
 
@@ -41,7 +40,7 @@ def __init__(
         if not os.path.exists(
             os.path.join(self.data_path, f"svhn_{self.split}data.h5")
         ):
-            self._download_data(self.data_path)
+            self._create_h5py(self.data_path)
 
         assert os.path.exists(
             os.path.join(self.data_path, f"svhn_{self.split}data.h5")
@@ -53,15 +52,14 @@ def __init__(
 
         self.num_classes = len(np.unique(self.labels))
 
-    def _download_data(self, path: str):
+    def _create_h5py(self, path: str):
         """
         Downloads the SVHN dataset to the specified directory.
         Args:
             path (str): The directory where the dataset will be downloaded.
         """
         print(f"Downloading SVHN data into {path}")
 
-        SVHN(path, split=self.split, download=True)
         data = loadmat(os.path.join(path, f"{self.split}_32x32.mat"))
 
         images, labels = data["X"], data["y"]

CollaborativeCoding/dataloaders/uspsh5_7_9.py

@@ -2,10 +2,8 @@
 
 import h5py
 import numpy as np
-import torch
 from PIL import Image
 from torch.utils.data import Dataset
-from torchvision import transforms
 
 
 class USPSH5_Digit_7_9_Dataset(Dataset):
@@ -55,6 +53,7 @@ def __init__(
         self.h5_path = data_path / self.filename
         self.sample_ids = sample_ids
         self.nr_channels = nr_channels
+        self.num_classes = 3
 
         # Load the dataset from the HDF5 file
         with h5py.File(self.filepath, "r") as hf:
@@ -103,34 +102,3 @@ def __getitem__(self, id):
             image = self.transform(image)
 
         return image, label
-
-
-def main():
-    # Example Usage:
-    transform = transforms.Compose(
-        [
-            transforms.Resize((16, 16)),  # Ensure images are 16x16
-            transforms.ToTensor(),
-            transforms.Normalize((0.5,), (0.5,)),  # Normalize to [-1, 1]
-        ]
-    )
-    indices = np.array([7, 8, 9])
-    # Load the dataset
-    dataset = USPSH5_Digit_7_9_Dataset(
-        data_path="C:/Users/Solveig/OneDrive/Dokumente/UiT PhD/Courses/Git",
-        sample_ids=indices,
-        train=False,
-        transform=transform,
-    )
-    data_loader = torch.utils.data.DataLoader(dataset, batch_size=2, shuffle=True)
-    batch = next(iter(data_loader))  # grab a batch from the dataloader
-    img, label = batch
-    print(img.shape)
-    print(label.shape)
-
-    # Check dataset size
-    print(f"Dataset size: {len(dataset)}")
-
-
-if __name__ == "__main__":
-    main()

CollaborativeCoding/metrics/F1.py

@@ -6,166 +6,121 @@
 class F1Score(nn.Module):
     """
     F1 Score implementation with support for both macro and micro averaging.
-
     This class computes the F1 score during training using either macro or micro averaging.
-    The F1 score is calculated based on the true positives (TP), false positives (FP),
-    and false negatives (FN) for each class.
-
     Parameters
     ----------
     num_classes : int
         The number of classes in the classification task.
 
-    macro_averaging : bool, optional, default=False
+    macro_averaging : bool, default=False
         If True, computes the macro-averaged F1 score. If False, computes the micro-averaged F1 score.
-
-    Attributes
-    ----------
-    num_classes : int
-        The number of classes in the classification task.
-
-    tp : torch.Tensor
-        Tensor storing the count of True Positives (TP) for each class.
-
-    fp : torch.Tensor
-        Tensor storing the count of False Positives (FP) for each class.
-
-    fn : torch.Tensor
-        Tensor storing the count of False Negatives (FN) for each class.
-
-    macro_averaging : bool
-        A flag indicating whether to compute the macro-averaged F1 score or not.
     """
 
     def __init__(self, num_classes, macro_averaging=False):
-        """
-        Initializes the F1Score object, setting up the necessary state variables.
-
-        Parameters
-        ----------
-        num_classes : int
-            The number of classes in the classification task.
-
-        macro_averaging : bool, optional, default=False
-            If True, computes the macro-averaged F1 score. If False, computes the micro-averaged F1 score.
-        """
         super().__init__()
-
         self.num_classes = num_classes
         self.macro_averaging = macro_averaging
         self.y_true = []
         self.y_pred = []
-        # Initialize variables for True Positives (TP), False Positives (FP), and False Negatives (FN)
-        self.tp = torch.zeros(num_classes)
-        self.fp = torch.zeros(num_classes)
-        self.fn = torch.zeros(num_classes)
 
-    def _micro_F1(self, target, preds):
+    def forward(self, target, preds):
         """
-        Compute the Micro F1 score by aggregating TP, FP, and FN across all classes.
+        Stores predictions and targets for computing the F1 score.
 
-        Micro F1 score is calculated globally by considering all predictions together, regardless of class.
+        Parameters
+        ----------
+        preds : torch.Tensor
+            Predicted logits (shape: [batch_size, num_classes]).
+        target : torch.Tensor
+            True labels (shape: [batch_size]).
+        """
+        preds = torch.argmax(preds, dim=-1)  # Convert logits to class indices
+        self.y_true.append(target.detach())
+        if preds.dim() == 0:  # Scalar (e.g., single class prediction)
+            preds = preds.unsqueeze(0)  # Add batch dimension
+        self.y_pred.append(preds.detach())
+
+    def compute_f1(self):
+        """
+        Computes the F1 score (Micro or Macro).
 
         Returns
         -------
         torch.Tensor
-            The micro-averaged F1 score.
+            The computed F1 score.
         """
-        for i in range(self.num_classes):
-            self.tp[i] += torch.sum((preds == i) & (target == i)).float()
-            self.fp[i] += torch.sum((preds == i) & (target != i)).float()
-            self.fn[i] += torch.sum((preds != i) & (target == i)).float()
+        if not self.y_true or not self.y_pred:  # Check if empty
+            return torch.tensor(np.nan)
+
+        # Convert lists to tensors
+        y_true = torch.cat(self.y_true)
+        y_pred = torch.cat(self.y_pred)
 
-        tp = torch.sum(self.tp)
-        fp = torch.sum(self.fp)
-        fn = torch.sum(self.fn)
+        return (
+            self._macro_F1(y_true, y_pred)
+            if self.macro_averaging
+            else self._micro_F1(y_true, y_pred)
+        )
 
-        precision = tp / (tp + fp + 1e-8)  # Avoid division by zero
-        recall = tp / (tp + fn + 1e-8)  # Avoid division by zero
+    def _micro_F1(self, target, preds):
+        """Computes Micro F1 Score (global TP, FP, FN)."""
+        tp = torch.sum(preds == target).float()
+        fp = torch.sum(preds != target).float()
+        fn = fp  # Since all errors are either FP or FN
+
+        precision = tp / (tp + fp + 1e-8)
+        recall = tp / (tp + fn + 1e-8)
+        f1 = 2 * (precision * recall) / (precision + recall + 1e-8)
 
-        f1 = (
-            2 * precision * recall / (precision + recall + 1e-8)
-        )  # Avoid division by zero
         return f1
 
     def _macro_F1(self, target, preds):
-        """
-        Compute the Macro F1 score by calculating the F1 score per class and averaging.
-
-        Macro F1 score is calculated as the average of per-class F1 scores. This approach treats all classes equally,
-        regardless of their frequency.
+        """Computes Macro F1 Score in a vectorized way (no loops)."""
+        num_classes = self.num_classes
+        target = target.long()  # Ensure target is a LongTensor
+        preds = preds.long()
+        # Create one-hot encodings of the true and predicted labels
+        target_one_hot = torch.nn.functional.one_hot(target, num_classes=num_classes)
+        preds_one_hot = torch.nn.functional.one_hot(preds, num_classes=num_classes)
 
-        Returns
-        -------
-        torch.Tensor
-            The macro-averaged F1 score.
-        """
-        # Calculate True Positives (TP), False Positives (FP), and False Negatives (FN) per class
-        for i in range(self.num_classes):
-            self.tp[i] += torch.sum((preds == i) & (target == i)).float()
-            self.fp[i] += torch.sum((preds == i) & (target != i)).float()
-            self.fn[i] += torch.sum((preds != i) & (target == i)).float()
-
-        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)
-        return f1_score
-
-    def forward(self, preds, target):
-        """
+        # Compute TP, FP, FN for each class
+        tp = torch.sum(target_one_hot * preds_one_hot, dim=0).float()
+        fp = torch.sum(preds_one_hot * (1 - target_one_hot), dim=0).float()
+        fn = torch.sum(target_one_hot * (1 - preds_one_hot), dim=0).float()
 
-        Update the True Positives, False Positives, and False Negatives, and compute the F1 score.
+        # Compute precision and recall per class
+        precision = tp / (tp + fp + 1e-8)
+        recall = tp / (tp + fn + 1e-8)
 
-        This method computes the F1 score based on the predictions and true labels. It can compute either the
-        macro-averaged or micro-averaged F1 score, depending on the `macro_averaging` flag.
+        # Compute per-class F1 score
+        f1_per_class = 2 * (precision * recall) / (precision + recall + 1e-8)
 
-        Parameters
-        ----------
-        preds : torch.Tensor
-            Predicted logits or class indices (shape: [batch_size, num_classes]).
-            These logits are typically the output of a softmax or sigmoid activation.
+        # Compute Macro F1 (mean over all classes)
+        return torch.mean(f1_per_class)
 
-        target : torch.Tensor
-            True labels (shape: [batch_size]), where each element is an integer representing the true class.
+    def __returnmetric__(self):
+        """
+        Computes and returns the F1 score (Micro or Macro).
 
         Returns
         -------
         torch.Tensor
-            The computed F1 score (either micro or macro, based on `macro_averaging`).
+            The computed F1 score.
         """
-        preds = torch.argmax(preds, dim=-1)
-        self.y_true.append(target)
-        self.y_pred.append(preds)
+        if not self.y_true or not self.y_pred:  # Check if empty
+            return torch.tensor(np.nan)
+
+        # Convert lists to tensors
+        y_true = torch.cat([t.unsqueeze(0) if t.dim() == 0 else t for t in self.y_true])
+        y_pred = torch.cat([t.unsqueeze(0) if t.dim() == 0 else t for t in self.y_pred])
 
-    def __returnmetric__(self):
-        if self.y_true == [] or self.y_pred == []:
-            return np.nan
-        if isinstance(self.y_true, list):
-            if len(self.y_true) == 1:
-                self.y_true = self.y_true[0]
-                self.y_pred = self.y_pred[0]
-            else:
-                self.y_true = torch.cat(self.y_true)
-                self.y_pred = torch.cat(self.y_pred)
         return (
-            self._micro_F1(self.y_true, self.y_pred)
-            if not self.macro_averaging
-            else self._macro_F1(self.y_true, self.y_pred)
+            self._macro_F1(y_true, y_pred)
+            if self.macro_averaging
+            else self._micro_F1(y_true, y_pred)
         )
 
     def __reset__(self):
+        """Resets stored predictions and targets."""
         self.y_true = []
         self.y_pred = []
-        return None