black format

Author: aditya0by0

chebai/callbacks/epoch_metrics.py

@@ -48,6 +48,7 @@ def compute(self):
         classwise_f1 = classwise_f1.nan_to_num()
         return torch.mean(classwise_f1)
 
+
 class BalancedAccuracy(torchmetrics.Metric):
     def __init__(self, num_labels, dist_sync_on_step=False, threshold=0.5):
         super().__init__(dist_sync_on_step=dist_sync_on_step)
@@ -79,14 +80,22 @@ def __init__(self, num_labels, dist_sync_on_step=False, threshold=0.5):
         self.threshold = threshold
 
     def update(self, preds: torch.Tensor, labels: torch.Tensor):
-        """"Update the TPs, TNs ,FPs and FNs """
+        """Update the TPs, TNs ,FPs and FNs"""
 
         # Size: Batch_size x Num_of_Classes;
         # summing over 1st dimension (dim=0), gives us the True positives per class
-        tps = torch.sum(torch.logical_and(preds > self.threshold, labels.to(torch.bool)), dim=0)
-        fps = torch.sum(torch.logical_and(preds > self.threshold, ~labels.to(torch.bool)), dim=0)
-        tns = torch.sum(torch.logical_and(preds <= self.threshold, ~labels.to(torch.bool)), dim=0)
-        fns = torch.sum(torch.logical_and(preds <= self.threshold, labels.to(torch.bool)), dim=0)
+        tps = torch.sum(
+            torch.logical_and(preds > self.threshold, labels.to(torch.bool)), dim=0
+        )
+        fps = torch.sum(
+            torch.logical_and(preds > self.threshold, ~labels.to(torch.bool)), dim=0
+        )
+        tns = torch.sum(
+            torch.logical_and(preds <= self.threshold, ~labels.to(torch.bool)), dim=0
+        )
+        fns = torch.sum(
+            torch.logical_and(preds <= self.threshold, labels.to(torch.bool)), dim=0
+        )
 
         # Size: Num_of_Classes;
         self.true_positives += tps
@@ -104,4 +113,4 @@ def compute(self):
         tnr = tnr.nan_to_num()
 
         balanced_acc = (tpr + tnr) / 2
-        return torch.mean(balanced_acc)
+        return torch.mean(balanced_acc)

tests/testCustomBalancedAccuracyMetric.py

@@ -15,12 +15,8 @@ def test_iterative_vs_single_call_approach(self):
         """Test the custom metric implementation in update fashion approach against
         the single call approach"""
 
-        preds = torch.tensor([[1, 1, 0, 1],
-                              [1, 0, 1, 1],
-                              [0, 1, 0, 1]])
-        label = torch.tensor([[0, 0, 0, 0],
-                              [0, 0, 1, 1],
-                              [0, 1, 0, 1]])
+        preds = torch.tensor([[1, 1, 0, 1], [1, 0, 1, 1], [0, 1, 0, 1]])
+        label = torch.tensor([[0, 0, 0, 0], [0, 0, 1, 1], [0, 1, 0, 1]])
 
         num_labels = label.shape[1]
         iterative_custom_metric = BalancedAccuracy(num_labels=num_labels)
@@ -41,34 +37,40 @@ def test_metric_against_realistic_data(self):
         num_of_files = len(os.listdir(abs_path)) // 2
 
         # load single file to get the num of labels for metric class instantiation
-        labels = torch.load(f'{directory_path}/labels{0:03d}.pt', map_location=torch.device(self.device))
+        labels = torch.load(
+            f"{directory_path}/labels{0:03d}.pt", map_location=torch.device(self.device)
+        )
         num_labels = labels.shape[1]
         balanced_acc_custom = BalancedAccuracy(num_labels=num_labels)
 
         for i in range(num_of_files):
-            labels = torch.load(f'{directory_path}/labels{i:03d}.pt', map_location=torch.device(self.device))
-            preds = torch.load(f'{directory_path}/preds{i:03d}.pt', map_location=torch.device(self.device))
+            labels = torch.load(
+                f"{directory_path}/labels{i:03d}.pt",
+                map_location=torch.device(self.device),
+            )
+            preds = torch.load(
+                f"{directory_path}/preds{i:03d}.pt",
+                map_location=torch.device(self.device),
+            )
             balanced_acc_custom.update(preds, labels)
 
         balanced_acc_custom_score = balanced_acc_custom.compute().item()
         print(f"Balanced Accuracy for realistic data: {balanced_acc_custom_score}")
 
     def test_case_when_few_class_has_no_labels(self):
         """Test custom metric against standard metric for the scenario where some class has no labels"""
