per class accuracy

dataPrep/helpers/transforms_loaders.py

@@ -103,13 +103,15 @@ def make_dataset_loaders(dataset, seed, batch_size, test_size, aug_config, worke
         pin_memory=True,
         num_workers=workers
     )
+    class_names = dataset.features['label'].names
 
     print(f"\nWorkers used in DataLoaders: {workers}\n")
 
     dataset_loaders = {
         "train": train_loader,
         "val": val_loader,
-        "test": test_loader
+        "test": test_loader,
+        "classNames": class_names
     }
 
     return dataset_loaders

testingModel/helpers/evaluation.py

@@ -1,43 +1,88 @@
-import torch
-from torch.nn import CrossEntropyLoss
-
-
-"""
-Evaluates a trained model on a dataloader that returns batches like:
-    batch["image"] -> Tensor [B, 3, 256, 256]
-    batch["label"] -> Tensor [B]
-
-Returns dict:
-    { "accuracy": float, "loss": float }
-"""
-def make_predictions(model, dataloader, device):
-
-    model.eval()
-    criterion = CrossEntropyLoss()
-
-    total_loss = 0
-    total_correct = 0
-    total_samples = 0
-
-    with torch.no_grad():
-        for batch in dataloader:
-
-            # Move tensors to device
-            images = batch["image"].to(device)
-            labels = batch["label"].to(device).long()
-
-            # Forward pass
-            outputs = model(images)
-            loss = criterion(outputs, labels)
-
-            total_loss += loss.item() * images.size(0)
-            total_correct += (outputs.argmax(dim=1) == labels).sum().item()
-            total_samples += labels.size(0)
-
-    accuracy = total_correct / total_samples
-    avg_loss = total_loss / total_samples
-
-    return {
-        "accuracy": accuracy,
-        "loss": avg_loss,
-    }
+import torch
+from torch.nn import CrossEntropyLoss
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+"""
+Evaluates a trained model on a dataloader that returns batches like:
+    batch["image"] -> Tensor [B, 3, 256, 256]
+    batch["label"] -> Tensor [B]
+"""
+def make_predictions(model, dataloader, device):
+
+    model.eval()
+    criterion = CrossEntropyLoss()
+
+    total_loss = 0
+    total_correct = 0
+    total_samples = 0
+
+    all_preds = []
+    all_labels = []
+
+    with torch.no_grad():
+        for batch in dataloader:
+
+            # Move tensors to device
+            images = batch["image"].to(device)
+            labels = batch["label"].to(device).long()
+
+            # Forward pass
+            outputs = model(images)
+            loss = criterion(outputs, labels)
+            preds = outputs.argmax(dim=1)
+
+            total_loss += loss.item() * images.size(0)
+            total_correct += (preds == labels).sum().item()
+            total_samples += labels.size(0)
+
+            # Accumulate all predictions and labels
+            all_preds.extend(preds.tolist())
+            all_labels.extend(labels.tolist())
+
+    accuracy = total_correct / total_samples
+    avg_loss = total_loss / total_samples
+
+    return {
+        "accuracy": accuracy,
+        "loss": avg_loss,
+        "predictions": np.array(all_preds),
+        "labels": np.array(all_labels),
+    }
+
+
+# Computes per-class accuracies
+def class_accuracies(labels, preds, num_classes):
+    correct = np.zeros(num_classes, dtype=int)
+    counts = np.zeros(num_classes, dtype=int)
+    accuracies = np.zeros(num_classes, dtype=float)
+
+    for true, pred in zip(labels, preds):
+        counts[true] += 1
+        if true == pred:
+            correct[true] += 1
+
+    # Calculate accuracies
+    for i in range(num_classes):
+        if counts[i] > 0:
+            accuracies[i] = round(correct[i] / counts[i], 4)
+        else:
+            accuracies[i] = 0.0 
+
+    return accuracies
+
+
+def plot_class_accuracies(accuracies, class_names):
+    fig, ax = plt.subplots(figsize=(12, 6))
+    
+    ax.set_title("Per-Class Accuracy")
+    ax.set_xlabel("Class")
+    ax.set_ylabel("Accuracy")
+    ax.set_ylim(0, 1.0)
+    ax.bar(class_names, accuracies)
+
+    plt.xticks(rotation=90)
+    plt.tight_layout()
+
+    return fig

testingModel/run_testing.py

@@ -4,7 +4,7 @@ from dataPrep.helpers.clearml_data import extract_latest_data_task
 import torch
 from models.modelOne import modelOne
 from models.modelTwo import BetterCNN
-from testingModel.helpers.evaluation import make_predictions
+from testingModel.helpers.evaluation import make_predictions, class_accuracies, plot_class_accuracies
 
 
 # -------------- Load Data --------------
@@ -66,6 +66,27 @@ subset_results = make_predictions(model, test_subset, device)
 testing_logger.report_single_value(name="Test Subset Accuracy", value=subset_results["accuracy"])
 testing_logger.report_single_value(name="Test Subset Loss", value=subset_results["loss"])
 
+# Compute per-class accuracy
+preds = subset_results["predictions"]
+labels = subset_results["labels"]
+class_acc = class_accuracies(
+    labels,
+    preds,
+    num_classes=testing_config["num_classes"]
+)
+
+# Plot with formatted class names
+class_names = subset_loaders['classNames']
+formatted_class_names = [" ".join(name.replace('_', ' ').split()) for name in class_names]
+acc_fig = plot_class_accuracies(class_acc, formatted_class_names)
+
+# Log accuracies plot to ClearML
+testing_logger.report_matplotlib_figure(
+    title="Subset Per-Class Accuracy",
+    series="Class Accuracy",
+    figure=acc_fig
+)
+
 
 # --------- Complete -----------------
 print("\n------ Testing Complete ------")