Delete densenet_withglam.ipynb

densenet_withglam.ipynb

@@ -1,1731 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "import torch.nn as nn\n",
-    "import torch.optim as optim\n",
-    "from torchvision import datasets, models, transforms\n",
-    "from torch.utils.data import DataLoader, random_split\n",
-    "from sklearn.metrics import (\n",
-    "    accuracy_score, f1_score, precision_score, recall_score,\n",
-    "    roc_auc_score, roc_curve, confusion_matrix, auc, classification_report\n",
-    ")\n",
-    "from sklearn.preprocessing import label_binarize\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import itertools\n",
-    "import random\n",
-    "import json\n",
-    "from tqdm import tqdm\n",
-    "from timm import create_model\n",
-    "import os"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "checkpoint = torch.load('densenet169_seed40_best.pt', map_location='cpu')\n",
-    "state_dict = checkpoint['state_dict']\n",
-    "\n",
-    "for k in list(state_dict.keys())[:10]:\n",
-    "    print(k)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/tmp/ipykernel_65719/145292541.py:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
-      "  checkpoint = torch.load('densenet169_seed40_best.pt', map_location='cpu')\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "features.0.conv0.weight\n",
-      "features.0.norm0.weight\n",
-      "features.0.norm0.bias\n",
-      "features.0.norm0.running_mean\n",
-      "features.0.norm0.running_var\n",
-      "features.0.norm0.num_batches_tracked\n",
-      "features.0.denseblock1.denselayer1.norm1.weight\n",
-      "features.0.denseblock1.denselayer1.norm1.bias\n",
-      "features.0.denseblock1.denselayer1.norm1.running_mean\n",
-      "features.0.denseblock1.denselayer1.norm1.running_var\n"
-     ]
-    }
-   ],
-   "source": [
-    "\n",
-    "checkpoint = torch.load('densenet169_seed40_best.pt', map_location='cpu')\n",
-    "state_dict = checkpoint['state_dict']\n",
-    "\n",
-    "for k in list(state_dict.keys())[:10]:\n",
-    "    print(k)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "import torch.nn as nn\n",
-    "import torch.nn.functional as F\n",
-    "\n",
-    "\n",
-    "class GLAM(nn.Module):\n",
-    "    \"\"\"\n",
-    "    Global-Local Attention Module (GLAM) that produces a refined feature map.\n",
-    "    \"\"\"\n",
-    "    def __init__(self, in_channels, reduction_ratio=8):\n",
-    "        super(GLAM, self).__init__()\n",
-    "        \n",
-    "        # --- Local Channel Attention ---\n",
-    "        self.local_channel_conv = nn.Conv2d(in_channels, in_channels // reduction_ratio, kernel_size=1)\n",
-    "        self.local_channel_act = nn.Sigmoid()\n",
-    "        self.local_channel_expand = nn.Conv2d(in_channels // reduction_ratio, in_channels, kernel_size=1)\n",
-    "        \n",
-    "        # --- Local Spatial Attention ---\n",
-    "        # 3-dilated, 5-dilated conv merges\n",
-    "        self.local_spatial_conv3 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=3, dilation=3)\n",
-    "        self.local_spatial_conv5 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=5, dilation=5)\n",
-    "        self.local_spatial_merge = nn.Conv2d(in_channels * 3, in_channels, kernel_size=1)\n",
-    "        self.local_spatial_act = nn.Sigmoid()\n",
-    "        \n",
-    "        # --- Global Channel Attention ---\n",
-    "        self.global_avg_pool = nn.AdaptiveAvgPool2d(1)\n",
-    "        self.global_channel_fc1 = nn.Linear(in_channels, in_channels // reduction_ratio)\n",
-    "        self.global_channel_fc2 = nn.Linear(in_channels // reduction_ratio, in_channels)\n",
-    "        self.global_channel_act = nn.Sigmoid()\n",
-    "        \n",
-    "        # --- Global Spatial Attention ---\n",
-    "        self.global_spatial_conv = nn.Conv2d(in_channels, 1, kernel_size=1)\n",
-    "        self.global_spatial_softmax = nn.Softmax(dim=-1)\n",
-    "        \n",
-    "        \n",
-    "        # --- Weighted paramerers initialization ---\n",
-    "        self.local_attention_weight = nn.Parameter(torch.tensor(1.0))  \n",
-    "        self.global_attention_weight = nn.Parameter(torch.tensor(1.0))\n",
-    "        \n",
-    "\n",
-    "    def forward(self, x):\n",
-    "        # Local Channel Attention\n",
-    "        lca = self.local_channel_conv(x)       \n",
-    "        lca = self.local_channel_act(lca)      \n",
-    "        lca = self.local_channel_expand(lca)   \n",
-    "        lca_out = lca * x                      \n",
-    "\n",
-    "        # Local Spatial Attention\n",
-    "        lsa3 = self.local_spatial_conv3(x)\n",
-    "        lsa5 = self.local_spatial_conv5(x)\n",
-    "        lsa_cat = torch.cat([x, lsa3, lsa5], dim=1)\n",
-    "        lsa = self.local_spatial_merge(lsa_cat)\n",
-    "        lsa = self.local_spatial_act(lsa)\n",
-    "        lsa_out = lsa * lca_out\n",
-    "        lsa_out = lsa_out + lca_out\n",
-    "\n",
-    "        # Global Channel Attention\n",
-    "        B, C, H, W = x.size()\n",
-    "        gca = self.global_avg_pool(x).view(B, C)  \n",
-    "        gca = F.relu(self.global_channel_fc1(gca), inplace=True)\n",
-    "        gca = self.global_channel_fc2(gca)\n",
-    "        gca = self.global_channel_act(gca)\n",
-    "        gca = gca.view(B, C, 1, 1)\n",
-    "        gca_out = gca * x\n",
-    "\n",
-    "        # Global Spatial Attention\n",
-    "        gsa = self.global_spatial_conv(x)  # [B, 1, H, W]\n",
-    "        gsa = gsa.view(B, -1)              # [B, H*W]\n",
-    "        gsa = self.global_spatial_softmax(gsa)\n",
-    "        gsa = gsa.view(B, 1, H, W)\n",
-    "        gsa_out = gsa * gca_out\n",
-    "        gsa_out = gsa_out + gca_out\n",
-    "\n",
-    "        # Fuse\n",
-    "        out =  lsa_out*self.local_attention_weight +  gsa_out*self.global_attention_weight + x\n",
-    "        return out\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def get_model_with_attention(model_name, num_classes):\n",
-    "    \"\"\"Get a pretrained model and attach GLAM attention block.\"\"\"\n",
-    "    # Ensure GLAM is imported or defined in the notebook\n",
-    "    # from your_glam_module import GLAM\n",
-    "\n",
-    "    if model_name == 'mobilenet_v2':\n",
-    "        model = models.mobilenet_v2(pretrained=True)\n",
-    "        in_channels = 1280\n",
-    "        model.features.add_module(\"attention\", GLAM(in_channels))\n",
-    "        model.classifier[1] = nn.Linear(in_channels, num_classes)\n",
-    "\n",
-    "    elif model_name == 'mobilenet_v3':\n",
-    "        model = models.mobilenet_v3_large(pretrained=True)\n",
-    "        in_channels = 960\n",
-    "        model.features.add_module(\"attention\", GLAM(in_channels))\n",
-    "        model.classifier = nn.Sequential(\n",
-    "            nn.Linear(in_channels, 1280),\n",
-    "            nn.Hardswish(),\n",
-    "            nn.Dropout(p=0.2),\n",
-    "            nn.Linear(1280, num_classes)\n",
-    "        )\n",
-    "\n",
-    "    elif model_name == 'efficientnet':\n",
-    "        model = models.efficientnet_b0(pretrained=True)\n",
-    "        in_channels = model.classifier[1].in_features\n",
-    "        model.features = nn.Sequential(model.features, GLAM(in_channels))\n",
-    "        model.classifier[1] = nn.Linear(in_channels, num_classes)\n",
-    "\n",
-    "    elif model_name == 'densenet121':\n",
-    "        model = models.densenet121(pretrained=True)\n",
-    "        in_channels = model.classifier.in_features\n",
-    "        model.features = nn.Sequential(model.features, nn.ReLU(inplace=True), GLAM(in_channels))\n",
-    "        model.classifier = nn.Linear(in_channels, num_classes)\n",
-    "\n",
-    "    elif model_name == 'densenet161':\n",
-    "        model = models.densenet161(pretrained=True)\n",
-    "        in_channels = model.classifier.in_features\n",
-    "        model.features = nn.Sequential(model.features, nn.ReLU(inplace=True), GLAM(in_channels))\n",
-    "        model.classifier = nn.Linear(in_channels, num_classes)\n",
-    "\n",
-    "    elif model_name == 'densenet169':\n",
-    "        model = models.densenet169(pretrained=True)\n",
-    "        in_channels = model.classifier.in_features\n",
-    "        model.features = nn.Sequential(model.features, nn.ReLU(inplace=True), GLAM(in_channels))\n",
-    "        model.classifier = nn.Linear(in_channels, num_classes)\n",
-    "\n",
-    "    elif model_name == 'vgg16':\n",
-    "        model = models.vgg16(pretrained=True)\n",
-    "        in_channels = 512\n",
-    "        model.features = nn.Sequential(model.features, GLAM(in_channels))\n",
-    "        model.classifier[6] = nn.Linear(4096, num_classes)\n",
-    "\n",
-    "    elif model_name == 'resnet18':\n",
-    "        model = models.resnet18(pretrained=True)\n",
-    "        in_channels = model.fc.in_features\n",
-    "        model.layer4.add_module(\"attention\", GLAM(in_channels))\n",
-    "        model.fc = nn.Linear(in_channels, num_classes)\n",
-    "\n",
-    "    elif model_name == 'resnet50':\n",
-    "        model = models.resnet50(pretrained=True)\n",
-    "        in_channels = model.fc.in_features\n",
-    "        model.layer4.add_module(\"attention\", GLAM(in_channels))\n",
-    "        model.fc = nn.Linear(in_channels, num_classes)\n",
-    "\n",
-    "    else:\n",
-    "        raise ValueError(f\"Unsupported model name: {model_name}\")\n",
-    "\n",
-    "    return model\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class EarlyStopping:\n",
-    "    \"\"\"Early stopping class with checkpointing support.\"\"\"\n",
-    "    def __init__(self, patience=30, verbose=False, delta=0.0, path='checkpoint.pt', minEpochs=10):\n",
-    "        self.patience = patience\n",
-    "        self.verbose = verbose\n",
-    "        self.delta = delta\n",
-    "        self.path = path\n",
-    "        self.counter = 0\n",
-    "        self.best_loss = None\n",
-    "        self.early_stop = False\n",
-    "        self.val_loss_min = np.Inf\n",
-    "        self.minEpochs = minEpochs\n",
-    "\n",
-    "    def __call__(self, val_loss, model, epochNum):\n",
-    "        \"\"\"Check if early stopping should be activated.\"\"\"\n",
-    "        if epochNum < self.minEpochs:\n",
-    "            return\n",
-    "        if self.best_loss is None:\n",
-    "            self.best_loss = val_loss\n",
-    "            self.save_checkpoint(val_loss, model, epochNum)\n",
-    "        elif val_loss > self.best_loss - self.delta:\n",
-    "            self.counter += 1\n",
-    "            if self.verbose:\n",
-    "                print(f'EarlyStopping counter: {self.counter} out of {self.patience}')\n",
-    "            if self.counter >= self.patience:\n",
-    "                self.early_stop = True\n",
-    "        else:\n",
-    "            self.best_loss = val_loss\n",
-    "            self.save_checkpoint(val_loss, model, epochNum)\n",
-    "            self.counter = 0\n",
-    "\n",
-    "    def save_checkpoint(self, val_loss, model, epochNum):\n",
-    "        \"\"\"Save checkpoint dict with state_dict and relevant metadata.\"\"\"\n",
-    "        if self.verbose:\n",
-    "            print(f'Validation loss decreased ({self.val_loss_min:.6f} --> {val_loss:.6f}). Saving checkpoint...')\n",
-    "        checkpoint = {\n",
-    "            'state_dict': model.state_dict(),\n",
-    "            'val_loss': val_loss,\n",
-    "            'epoch': epochNum\n",
-    "        }\n",
-    "        torch.save(checkpoint, self.path)\n",
-    "        self.val_loss_min = val_loss\n",
-    "\n",
-    "\n",
-    "class ModelTrainer:\n",
-    "    \"\"\"Trainer for PyTorch model with early stopping, training, and evaluation.\"\"\"\n",
-    "    def __init__(\n",
-    "        self, model, train_loader, val_loader, test_loader,\n",
-    "        criterion, optimizer, device, model_name='model', seed=42\n",
-    "    ):\n",
-    "        self.model = model\n",
-    "        self.train_loader = train_loader\n",
-    "        self.val_loader = val_loader\n",
-    "        self.test_loader = test_loader\n",
-    "        self.criterion = criterion\n",
-    "        self.optimizer = optimizer\n",
-    "        self.device = device\n",
-    "        self.model_name = f\"{model_name}_seed{seed}\"\n",
-    "        self.history = {\n",
-    "            'train_loss': [], 'val_loss': [],\n",
-    "            'train_acc': [], 'val_acc': [],\n",
-    "            'best_epoch': 0\n",
-    "        }\n",
-    "\n",
-    "    def train_epoch(self):\n",
-    "        \"\"\"Perform one training epoch.\"\"\"\n",
-    "        self.model.train()\n",
-    "        running_loss = 0.0\n",
-    "        running_corrects = 0\n",
-    "        total_samples = 0\n",
-    "        for inputs, labels in tqdm(self.train_loader, desc='Training'):\n",
-    "            inputs = inputs.to(self.device)\n",
-    "            labels = labels.to(self.device)\n",
-    "\n",
-    "            self.optimizer.zero_grad()\n",
-    "            outputs = self.model(inputs)\n",
-    "\n",
-    "            loss = self.criterion(outputs, labels)\n",
-    "\n",
-    "            loss.backward()\n",
-    "            self.optimizer.step()\n",
-    "\n",
-    "            _, preds = torch.max(outputs, 1)\n",
-    "            running_loss += loss.item() * inputs.size(0)\n",
-    "            running_corrects += torch.sum(preds == labels.data).item()\n",
-    "            total_samples += inputs.size(0)\n",
-    "\n",
-    "        return running_loss / total_samples, running_corrects / total_samples, None\n",
-    "\n",
-    "    def validate_epoch(self):\n",
-    "        \"\"\"Perform one validation epoch.\"\"\"\n",
-    "        self.model.eval()\n",
-    "        running_loss = 0.0\n",
-    "        running_corrects = 0\n",
-    "        total_samples = 0\n",
-    "\n",
-    "        with torch.no_grad():\n",
-    "            for inputs, labels in self.val_loader:\n",
-    "                inputs = inputs.to(self.device)\n",
-    "                labels = labels.to(self.device)\n",
-    "\n",
-    "                outputs = self.model(inputs)\n",
-    "\n",
-    "                loss = self.criterion(outputs, labels)\n",
-    "\n",
-    "                _, preds = torch.max(outputs, 1)\n",
-    "                running_loss += loss.item() * inputs.size(0)\n",
-    "                running_corrects += torch.sum(preds == labels.data).item()\n",
-    "                total_samples += inputs.size(0)\n",
-    "\n",
-    "        return running_loss / total_samples, running_corrects / total_samples, None\n",
-    "\n",
-    "    def train(self, num_epochs=100, patience=20):\n",
-    "        \"\"\"Train the model for a number of epochs with early stopping.\"\"\"\n",
-    "        early_stopping = EarlyStopping(\n",
-    "            patience=patience,\n",
-    "            verbose=True,\n",
-    "            path=f'{self.model_name}_best.pt',\n",
-    "            minEpochs=num_epochs // 4\n",
-    "        )\n",
-    "        for epoch in range(num_epochs):\n",
-    "            print(f'\\nEpoch {epoch + 1}/{num_epochs}')\n",
-    "            train_loss, train_acc, _ = self.train_epoch()\n",
-    "            val_loss, val_acc, _ = self.validate_epoch()\n",
-    "\n",
-    "            self.history['train_loss'].append(train_loss)\n",
-    "            self.history['train_acc'].append(train_acc)\n",
-    "            self.history['val_loss'].append(val_loss)\n",
-    "            self.history['val_acc'].append(val_acc)\n",
-    "\n",
-    "            print(f'Train Loss: {train_loss:.4f} | Acc: {train_acc:.4f}')\n",
-    "            print(f'Val   Loss: {val_loss:.4f} | Acc: {val_acc:.4f}')\n",
-    "\n",
-    "            early_stopping(val_loss, self.model, epoch)\n",
-    "            if early_stopping.early_stop:\n",
-    "                print(\"Early stopping triggered.\")\n",
-    "                self.history['best_epoch'] = epoch\n",
-    "                break\n",
-    "\n",
-    "        # Load best checkpoint\n",
-    "        checkpoint = torch.load(f'{self.model_name}_best.pt')\n",
-    "        self.model.load_state_dict(checkpoint['state_dict'])\n",
-    "        return self.history\n",
-    "\n",
-    "    def evaluate(self, save_root=\"./eval_plots\"):\n",
-    "        \"\"\"Evaluate the model and save metrics and ROC curves.\"\"\"\n",
-    "        self.model.eval()\n",
-    "        y_true, y_pred, y_prob = [], [], []\n",
-    "        pbar = tqdm(self.test_loader, desc='Testing')\n",
-    "        with torch.no_grad():\n",
-    "            for inputs, labels in pbar:\n",
-    "                inputs = inputs.to(self.device)\n",
-    "                labels = labels.to(self.device)\n",
-    "\n",
-    "                logits = self.model(inputs)\n",
-    "                probs = torch.softmax(logits, dim=1)\n",
-    "                preds = probs.argmax(dim=1)\n",
-    "\n",
-    "                y_true.extend(labels.cpu().numpy())\n",
-    "                y_pred.extend(preds.cpu().numpy())\n",
-    "                y_prob.extend(probs.cpu().numpy())\n",
-    "\n",
-    "        y_true = np.array(y_true)\n",
-    "        y_pred = np.array(y_pred)\n",
-    "        y_prob = np.array(y_prob)\n",
-    "        num_classes = y_prob.shape[1]\n",
-    "        y_true_bin = label_binarize(y_true, classes=list(range(num_classes)))\n",
-    "\n",
-    "        # Metrics\n",
-    "        accuracy = accuracy_score(y_true, y_pred)\n",
-    "        f1 = f1_score(y_true, y_pred, average='weighted')\n",
-    "        precision = precision_score(y_true, y_pred, average='weighted')\n",
-    "        recall = recall_score(y_true, y_pred, average='weighted')\n",
-    "        auc_macro = roc_auc_score(y_true_bin, y_prob, average='macro', multi_class='ovr')\n",
-    "\n",
-    "        print(f\"Accuracy:    {accuracy:.4f}\")\n",
-    "        print(f\"F1 Score:    {f1:.4f}\")\n",
-    "        print(f\"Precision:   {precision:.4f}\")\n",
-    "        print(f\"Recall:      {recall:.4f}\")\n",
-    "        print(f\"AUC (macro): {auc_macro:.4f}\")\n",
-    "\n",
-    "        # Save directory\n",
-    "        save_dir = os.path.join(save_root, self.model_name)\n",
-    "        os.makedirs(save_dir, exist_ok=True)\n",
-    "\n",
-    "        # Confusion Matrix\n",
-    "        cm = confusion_matrix(y_true, y_pred)\n",
-    "        plt.figure(figsize=(8, 6))\n",
-    "        plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)\n",
-    "        plt.title(\"Confusion Matrix\")\n",
-    "        plt.colorbar()\n",
-    "        ticks = np.arange(num_classes)\n",
-    "        plt.xticks(ticks, ticks)\n",
-    "        plt.yticks(ticks, ticks)\n",
-    "        thresh = cm.max() / 2.\n",
-    "        for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
-    "            plt.text(j, i, format(cm[i, j], 'd'),\n",
-    "                     ha=\"center\",\n",
-    "                     color=\"white\" if cm[i, j] > thresh else \"black\")\n",
-    "        plt.ylabel('True label')\n",
-    "        plt.xlabel('Predicted label')\n",
-    "        plt.tight_layout()\n",
-    "        plt.savefig(os.path.join(save_dir, \"confusion_matrix.jpg\"), format='jpg')\n",
-    "        plt.close()\n",
-    "\n",
-    "        # Class-wise ROC\n",
-    "        fpr, tpr, roc_auc_values = {}, {}, {}\n",
-    "        for i in range(num_classes):\n",
-    "            fpr[i], tpr[i], _ = roc_curve(y_true_bin[:, i], y_prob[:, i])\n",
-    "            roc_auc_values[i] = auc(fpr[i], tpr[i])\n",
-    "\n",
-    "        plt.figure()\n",
-    "        for i in range(num_classes):\n",
-    "            plt.plot(fpr[i], tpr[i], label=f\"Class {i} (AUC = {roc_auc_values[i]:.2f})\")\n",
-    "        plt.plot([0, 1], [0, 1], linestyle='--')\n",
-    "        plt.title(\"Class-wise ROC Curves\")\n",
-    "        plt.xlabel(\"False Positive Rate\")\n",
-    "        plt.ylabel(\"True Positive Rate\")\n",
-    "        plt.legend(loc=\"lower right\")\n",
-    "        plt.tight_layout()\n",
-    "        plt.savefig(os.path.join(save_dir, \"classwise_auc_roc.jpg\"), format='jpg')\n",
-    "        plt.close()\n",
-    "\n",
-    "        # Overall ROC\n",
-    "        fpr_mac, tpr_mac, _ = roc_curve(y_true_bin.ravel(), y_prob.ravel())\n",
-    "        roc_auc_mac = auc(fpr_mac, tpr_mac)\n",
-    "        plt.figure()\n",
-    "        plt.plot(fpr_mac, tpr_mac, label=f\"Overall (macro) ROC (AUC = {roc_auc_mac:.2f})\")\n",
-    "        plt.plot([0, 1], [0, 1], linestyle='--')\n",
-    "        plt.title(\"Overall (Macro) ROC Curve\")\n",
-    "        plt.xlabel(\"False Positive Rate\")\n",
-    "        plt.ylabel(\"True Positive Rate\")\n",
-    "        plt.legend(loc=\"lower right\")\n",
-    "        plt.tight_layout()\n",
-    "        plt.savefig(os.path.join(save_dir, \"overall_auc_roc.jpg\"), format='jpg')\n",
-    "        plt.close()\n",
-    "\n",
-    "        # Classification Report\n",
-    "        report = classification_report(y_true, y_pred)\n",
-    "        print(\"\\nClassification Report:\\n\", report)\n",
-    "\n",
-    "        return {\n",
-    "            'accuracy': accuracy,\n",
-    "            'f1_score': f1,\n",
-    "            'precision': precision,\n",
-    "            'recall': recall,\n",
-    "            'auc_macro': auc_macro,\n",
-    "            'confusion_matrix': cm.tolist(),\n",
-    "            'classification_report': report,\n",
-    "            'plots_dir': save_dir\n",
-    "        }\n",
-    "\n",
-    "\n",
-    "def set_seed(seed):\n",
-    "    \"\"\"Set random seed for reproducibility across Python, PyTorch, and NumPy.\"\"\"\n",
-    "    torch.manual_seed(seed)\n",
-    "    torch.cuda.manual_seed(seed)\n",
-    "    torch.cuda.manual_seed_all(seed)\n",
-    "    np.random.seed(seed)\n",
-    "    random.seed(seed)\n",
-    "    torch.backends.cudnn.deterministic = True\n",
-    "    torch.backends.cudnn.benchmark = False"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🖥️ Using device: cuda:7\n",
-      "\n",
-      "🚀 Training densenet169 with seed 40\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/raid/home/sbag/anaconda3/envs/yashwantvenv/lib/python3.8/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
-      "  warnings.warn(\n",
-      "/raid/home/sbag/anaconda3/envs/yashwantvenv/lib/python3.8/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=DenseNet169_Weights.IMAGENET1K_V1`. You can also use `weights=DenseNet169_Weights.DEFAULT` to get the most up-to-date weights.\n",
-      "  warnings.warn(msg)\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Epoch 1/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.52it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.6409 | Acc: 0.7247\n",
-      "Val   Loss: 0.5123 | Acc: 0.8097\n",
-      "\n",
-      "Epoch 2/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.55it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.2327 | Acc: 0.9251\n",
-      "Val   Loss: 0.4905 | Acc: 0.7773\n",
-      "\n",
-      "Epoch 3/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.55it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.1046 | Acc: 0.9717\n",
-      "Val   Loss: 0.5231 | Acc: 0.8057\n",
-      "\n",
-      "Epoch 4/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.55it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0758 | Acc: 0.9868\n",
-      "Val   Loss: 0.5464 | Acc: 0.8097\n",
-      "\n",
-      "Epoch 5/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.55it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0505 | Acc: 0.9879\n",
-      "Val   Loss: 0.4652 | Acc: 0.8381\n",
-      "\n",
-      "Epoch 6/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.54it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0384 | Acc: 0.9909\n",
-      "Val   Loss: 0.5930 | Acc: 0.8016\n",
-      "\n",
-      "Epoch 7/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.53it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0368 | Acc: 0.9889\n",
-      "Val   Loss: 0.6190 | Acc: 0.7733\n",
-      "\n",
-      "Epoch 8/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.54it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0680 | Acc: 0.9706\n",
-      "Val   Loss: 0.6185 | Acc: 0.8057\n",
-      "\n",
-      "Epoch 9/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:39<00:00,  1.55it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.1453 | Acc: 0.9393\n",
-      "Val   Loss: 0.7820 | Acc: 0.7652\n",
-      "\n",
-      "Epoch 10/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.55it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.1284 | Acc: 0.9565\n",
-      "Val   Loss: 0.6574 | Acc: 0.7895\n",
-      "\n",
-      "Epoch 11/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:39<00:00,  1.56it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0861 | Acc: 0.9636\n",
-      "Val   Loss: 0.6034 | Acc: 0.7854\n",
-      "\n",
-      "Epoch 12/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:39<00:00,  1.56it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0318 | Acc: 0.9929\n",
-      "Val   Loss: 0.5974 | Acc: 0.8300\n",
-      "\n",
-      "Epoch 13/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.52it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0133 | Acc: 0.9949\n",
-      "Val   Loss: 0.6431 | Acc: 0.7976\n",
-      "\n",
-      "Epoch 14/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:45<00:00,  1.36it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0130 | Acc: 0.9949\n",
-      "Val   Loss: 0.6782 | Acc: 0.8340\n",
-      "\n",
-      "Epoch 15/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:45<00:00,  1.36it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0108 | Acc: 0.9960\n",
-      "Val   Loss: 0.6482 | Acc: 0.8138\n",
-      "\n",
-      "Epoch 16/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.54it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0106 | Acc: 0.9929\n",
-      "Val   Loss: 0.6366 | Acc: 0.8138\n",
-      "\n",
-      "Epoch 17/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.55it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0208 | Acc: 0.9919\n",
-      "Val   Loss: 0.8402 | Acc: 0.7854\n",
-      "\n",
-      "Epoch 18/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:39<00:00,  1.55it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0180 | Acc: 0.9919\n",
-      "Val   Loss: 0.7927 | Acc: 0.8097\n",
-      "\n",
-      "Epoch 19/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:44<00:00,  1.39it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0113 | Acc: 0.9960\n",
-      "Val   Loss: 0.6292 | Acc: 0.8421\n",
-      "\n",
-      "Epoch 20/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:44<00:00,  1.40it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0297 | Acc: 0.9879\n",
-      "Val   Loss: 0.7917 | Acc: 0.7935\n",
-      "\n",
-      "Epoch 21/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.54it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0325 | Acc: 0.9858\n",
-      "Val   Loss: 0.8198 | Acc: 0.8259\n",
-      "\n",
-      "Epoch 22/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.54it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0692 | Acc: 0.9717\n",
-      "Val   Loss: 0.9598 | Acc: 0.7733\n",
-      "\n",
-      "Epoch 23/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:42<00:00,  1.46it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.1032 | Acc: 0.9626\n",
-      "Val   Loss: 0.7010 | Acc: 0.7976\n",
-      "\n",
-      "Epoch 24/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.54it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0464 | Acc: 0.9818\n",
-      "Val   Loss: 0.7204 | Acc: 0.7895\n",
-      "\n",
-      "Epoch 25/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:40<00:00,  1.54it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0126 | Acc: 0.9970\n",
-      "Val   Loss: 0.7141 | Acc: 0.7935\n",
-      "\n",
-      "Epoch 26/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:42<00:00,  1.45it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0298 | Acc: 0.9889\n",
-      "Val   Loss: 0.8210 | Acc: 0.8057\n",
-      "Validation loss decreased (inf --> 0.820993). Saving checkpoint...\n",
-      "\n",
-      "Epoch 27/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:33<00:00,  1.84it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0346 | Acc: 0.9868\n",
-      "Val   Loss: 0.8775 | Acc: 0.8138\n",
-      "EarlyStopping counter: 1 out of 30\n",
-      "\n",
-      "Epoch 28/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:39<00:00,  1.58it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0334 | Acc: 0.9868\n",
-      "Val   Loss: 0.6443 | Acc: 0.8178\n",
-      "Validation loss decreased (0.820993 --> 0.644336). Saving checkpoint...\n",
-      "\n",
-      "Epoch 29/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.80it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0138 | Acc: 0.9919\n",
-      "Val   Loss: 0.7253 | Acc: 0.8178\n",
-      "EarlyStopping counter: 1 out of 30\n",
-      "\n",
-      "Epoch 30/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:33<00:00,  1.88it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0188 | Acc: 0.9919\n",
-      "Val   Loss: 0.6810 | Acc: 0.7854\n",
-      "EarlyStopping counter: 2 out of 30\n",
-      "\n",
-      "Epoch 31/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.81it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0103 | Acc: 0.9949\n",
-      "Val   Loss: 0.7952 | Acc: 0.8097\n",
-      "EarlyStopping counter: 3 out of 30\n",
-      "\n",
-      "Epoch 32/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.80it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0128 | Acc: 0.9939\n",
-      "Val   Loss: 0.7404 | Acc: 0.8178\n",
-      "EarlyStopping counter: 4 out of 30\n",
-      "\n",
-      "Epoch 33/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:33<00:00,  1.84it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0144 | Acc: 0.9919\n",
-      "Val   Loss: 0.7201 | Acc: 0.8178\n",
-      "EarlyStopping counter: 5 out of 30\n",
-      "\n",
-      "Epoch 34/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:33<00:00,  1.84it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0151 | Acc: 0.9949\n",
-      "Val   Loss: 0.7246 | Acc: 0.8178\n",
-      "EarlyStopping counter: 6 out of 30\n",
-      "\n",
-      "Epoch 35/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:33<00:00,  1.85it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0101 | Acc: 0.9960\n",
-      "Val   Loss: 0.7968 | Acc: 0.8219\n",
-      "EarlyStopping counter: 7 out of 30\n",
-      "\n",
-      "Epoch 36/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:36<00:00,  1.71it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0093 | Acc: 0.9939\n",
-      "Val   Loss: 0.8325 | Acc: 0.8097\n",
-      "EarlyStopping counter: 8 out of 30\n",
-      "\n",
-      "Epoch 37/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:37<00:00,  1.65it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0095 | Acc: 0.9960\n",
-      "Val   Loss: 0.8379 | Acc: 0.8178\n",
-      "EarlyStopping counter: 9 out of 30\n",
-      "\n",
-      "Epoch 38/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.82it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0634 | Acc: 0.9757\n",
-      "Val   Loss: 0.8605 | Acc: 0.7571\n",
-      "EarlyStopping counter: 10 out of 30\n",
-      "\n",
-      "Epoch 39/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:41<00:00,  1.49it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.1095 | Acc: 0.9615\n",
-      "Val   Loss: 1.1914 | Acc: 0.7773\n",
-      "EarlyStopping counter: 11 out of 30\n",
-      "\n",
-      "Epoch 40/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:36<00:00,  1.69it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0696 | Acc: 0.9777\n",
-      "Val   Loss: 0.8333 | Acc: 0.8097\n",
-      "EarlyStopping counter: 12 out of 30\n",
-      "\n",
-      "Epoch 41/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.79it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0380 | Acc: 0.9828\n",
-      "Val   Loss: 0.7910 | Acc: 0.8381\n",
-      "EarlyStopping counter: 13 out of 30\n",
-      "\n",
-      "Epoch 42/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.78it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0196 | Acc: 0.9919\n",
-      "Val   Loss: 0.7824 | Acc: 0.8178\n",
-      "EarlyStopping counter: 14 out of 30\n",
-      "\n",
-      "Epoch 43/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:42<00:00,  1.45it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0163 | Acc: 0.9939\n",
-      "Val   Loss: 0.9460 | Acc: 0.8178\n",
-      "EarlyStopping counter: 15 out of 30\n",
-      "\n",
-      "Epoch 44/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.80it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0086 | Acc: 0.9949\n",
-      "Val   Loss: 0.8867 | Acc: 0.8259\n",
-      "EarlyStopping counter: 16 out of 30\n",
-      "\n",
-      "Epoch 45/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:33<00:00,  1.83it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0068 | Acc: 0.9949\n",
-      "Val   Loss: 0.8065 | Acc: 0.8300\n",
-      "EarlyStopping counter: 17 out of 30\n",
-      "\n",
-      "Epoch 46/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.82it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0067 | Acc: 0.9939\n",
-      "Val   Loss: 0.9346 | Acc: 0.8462\n",
-      "EarlyStopping counter: 18 out of 30\n",
-      "\n",
-      "Epoch 47/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.81it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0056 | Acc: 0.9970\n",
-      "Val   Loss: 0.8019 | Acc: 0.8340\n",
-      "EarlyStopping counter: 19 out of 30\n",
-      "\n",
-      "Epoch 48/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:33<00:00,  1.83it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0056 | Acc: 0.9970\n",
-      "Val   Loss: 0.8673 | Acc: 0.8421\n",
-      "EarlyStopping counter: 20 out of 30\n",
-      "\n",
-      "Epoch 49/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.82it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0051 | Acc: 0.9949\n",
-      "Val   Loss: 0.8609 | Acc: 0.8421\n",
-      "EarlyStopping counter: 21 out of 30\n",
-      "\n",
-      "Epoch 50/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:35<00:00,  1.74it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0051 | Acc: 0.9939\n",
-      "Val   Loss: 0.8720 | Acc: 0.8421\n",
-      "EarlyStopping counter: 22 out of 30\n",
-      "\n",
-      "Epoch 51/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.80it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0051 | Acc: 0.9970\n",
-      "Val   Loss: 0.8415 | Acc: 0.8340\n",
-      "EarlyStopping counter: 23 out of 30\n",
-      "\n",
-      "Epoch 52/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:41<00:00,  1.51it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0048 | Acc: 0.9970\n",
-      "Val   Loss: 0.8468 | Acc: 0.8421\n",
-      "EarlyStopping counter: 24 out of 30\n",
-      "\n",
-      "Epoch 53/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:35<00:00,  1.73it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0049 | Acc: 0.9960\n",
-      "Val   Loss: 0.8831 | Acc: 0.8502\n",
-      "EarlyStopping counter: 25 out of 30\n",
-      "\n",
-      "Epoch 54/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.80it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0060 | Acc: 0.9960\n",
-      "Val   Loss: 0.9027 | Acc: 0.8340\n",
-      "EarlyStopping counter: 26 out of 30\n",
-      "\n",
-      "Epoch 55/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.79it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0138 | Acc: 0.9919\n",
-      "Val   Loss: 0.8650 | Acc: 0.8300\n",
-      "EarlyStopping counter: 27 out of 30\n",
-      "\n",
-      "Epoch 56/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.80it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0283 | Acc: 0.9909\n",
-      "Val   Loss: 1.3316 | Acc: 0.7854\n",
-      "EarlyStopping counter: 28 out of 30\n",
-      "\n",
-      "Epoch 57/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.79it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0984 | Acc: 0.9666\n",
-      "Val   Loss: 0.7924 | Acc: 0.7935\n",
-      "EarlyStopping counter: 29 out of 30\n",
-      "\n",
-      "Epoch 58/100\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Training: 100%|██████████| 62/62 [00:34<00:00,  1.80it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train Loss: 0.0883 | Acc: 0.9666\n",
-      "Val   Loss: 0.8648 | Acc: 0.7935\n",
-      "EarlyStopping counter: 30 out of 30\n",
-      "Early stopping triggered.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/tmp/ipykernel_65719/2726642889.py:141: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
-      "  checkpoint = torch.load(f'{self.model_name}_best.pt')\n",
-      "Testing: 100%|██████████| 20/20 [00:09<00:00,  2.15it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Accuracy:    0.8317\n",
-      "F1 Score:    0.8266\n",
-      "Precision:   0.8237\n",
-      "Recall:      0.8317\n",
-      "AUC (macro): 0.9197\n",
-      "\n",
-      "Classification Report:\n",
-      "               precision    recall  f1-score   support\n",
-      "\n",
-      "           0       0.86      0.91      0.88        99\n",
-      "           1       0.59      0.49      0.54        53\n",
-      "           2       0.88      0.90      0.89       157\n",
-      "\n",
-      "    accuracy                           0.83       309\n",
-      "   macro avg       0.78      0.77      0.77       309\n",
-      "weighted avg       0.82      0.83      0.83       309\n",
-      "\n",
-      "\n",
-      "✅ Results saved to glaucoma_classification_glam_model_results_40.json\n"
-     ]
-    }
-   ],
-   "source": [
-    "def set_seed(seed):\n",
-    "    torch.manual_seed(seed)\n",
-    "    torch.cuda.manual_seed(seed)\n",
-    "    torch.cuda.manual_seed_all(seed)\n",
-    "    np.random.seed(seed)\n",
-    "    random.seed(seed)\n",
-    "    torch.backends.cudnn.deterministic = True\n",
-    "    torch.backends.cudnn.benchmark = False\n",
-    "\n",
-    "# ✅ Set device\n",
-    "device = torch.device(\"cuda:7\" if torch.cuda.is_available() else \"cpu\")\n",
-    "print(f'🖥️ Using device: {device}')\n",
-    "\n",
-    "# ✅ Define data transforms\n",
-    "data_transforms = {\n",
-    "    'train': transforms.Compose([\n",
-    "        transforms.RandomResizedCrop(224),\n",
-    "        transforms.RandomHorizontalFlip(),\n",
-    "        transforms.RandomRotation(15),\n",
-    "        transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1),\n",
-    "        transforms.ToTensor(),\n",
-    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
-    "    ]),\n",
-    "    'val': transforms.Compose([\n",
-    "        transforms.Resize(256),\n",
-    "        transforms.CenterCrop(224),\n",
-    "        transforms.ToTensor(),\n",
-    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
-    "    ]),\n",
-    "}\n",
-    "\n",
-    "# ✅ Define architecture and attention variants\n",
-    "architectures = [\"densenet169\"]\n",
-    "\n",
-    "models_to_test=architectures\n",
-    "seeds_to_test = [40]\n",
-    "num_classes = 3\n",
-    "results_file = 'glaucoma_classification_glam_model_results_40.json'\n",
-    "\n",
-    "# ✅ Store all results\n",
-    "all_results = {}\n",
-    "\n",
-    "# ✅ Main training loop\n",
-    "for model_name in models_to_test:\n",
-    "    model_results = {}\n",
-    "    for seed in seeds_to_test:\n",
-    "        print(f\"\\n🚀 Training {model_name} with seed {seed}\")\n",
-    "        set_seed(seed)\n",
-    "\n",
-    "        try:\n",
-    "            # Load dataset\n",
-    "            dataset = datasets.ImageFolder(\n",
-    "                root=\"/raid/home/sbag/B.tech/Final Results/processed_data\",\n",
-    "                transform=data_transforms['train']\n",
-    "            )\n",
-    "\n",
-    "            # Split data\n",
-    "            total_size = len(dataset)\n",
-    "            train_size = int(0.8 * total_size)\n",
-    "            test_size = total_size - train_size\n",
-    "            train_val_dataset, test_dataset = random_split(dataset, [train_size, test_size])\n",
-    "\n",
-    "            val_size = int(0.2 * train_size)\n",
-    "            train_size = train_size - val_size\n",
-    "            train_dataset, val_dataset = random_split(train_val_dataset, [train_size, val_size])\n",
-    "\n",
-    "            val_dataset.dataset.transform = data_transforms['val']\n",
-    "            test_dataset.dataset.transform = data_transforms['val']\n",
-    "\n",
-    "            # Create loaders\n",
-    "            train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True, num_workers=4, pin_memory=True)\n",
-    "            val_loader = DataLoader(val_dataset, batch_size=16, shuffle=False, num_workers=4, pin_memory=True)\n",
-    "            test_loader = DataLoader(test_dataset, batch_size=16, shuffle=False, num_workers=4, pin_memory=True)\n",
-    "\n",
-    "            # Get model with attention\n",
-    "            model = get_model_with_attention(model_name, num_classes=num_classes).to(device)\n",
-    "\n",
-    "            # Loss and optimizer\n",
-    "            criterion = nn.CrossEntropyLoss()\n",
-    "            optimizer = optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-4)\n",
-    "\n",
-    "            # Train\n",
-    "            trainer = ModelTrainer(\n",
-    "                model=model,\n",
-    "                train_loader=train_loader,\n",
-    "                val_loader=val_loader,\n",
-    "                test_loader=test_loader,\n",
-    "                criterion=criterion,\n",
-    "                optimizer=optimizer,\n",
-    "                device=device,\n",
-    "                model_name=model_name,\n",
-    "                seed=seed\n",
-    "            )\n",
-    "\n",
-    "            history = trainer.train(num_epochs=100, patience=30)\n",
-    "            results = trainer.evaluate()\n",
-    "            model_results[f\"seed_{seed}\"] = results\n",
-    "\n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error while training {model_name} (seed={seed}): {e}\")\n",
-    "            model_results[f\"seed_{seed}\"] = {\"error\": str(e)}\n",
-    "\n",
-    "    all_results[model_name] = model_results\n",
-    "\n",
-    "# ✅ Save all results\n",
-    "with open(results_file, 'w') as f:\n",
-    "    json.dump(all_results, f, indent=4)\n",
-    "\n",
-    "print(f\"\\n✅ Results saved to {results_file}\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "yashwantvenv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.19"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}