-        preds = torch.tensor([[1, 1, 0, 1],
-                              [1, 0, 1, 1],
-                              [0, 1, 0, 1]])
-        label = torch.tensor([[0, 0, 0, 0], # no labels
-                              [0, 0, 1, 1],
-                              [0, 1, 0, 1]])
+        preds = torch.tensor([[1, 1, 0, 1], [1, 0, 1, 1], [0, 1, 0, 1]])
+        label = torch.tensor([[0, 0, 0, 0], [0, 0, 1, 1], [0, 1, 0, 1]])  # no labels
 
         # tp = [0, 1, 1, 2], fp = [2, 1, 0, 1], tn = [1, 1, 2, 0], fn = [0, 0, 0, 0]
         # tpr = [0, 1, 1, 2] / ([0, 1, 1, 2] + [0, 0, 0, 0]) = [0, 1, 1, 1]
         # tnr = [1, 1, 2, 0] / ([1, 1, 2, 0] + [2, 1, 0, 1]) = [0.33333, 0.5, 1, 0]
         # balanced_accuracy = ([0, 1, 1, 1] + [0.33333, 0.5, 1, 0]) / 2 = ([0.16666667, 0.75, 1, 0.5]
         # mean bal accuracy = 0.6041666666666666
 
-        balanced_acc_score = self.__get_custom_metric_score(preds, label, label.shape[1])
+        balanced_acc_score = self.__get_custom_metric_score(
+            preds, label, label.shape[1]
+        )
 
         self.assertAlmostEqual(balanced_acc_score, 0.6041666666, places=4)
 
@@ -78,7 +80,10 @@ def test_all_predictions_are_1_half_labels_are_1(self):
         preds = torch.ones((1, 900), dtype=torch.int)
         label = torch.ones((1, 900), dtype=torch.int)
 
-        mask = [[True] * (label.size(1) // 2) + [False] * (label.size(1) - (label.size(1) // 2))]
+        mask = [
+            [True] * (label.size(1) // 2)
+            + [False] * (label.size(1) - (label.size(1) // 2))
+        ]
         random.shuffle(mask[0])
         label[torch.tensor(mask)] = 0
 
@@ -88,7 +93,9 @@ def test_all_predictions_are_1_half_labels_are_1(self):
         # tnr = tn / (tn + fp) = [0, 0, 0, 0]
         # balanced accuracy = 1 / 4 = 0.25
 
-        balanced_acc_custom_score = self.__get_custom_metric_score(preds, label, label.shape[1])
+        balanced_acc_custom_score = self.__get_custom_metric_score(
+            preds, label, label.shape[1]
+        )
         self.assertAlmostEqual(balanced_acc_custom_score, 0.25, places=4)
 
     def test_all_labels_are_1_half_predictions_are_1(self):
@@ -97,7 +104,10 @@ def test_all_labels_are_1_half_predictions_are_1(self):
         preds = torch.ones((1, 900), dtype=torch.int)
         label = torch.ones((1, 900), dtype=torch.int)
 
-        mask = [[True] * (label.size(1) // 2) + [False] * (label.size(1) - (label.size(1) // 2))]
+        mask = [
+            [True] * (label.size(1) // 2)
+            + [False] * (label.size(1) - (label.size(1) // 2))
+        ]
         random.shuffle(mask[0])
         preds[torch.tensor(mask)] = 0
 
@@ -107,7 +117,9 @@ def test_all_labels_are_1_half_predictions_are_1(self):
         # tnr = tn / (tn + fp) = [0, 0, 0, 0]
         # balanced accuracy = 1 / 4 = 0.25
 
-        balanced_acc_custom_score = self.__get_custom_metric_score(preds, label, label.shape[1])
+        balanced_acc_custom_score = self.__get_custom_metric_score(
+            preds, label, label.shape[1]
+        )
         self.assertAlmostEqual(balanced_acc_custom_score, 0.25, places=4)
 
     @staticmethod