Upload 2 files

KhushalRamani_CNN_Assignment_final.ipynb

@@ -0,0 +1,1230 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "e5e86e2f",
+      "metadata": {
+        "id": "e5e86e2f"
+      },
+      "source": [
+        "# Assignment 1 — CNN: Beyond Basic Classification (CIFAR-10)\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "66b942b9",
+      "metadata": {
+        "id": "66b942b9"
+      },
+      "source": [
+        "## 1. Setup & Reproducibility"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "4dfcbbf2",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "4dfcbbf2",
+        "outputId": "1803599b-293f-4d56-d9fd-7d4887f3e40e"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "device(type='cuda')"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 1
+        }
+      ],
+      "source": [
+        "# !pip install torch torchvision matplotlib numpy scikit-learn --quiet\n",
+        "\n",
+        "import os, random, math, time\n",
+        "import numpy as np\n",
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "import torch.optim as optim\n",
+        "import torch.nn.functional as F\n",
+        "from torch.utils.data import DataLoader, Subset\n",
+        "from torchvision import datasets, transforms, utils as vutils\n",
+        "\n",
+        "import matplotlib.pyplot as plt\n",
+        "from sklearn.metrics import classification_report\n",
+        "from collections import defaultdict\n",
+        "\n",
+        "SEED = 1337\n",
+        "random.seed(SEED)\n",
+        "np.random.seed(SEED)\n",
+        "torch.manual_seed(SEED)\n",
+        "torch.cuda.manual_seed_all(SEED)\n",
+        "\n",
+        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+        "device"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "74b912d3",
+      "metadata": {
+        "id": "74b912d3"
+      },
+      "source": [
+        "## 2. Configuration"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "e76faeda",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "e76faeda",
+        "outputId": "dbc150b1-95c7-4b34-ff89-0eab9d2ec1f5"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "{'data_root': './data',\n",
+              " 'batch_size': 128,\n",
+              " 'num_workers': 2,\n",
+              " 'epochs_A': 15,\n",
+              " 'epochs_B': 25,\n",
+              " 'epochs_FC': 10,\n",
+              " 'lr': 0.001,\n",
+              " 'weight_decay': 0.0001,\n",
+              " 'momentum': 0.9,\n",
+              " 'print_every': 100,\n",
+              " 'subset_train': 1.0,\n",
+              " 'subset_test': 1.0}"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 2
+        }
+      ],
+      "source": [
+        "# Toggle this to True to run a *very* quick pass (few batches/epochs) for sanity checks.\n",
+        "FAST_DEBUG = False\n",
+        "\n",
+        "CFG = {\n",
+        "    \"data_root\": \"./data\",\n",
+        "    \"batch_size\": 128 if not FAST_DEBUG else 64,\n",
+        "    \"num_workers\": 2,\n",
+        "    \"epochs_A\": 15 if not FAST_DEBUG else 1,\n",
+        "    \"epochs_B\": 25 if not FAST_DEBUG else 1,\n",
+        "    \"epochs_FC\": 10 if not FAST_DEBUG else 1,\n",
+        "    \"lr\": 1e-3,\n",
+        "    \"weight_decay\": 1e-4,\n",
+        "    \"momentum\": 0.9,\n",
+        "    \"print_every\": 100 if not FAST_DEBUG else 10,\n",
+        "    \"subset_train\": 0.2 if FAST_DEBUG else 1.0,  # use a fraction of training data in FAST_DEBUG\n",
+        "    \"subset_test\": 0.2 if FAST_DEBUG else 1.0,\n",
+        "}\n",
+        "CFG"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "ebe81e30",
+      "metadata": {
+        "id": "ebe81e30"
+      },
+      "source": [
+        "## 3. Data — CIFAR-10 (with standard normalization)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "9686a204",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "9686a204",
+        "outputId": "7f48b6a7-0042-4a7b-a398-a15bd742a411"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "100%|██████████| 170M/170M [00:06<00:00, 26.9MB/s]\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(50000,\n",
+              " 10000,\n",
+              " ['airplane',\n",
+              "  'automobile',\n",
+              "  'bird',\n",
+              "  'cat',\n",
+              "  'deer',\n",
+              "  'dog',\n",
+              "  'frog',\n",
+              "  'horse',\n",
+              "  'ship',\n",
+              "  'truck'])"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 3
+        }
+      ],
+      "source": [
+        "# CIFAR-10 mean/std for normalization\n",
+        "CIFAR10_MEAN = (0.4914, 0.4822, 0.4465)\n",
+        "CIFAR10_STD  = (0.2470, 0.2435, 0.2616)\n",
+        "\n",
+        "train_tfms = transforms.Compose([\n",
+        "    transforms.RandomCrop(32, padding=4),\n",
+        "    transforms.RandomHorizontalFlip(),\n",
+        "    transforms.ToTensor(),\n",
+        "    transforms.Normalize(CIFAR10_MEAN, CIFAR10_STD),\n",
+        "])\n",
+        "\n",
+        "test_tfms = transforms.Compose([\n",
+        "    transforms.ToTensor(),\n",
+        "    transforms.Normalize(CIFAR10_MEAN, CIFAR10_STD),\n",
+        "])\n",
+        "\n",
+        "try:\n",
+        "    train_set = datasets.CIFAR10(root=CFG[\"data_root\"], train=True, download=True, transform=train_tfms)\n",
+        "    test_set  = datasets.CIFAR10(root=CFG[\"data_root\"], train=False, download=True, transform=test_tfms)\n",
+        "except Exception as e:\n",
+        "    print(\"⚠️ Failed to download CIFAR-10 (no internet?). If so, place the dataset under\", CFG[\"data_root\"], \"and rerun.\")\n",
+        "    raise e\n",
+        "\n",
+        "# Optionally shrink for FAST_DEBUG\n",
+        "if CFG[\"subset_train\"] < 1.0:\n",
+        "    n = int(len(train_set) * CFG[\"subset_train\"])\n",
+        "    train_set = Subset(train_set, list(range(n)))\n",
+        "\n",
+        "if CFG[\"subset_test\"] < 1.0:\n",
+        "    n = int(len(test_set) * CFG[\"subset_test\"])\n",
+        "    test_set  = Subset(test_set, list(range(n)))\n",
+        "\n",
+        "train_loader = DataLoader(train_set, batch_size=CFG[\"batch_size\"], shuffle=True, num_workers=CFG[\"num_workers\"], pin_memory=True)\n",
+        "test_loader  = DataLoader(test_set,  batch_size=CFG[\"batch_size\"], shuffle=False, num_workers=CFG[\"num_workers\"], pin_memory=True)\n",
+        "\n",
+        "classes = ['airplane', 'automobile', 'bird', 'cat', 'deer',\n",
+        "           'dog', 'frog', 'horse', 'ship', 'truck']\n",
+        "\n",
+        "len(train_set), len(test_set), classes"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "591aa8d2",
+      "metadata": {
+        "id": "591aa8d2"
+      },
+      "source": [
+        "## 4. Training Utilities"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "4680fb7d",
+      "metadata": {
+        "id": "4680fb7d"
+      },
+      "outputs": [],
+      "source": [
+        "def train_one_epoch(model, loader, criterion, optimizer, epoch, max_batches=None):\n",
+        "    model.train()\n",
+        "    running_loss = 0.0\n",
+        "    correct = 0\n",
+        "    total = 0\n",
+        "    for b, (x, y) in enumerate(loader, 1):\n",
+        "        if max_batches and b > max_batches: break\n",
+        "        x, y = x.to(device, non_blocking=True), y.to(device, non_blocking=True)\n",
+        "        optimizer.zero_grad(set_to_none=True)\n",
+        "        logits = model(x)\n",
+        "        loss = criterion(logits, y)\n",
+        "        loss.backward()\n",
+        "        optimizer.step()\n",
+        "\n",
+        "        running_loss += loss.item() * x.size(0)\n",
+        "        pred = logits.argmax(1)\n",
+        "        correct += (pred == y).sum().item()\n",
+        "        total += y.size(0)\n",
+        "\n",
+        "        if b % CFG[\"print_every\"] == 0:\n",
+        "            print(f\"  batch {b:4d} | loss {running_loss/total:.4f} | acc {100*correct/total:.2f}%\")\n",
+        "\n",
+        "    return running_loss/total, 100*correct/total\n",
+        "\n",
+        "@torch.no_grad()\n",
+        "def evaluate(model, loader, criterion, max_batches=None, return_preds=False):\n",
+        "    model.eval()\n",
+        "    running_loss = 0.0\n",
+        "    correct = 0\n",
+        "    total = 0\n",
+        "    all_preds, all_targets = [], []\n",
+        "    for b, (x, y) in enumerate(loader, 1):\n",
+        "        if max_batches and b > max_batches: break\n",
+        "        x, y = x.to(device, non_blocking=True), y.to(device, non_blocking=True)\n",
+        "        logits = model(x)\n",
+        "        loss = criterion(logits, y)\n",
+        "\n",
+        "        running_loss += loss.item() * x.size(0)\n",
+        "        pred = logits.argmax(1)\n",
+        "        correct += (pred == y).sum().item()\n",
+        "        total += y.size(0)\n",
+        "\n",
+        "        if return_preds:\n",
+        "            all_preds.append(pred.cpu().numpy())\n",
+        "            all_targets.append(y.cpu().numpy())\n",
+        "\n",
+        "    acc = 100*correct/total\n",
+        "    if return_preds:\n",
+        "        return running_loss/total, acc, np.concatenate(all_preds), np.concatenate(all_targets)\n",
+        "    return running_loss/total, acc"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "5ce173f6",
+      "metadata": {
+        "id": "5ce173f6"
+      },
+      "source": [
+        "## 5. Model A — 2×Conv → Pool → Dense"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "a8a30990",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "a8a30990",
+        "outputId": "bf0b0305-e385-4d51-f2b5-6b02037cf070"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "4.216522"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 5
+        }
+      ],
+      "source": [
+        "class ModelA(nn.Module):\n",
+        "    def __init__(self, num_classes=10):\n",
+        "        super().__init__()\n",
+        "        self.features = nn.Sequential(\n",
+        "            nn.Conv2d(3, 32, 3, padding=1),  # 32x32\n",
+        "            nn.ReLU(inplace=True),\n",
+        "            nn.Conv2d(32, 64, 3, padding=1), # 32x32\n",
+        "            nn.ReLU(inplace=True),\n",
+        "            nn.MaxPool2d(2),                  # 16x16\n",
+        "            nn.Dropout(0.1),\n",
+        "        )\n",
+        "        self.classifier = nn.Sequential(\n",
+        "            nn.Flatten(),\n",
+        "            nn.Linear(64*16*16, 256),\n",
+        "            nn.ReLU(inplace=True),\n",
+        "            nn.Dropout(0.2),\n",
+        "            nn.Linear(256, num_classes)\n",
+        "        )\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        x = self.features(x)\n",
+        "        x = self.classifier(x)\n",
+        "        return x\n",
+        "\n",
+        "model_a = ModelA().to(device)\n",
+        "sum(p.numel() for p in model_a.parameters())/1e6"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "f4d41abb",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "f4d41abb",
+        "outputId": "e8068ddd-01ae-49af-a840-085de6ad839b"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch [1/15] — Model A\n",
+            "  batch  100 | loss 1.8835 | acc 31.63%\n",
+            "  batch  200 | loss 1.7268 | acc 37.04%\n",
+            "  batch  300 | loss 1.6298 | acc 40.52%\n",
+            "  >> val_loss=1.1959 | val_acc=56.70%\n",
+            "Epoch [2/15] — Model A\n",
+            "  batch  100 | loss 1.2701 | acc 54.49%\n",
+            "  batch  200 | loss 1.2658 | acc 54.56%\n",
+            "  batch  300 | loss 1.2442 | acc 55.33%\n",
+            "  >> val_loss=0.9906 | val_acc=64.65%\n",
+            "Epoch [3/15] — Model A\n",
+            "  batch  100 | loss 1.1342 | acc 59.63%\n",
+            "  batch  200 | loss 1.1208 | acc 60.12%\n",
+            "  batch  300 | loss 1.1114 | acc 60.49%\n",
+            "  >> val_loss=0.9572 | val_acc=65.93%\n",
+            "Epoch [4/15] — Model A\n",
+            "  batch  100 | loss 1.0442 | acc 62.85%\n",
+            "  batch  200 | loss 1.0377 | acc 63.13%\n",
+            "  batch  300 | loss 1.0408 | acc 63.01%\n",
+            "  >> val_loss=0.8935 | val_acc=68.93%\n",
+            "Epoch [5/15] — Model A\n",
+            "  batch  100 | loss 0.9943 | acc 65.29%\n",
+            "  batch  200 | loss 0.9877 | acc 65.25%\n",
+            "  batch  300 | loss 0.9870 | acc 65.28%\n",
+            "  >> val_loss=0.8324 | val_acc=70.40%\n",
+            "Epoch [6/15] — Model A\n",
+            "  batch  100 | loss 0.9358 | acc 67.96%\n",
+            "  batch  200 | loss 0.9543 | acc 66.99%\n",
+            "  batch  300 | loss 0.9495 | acc 66.65%\n",
+            "  >> val_loss=0.8087 | val_acc=72.03%\n",
+            "Epoch [7/15] — Model A\n",
+            "  batch  100 | loss 0.9254 | acc 67.15%\n",
+            "  batch  200 | loss 0.9162 | acc 67.68%\n",
+            "  batch  300 | loss 0.9126 | acc 67.83%\n",
+            "  >> val_loss=0.7981 | val_acc=72.02%\n",
+            "Epoch [8/15] — Model A\n",
+            "  batch  100 | loss 0.9014 | acc 68.53%\n",
+            "  batch  200 | loss 0.8928 | acc 68.60%\n",
+            "  batch  300 | loss 0.8931 | acc 68.49%\n",
+            "  >> val_loss=0.7629 | val_acc=73.53%\n",
+            "Epoch [9/15] — Model A\n",
+            "  batch  100 | loss 0.8693 | acc 69.84%\n",
+            "  batch  200 | loss 0.8700 | acc 69.68%\n",
+            "  batch  300 | loss 0.8674 | acc 69.74%\n",
+            "  >> val_loss=0.7554 | val_acc=73.63%\n",
+            "Epoch [10/15] — Model A\n",
+            "  batch  100 | loss 0.8564 | acc 70.36%\n",
+            "  batch  200 | loss 0.8575 | acc 70.16%\n",
+            "  batch  300 | loss 0.8518 | acc 70.13%\n",
+            "  >> val_loss=0.7493 | val_acc=73.84%\n",
+            "Epoch [11/15] — Model A\n",
+            "  batch  100 | loss 0.8342 | acc 71.15%\n",
+            "  batch  200 | loss 0.8310 | acc 71.05%\n",
+            "  batch  300 | loss 0.8308 | acc 70.97%\n",
+            "  >> val_loss=0.7486 | val_acc=73.90%\n",
+            "Epoch [12/15] — Model A\n",
+            "  batch  100 | loss 0.8105 | acc 72.04%\n",
+            "  batch  200 | loss 0.8154 | acc 71.69%\n",
+            "  batch  300 | loss 0.8153 | acc 71.69%\n",
+            "  >> val_loss=0.7360 | val_acc=74.44%\n",
+            "Epoch [13/15] — Model A\n",
+            "  batch  100 | loss 0.8031 | acc 72.01%\n",
+            "  batch  200 | loss 0.8065 | acc 71.70%\n",
+            "  batch  300 | loss 0.8061 | acc 71.72%\n",
+            "  >> val_loss=0.7195 | val_acc=74.95%\n",
+            "Epoch [14/15] — Model A\n",
+            "  batch  100 | loss 0.8036 | acc 71.45%\n",
+            "  batch  200 | loss 0.8030 | acc 71.64%\n",
+            "  batch  300 | loss 0.7933 | acc 72.04%\n",
+            "  >> val_loss=0.7215 | val_acc=75.22%\n",
+            "Epoch [15/15] — Model A\n",
+            "  batch  100 | loss 0.7981 | acc 72.17%\n",
+            "  batch  200 | loss 0.7835 | acc 72.52%\n",
+            "  batch  300 | loss 0.7823 | acc 72.56%\n",
+            "  >> val_loss=0.7132 | val_acc=75.30%\n",
+            "Model A best val_acc: 75.3\n"
+          ]
+        }
+      ],
+      "source": [
+        "criterion = nn.CrossEntropyLoss()\n",
+        "optimizer_a = optim.AdamW(model_a.parameters(), lr=CFG[\"lr\"], weight_decay=CFG[\"weight_decay\"])\n",
+        "\n",
+        "history_a = defaultdict(list)\n",
+        "epochs = CFG[\"epochs_A\"]\n",
+        "for epoch in range(1, epochs+1):\n",
+        "    print(f\"Epoch [{epoch}/{epochs}] — Model A\")\n",
+        "    train_loss, train_acc = train_one_epoch(model_a, train_loader, criterion, optimizer_a,\n",
+        "                                            epoch, max_batches=10 if FAST_DEBUG else None)\n",
+        "    val_loss, val_acc = evaluate(model_a, test_loader, criterion,\n",
+        "                                 max_batches=10 if FAST_DEBUG else None)\n",
+        "    history_a[\"train_loss\"].append(train_loss)\n",
+        "    history_a[\"train_acc\"].append(train_acc)\n",
+        "    history_a[\"val_loss\"].append(val_loss)\n",
+        "    history_a[\"val_acc\"].append(val_acc)\n",
+        "    print(f\"  >> val_loss={val_loss:.4f} | val_acc={val_acc:.2f}%\")\n",
+        "\n",
+        "print(\"Model A best val_acc:\", max(history_a[\"val_acc\"]))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "1bdbf486",
+      "metadata": {
+        "id": "1bdbf486"
+      },
+      "source": [
+        "## 6. Model B — Deeper CNN (≥4 Conv) + BatchNorm + Dropout"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "3d3181e2",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "3d3181e2",
+        "outputId": "419ef852-283b-41a3-c0c1-69c95ff76524"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "4.460874"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 7
+        }
+      ],
+      "source": [
+        "class ModelB(nn.Module):\n",
+        "    def __init__(self, num_classes=10):\n",
+        "        super().__init__()\n",
+        "        self.features = nn.Sequential(\n",
+        "            nn.Conv2d(3, 64, 3, padding=1),\n",
+        "            nn.BatchNorm2d(64),\n",
+        "            nn.ReLU(inplace=True),\n",
+        "            nn.Conv2d(64, 64, 3, padding=1),\n",
+        "            nn.BatchNorm2d(64),\n",
+        "            nn.ReLU(inplace=True),\n",
+        "            nn.MaxPool2d(2),         # 16x16\n",
+        "            nn.Dropout(0.25),\n",
+        "\n",
+        "            nn.Conv2d(64, 128, 3, padding=1),\n",
+        "            nn.BatchNorm2d(128),\n",
+        "            nn.ReLU(inplace=True),\n",
+        "            nn.Conv2d(128, 128, 3, padding=1),\n",
+        "            nn.BatchNorm2d(128),\n",
+        "            nn.ReLU(inplace=True),\n",
+        "            nn.MaxPool2d(2),         # 8x8\n",
+        "            nn.Dropout(0.25),\n",
+        "        )\n",
+        "        self.classifier = nn.Sequential(\n",
+        "            nn.Flatten(),\n",
+        "            nn.Linear(128*8*8, 512),\n",
+        "            nn.ReLU(inplace=True),\n",
+        "            nn.Dropout(0.5),\n",
+        "            nn.Linear(512, num_classes),\n",
+        "        )\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        x = self.features(x)\n",
+        "        x = self.classifier(x)\n",
+        "        return x\n",
+        "\n",
+        "model_b = ModelB().to(device)\n",
+        "sum(p.numel() for p in model_b.parameters())/1e6"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "c864885b",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "c864885b",
+        "outputId": "2de6348a-6e5d-45b2-fbe3-9b16a55fee0c"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch [1/25] — Model B\n",
+            "  batch  100 | loss 2.3041 | acc 22.00%\n",
+            "  batch  200 | loss 2.0422 | acc 27.07%\n",
+            "  batch  300 | loss 1.9179 | acc 30.49%\n",
+            "  >> val_loss=1.4611 | val_acc=46.74%\n",
+            "Epoch [2/25] — Model B\n",
+            "  batch  100 | loss 1.5627 | acc 41.42%\n",
+            "  batch  200 | loss 1.5185 | acc 43.39%\n",
+            "  batch  300 | loss 1.4956 | acc 44.42%\n",
+            "  >> val_loss=1.2068 | val_acc=55.91%\n",
+            "Epoch [3/25] — Model B\n",
+            "  batch  100 | loss 1.3728 | acc 49.70%\n",
+            "  batch  200 | loss 1.3556 | acc 50.57%\n",
+            "  batch  300 | loss 1.3421 | acc 50.89%\n",
+            "  >> val_loss=1.0092 | val_acc=63.63%\n",
+            "Epoch [4/25] — Model B\n",
+            "  batch  100 | loss 1.2450 | acc 55.69%\n",
+            "  batch  200 | loss 1.2424 | acc 55.50%\n",
+            "  batch  300 | loss 1.2321 | acc 55.73%\n",
+            "  >> val_loss=1.0295 | val_acc=62.87%\n",
+            "Epoch [5/25] — Model B\n",
+            "  batch  100 | loss 1.1750 | acc 57.95%\n",
+            "  batch  200 | loss 1.1537 | acc 58.55%\n",
+            "  batch  300 | loss 1.1454 | acc 59.04%\n",
+            "  >> val_loss=0.9158 | val_acc=66.96%\n",
+            "Epoch [6/25] — Model B\n",
+            "  batch  100 | loss 1.1005 | acc 60.72%\n",
+            "  batch  200 | loss 1.0885 | acc 61.15%\n",
+            "  batch  300 | loss 1.0842 | acc 61.40%\n",
+            "  >> val_loss=0.9249 | val_acc=67.41%\n",
+            "Epoch [7/25] — Model B\n",
+            "  batch  100 | loss 1.0498 | acc 62.23%\n",
+            "  batch  200 | loss 1.0485 | acc 62.52%\n",
+            "  batch  300 | loss 1.0400 | acc 62.95%\n",
+            "  >> val_loss=0.7712 | val_acc=72.44%\n",
+            "Epoch [8/25] — Model B\n",
+            "  batch  100 | loss 1.0095 | acc 64.56%\n",
+            "  batch  200 | loss 1.0081 | acc 64.46%\n",
+            "  batch  300 | loss 1.0099 | acc 64.43%\n",
+            "  >> val_loss=0.8014 | val_acc=70.53%\n",
+            "Epoch [9/25] — Model B\n",
+            "  batch  100 | loss 0.9748 | acc 66.02%\n",
+            "  batch  200 | loss 0.9703 | acc 65.77%\n",
+            "  batch  300 | loss 0.9678 | acc 65.86%\n",
+            "  >> val_loss=0.7266 | val_acc=74.32%\n",
+            "Epoch [10/25] — Model B\n",
+            "  batch  100 | loss 0.9476 | acc 66.38%\n",
+            "  batch  200 | loss 0.9469 | acc 66.77%\n",
+            "  batch  300 | loss 0.9561 | acc 66.39%\n",
+            "  >> val_loss=0.6881 | val_acc=75.38%\n",
+            "Epoch [11/25] — Model B\n",
+            "  batch  100 | loss 0.9226 | acc 67.28%\n",
+            "  batch  200 | loss 0.9152 | acc 67.61%\n",
+            "  batch  300 | loss 0.9079 | acc 68.06%\n",
+            "  >> val_loss=0.6874 | val_acc=76.36%\n",
+            "Epoch [12/25] — Model B\n",
+            "  batch  100 | loss 0.8871 | acc 68.79%\n",
+            "  batch  200 | loss 0.8832 | acc 68.95%\n",
+            "  batch  300 | loss 0.8822 | acc 68.94%\n",
+            "  >> val_loss=0.7138 | val_acc=75.56%\n",
+            "Epoch [13/25] — Model B\n",
+            "  batch  100 | loss 0.8668 | acc 70.22%\n",
+            "  batch  200 | loss 0.8704 | acc 69.69%\n",
+            "  batch  300 | loss 0.8644 | acc 69.72%\n",
+            "  >> val_loss=0.6778 | val_acc=76.60%\n",
+            "Epoch [14/25] — Model B\n",
+            "  batch  100 | loss 0.8547 | acc 69.93%\n",
+            "  batch  200 | loss 0.8509 | acc 70.37%\n",
+            "  batch  300 | loss 0.8541 | acc 70.30%\n",
+            "  >> val_loss=0.6960 | val_acc=76.22%\n",
+            "Epoch [15/25] — Model B\n",
+            "  batch  100 | loss 0.8193 | acc 71.34%\n",
+            "  batch  200 | loss 0.8172 | acc 71.52%\n",
+            "  batch  300 | loss 0.8213 | acc 71.33%\n",
+            "  >> val_loss=0.6823 | val_acc=76.47%\n",
+            "Epoch [16/25] — Model B\n",
+            "  batch  100 | loss 0.8152 | acc 71.24%\n",
+            "  batch  200 | loss 0.8064 | acc 71.84%\n",
+            "  batch  300 | loss 0.8120 | acc 71.49%\n",
+            "  >> val_loss=0.5984 | val_acc=79.03%\n",
+            "Epoch [17/25] — Model B\n",
+            "  batch  100 | loss 0.7871 | acc 72.94%\n",
+            "  batch  200 | loss 0.7860 | acc 72.73%\n",
+            "  batch  300 | loss 0.7874 | acc 72.78%\n",
+            "  >> val_loss=0.5818 | val_acc=79.67%\n",
+            "Epoch [18/25] — Model B\n",
+            "  batch  100 | loss 0.7570 | acc 73.70%\n",
+            "  batch  200 | loss 0.7642 | acc 73.52%\n",
+            "  batch  300 | loss 0.7647 | acc 73.51%\n",
+            "  >> val_loss=0.5829 | val_acc=80.03%\n",
+            "Epoch [19/25] — Model B\n",
+            "  batch  100 | loss 0.7580 | acc 73.93%\n",
+            "  batch  200 | loss 0.7529 | acc 74.15%\n",
+            "  batch  300 | loss 0.7500 | acc 74.39%\n",
+            "  >> val_loss=0.6073 | val_acc=79.92%\n",
+            "Epoch [20/25] — Model B\n",
+            "  batch  100 | loss 0.7138 | acc 75.43%\n",
+            "  batch  200 | loss 0.7275 | acc 74.96%\n",
+            "  batch  300 | loss 0.7319 | acc 74.78%\n",
+            "  >> val_loss=0.5629 | val_acc=81.04%\n",
+            "Epoch [21/25] — Model B\n",
+            "  batch  100 | loss 0.7272 | acc 75.27%\n",
+            "  batch  200 | loss 0.7187 | acc 75.50%\n",
+            "  batch  300 | loss 0.7173 | acc 75.51%\n",
+            "  >> val_loss=0.5410 | val_acc=81.69%\n",
+            "Epoch [22/25] — Model B\n",
+            "  batch  100 | loss 0.7032 | acc 76.09%\n",
+            "  batch  200 | loss 0.7040 | acc 76.06%\n",
+            "  batch  300 | loss 0.7081 | acc 75.88%\n",
+            "  >> val_loss=0.5806 | val_acc=81.22%\n",
+            "Epoch [23/25] — Model B\n",
+            "  batch  100 | loss 0.6901 | acc 76.09%\n",
+            "  batch  200 | loss 0.6939 | acc 76.33%\n",
+            "  batch  300 | loss 0.6927 | acc 76.41%\n",
+            "  >> val_loss=0.5662 | val_acc=81.89%\n",
+            "Epoch [24/25] — Model B\n",
+            "  batch  100 | loss 0.6639 | acc 77.48%\n",
+            "  batch  200 | loss 0.6663 | acc 77.18%\n",
+            "  batch  300 | loss 0.6643 | acc 77.33%\n",
+            "  >> val_loss=0.5871 | val_acc=80.41%\n",
+            "Epoch [25/25] — Model B\n",
+            "  batch  100 | loss 0.6572 | acc 77.48%\n",
+            "  batch  200 | loss 0.6575 | acc 77.41%\n",
+            "  batch  300 | loss 0.6593 | acc 77.50%\n",
+            "  >> val_loss=0.5349 | val_acc=81.93%\n",
+            "Model B best val_acc: 81.93\n"
+          ]
+        }
+      ],
+      "source": [
+        "optimizer_b = optim.AdamW(model_b.parameters(), lr=CFG[\"lr\"], weight_decay=CFG[\"weight_decay\"])\n",
+        "\n",
+        "history_b = defaultdict(list)\n",
+        "epochs = CFG[\"epochs_B\"]\n",
+        "for epoch in range(1, epochs+1):\n",
+        "    print(f\"Epoch [{epoch}/{epochs}] — Model B\")\n",
+        "    train_loss, train_acc = train_one_epoch(model_b, train_loader, criterion, optimizer_b,\n",
+        "                                            epoch, max_batches=10 if FAST_DEBUG else None)\n",
+        "    val_loss, val_acc = evaluate(model_b, test_loader, criterion,\n",
+        "                                 max_batches=10 if FAST_DEBUG else None)\n",
+        "    history_b[\"train_loss\"].append(train_loss)\n",
+        "    history_b[\"train_acc\"].append(train_acc)\n",
+        "    history_b[\"val_loss\"].append(val_loss)\n",
+        "    history_b[\"val_acc\"].append(val_acc)\n",
+        "    print(f\"  >> val_loss={val_loss:.4f} | val_acc={val_acc:.2f}%\")\n",
+        "\n",
+        "print(\"Model B best val_acc:\", max(history_b[\"val_acc\"]))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "428204dc",
+      "metadata": {
+        "id": "428204dc"
+      },
+      "source": [
+        "## 7. Fully Connected (No Convs) Baseline"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "040177ef",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "040177ef",
+        "outputId": "58be7187-e053-445b-f0f8-26a23344924d"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "3.676682"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 9
+        }
+      ],
+      "source": [
+        "class FCBaseline(nn.Module):\n",
+        "    def __init__(self, num_classes=10):\n",
+        "        super().__init__()\n",
+        "        self.net = nn.Sequential(\n",
+        "            nn.Flatten(),\n",
+        "            nn.Linear(32*32*3, 1024),\n",
+        "            nn.ReLU(inplace=True),\n",
+        "            nn.Dropout(0.5),\n",
+        "            nn.Linear(1024, 512),\n",
+        "            nn.ReLU(inplace=True),\n",
+        "            nn.Dropout(0.5),\n",
+        "            nn.Linear(512, num_classes),\n",
+        "        )\n",
+        "    def forward(self, x):\n",
+        "        return self.net(x)\n",
+        "\n",
+        "fc_model = FCBaseline().to(device)\n",
+        "sum(p.numel() for p in fc_model.parameters())/1e6"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "80d3b4fc",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "80d3b4fc",
+        "outputId": "195e3156-2400-4b1a-aced-d55c5acb1d4b"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch [1/10] — FC Baseline\n",
+            "  batch  100 | loss 2.1098 | acc 23.79%\n",
+            "  batch  200 | loss 2.0444 | acc 25.73%\n",
+            "  batch  300 | loss 2.0086 | acc 26.96%\n",
+            "  >> val_loss=1.8049 | val_acc=33.72%\n",
+            "Epoch [2/10] — FC Baseline\n",
+            "  batch  100 | loss 1.8963 | acc 31.52%\n",
+            "  batch  200 | loss 1.8989 | acc 31.39%\n",
+            "  batch  300 | loss 1.8918 | acc 31.65%\n",
+            "  >> val_loss=1.8408 | val_acc=33.38%\n",
+            "Epoch [3/10] — FC Baseline\n",
+            "  batch  100 | loss 1.8566 | acc 33.38%\n",
+            "  batch  200 | loss 1.8661 | acc 32.67%\n",
+            "  batch  300 | loss 1.8614 | acc 32.71%\n",
+            "  >> val_loss=1.7887 | val_acc=34.52%\n",
+            "Epoch [4/10] — FC Baseline\n",
+            "  batch  100 | loss 1.8461 | acc 33.55%\n",
+            "  batch  200 | loss 1.8489 | acc 33.23%\n",
+            "  batch  300 | loss 1.8486 | acc 33.23%\n",
+            "  >> val_loss=1.8105 | val_acc=33.39%\n",
+            "Epoch [5/10] — FC Baseline\n",
+            "  batch  100 | loss 1.8330 | acc 33.74%\n",
+            "  batch  200 | loss 1.8366 | acc 33.61%\n",
+            "  batch  300 | loss 1.8399 | acc 33.47%\n",
+            "  >> val_loss=1.8409 | val_acc=33.68%\n",
+            "Epoch [6/10] — FC Baseline\n",
+            "  batch  100 | loss 1.8401 | acc 33.67%\n",
+            "  batch  200 | loss 1.8366 | acc 33.70%\n",
+            "  batch  300 | loss 1.8373 | acc 33.82%\n",
+            "  >> val_loss=1.8161 | val_acc=34.58%\n",
+            "Epoch [7/10] — FC Baseline\n",
+            "  batch  100 | loss 1.8142 | acc 34.52%\n",
+            "  batch  200 | loss 1.8163 | acc 34.23%\n",
+            "  batch  300 | loss 1.8178 | acc 34.26%\n",
+            "  >> val_loss=1.7960 | val_acc=35.01%\n",
+            "Epoch [8/10] — FC Baseline\n",
+            "  batch  100 | loss 1.8183 | acc 34.44%\n",
+            "  batch  200 | loss 1.8135 | acc 34.31%\n",
+            "  batch  300 | loss 1.8114 | acc 34.28%\n",
+            "  >> val_loss=1.7832 | val_acc=35.77%\n",
+            "Epoch [9/10] — FC Baseline\n",
+            "  batch  100 | loss 1.7961 | acc 34.86%\n",
+            "  batch  200 | loss 1.8051 | acc 35.00%\n",
+            "  batch  300 | loss 1.8049 | acc 34.97%\n",
+            "  >> val_loss=1.8369 | val_acc=33.73%\n",
+            "Epoch [10/10] — FC Baseline\n",
+            "  batch  100 | loss 1.7900 | acc 35.39%\n",
+            "  batch  200 | loss 1.8035 | acc 34.96%\n",
+            "  batch  300 | loss 1.8034 | acc 35.08%\n",
+            "  >> val_loss=1.8056 | val_acc=32.81%\n",
+            "FC best val_acc: 35.77\n"
+          ]
+        }
+      ],
+      "source": [
+        "optimizer_fc = optim.AdamW(fc_model.parameters(), lr=CFG[\"lr\"], weight_decay=CFG[\"weight_decay\"])\n",
+        "\n",
+        "history_fc = defaultdict(list)\n",
+        "epochs = CFG[\"epochs_FC\"]\n",
+        "for epoch in range(1, epochs+1):\n",
+        "    print(f\"Epoch [{epoch}/{epochs}] — FC Baseline\")\n",
+        "    train_loss, train_acc = train_one_epoch(fc_model, train_loader, criterion, optimizer_fc,\n",
+        "                                            epoch, max_batches=10 if FAST_DEBUG else None)\n",
+        "    val_loss, val_acc = evaluate(fc_model, test_loader, criterion,\n",
+        "                                 max_batches=10 if FAST_DEBUG else None)\n",
+        "    history_fc[\"train_loss\"].append(train_loss)\n",
+        "    history_fc[\"train_acc\"].append(train_acc)\n",
+        "    history_fc[\"val_loss\"].append(val_loss)\n",
+        "    history_fc[\"val_acc\"].append(val_acc)\n",
+        "    print(f\"  >> val_loss={val_loss:.4f} | val_acc={val_acc:.2f}%\")\n",
+        "\n",
+        "print(\"FC best val_acc:\", max(history_fc[\"val_acc\"]))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "14ad1c02",
+      "metadata": {
+        "id": "14ad1c02"
+      },
+      "source": [
+        "## 8. Results — Accuracy Comparison & Report"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "1de95c93",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "1de95c93",
+        "outputId": "6ea10104-c14b-4ca8-90ac-241ae5fae825"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "{'Model A (2-Conv)': 75.3,\n",
+              " 'Model B (Deep + BN + Dropout)': 81.93,\n",
+              " 'FC Baseline (No Conv)': 35.77}"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 11
+        }
+      ],
+      "source": [
+        "def best_acc(hist):\n",
+        "    return max(hist[\"val_acc\"]) if len(hist[\"val_acc\"]) else float('nan')\n",
+        "\n",
+        "summary = {\n",
+        "    \"Model A (2-Conv)\": best_acc(history_a),\n",
+        "    \"Model B (Deep + BN + Dropout)\": best_acc(history_b),\n",
+        "    \"FC Baseline (No Conv)\": best_acc(history_fc)\n",
+        "}\n",
+        "summary"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "2abdea68",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "2abdea68",
+        "outputId": "1ee12f7f-1cae-4a43-d8d0-b885e147c26e"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Best model: Model B (Deep + BN + Dropout)\n",
+            "Test Acc (Model B (Deep + BN + Dropout)): 81.93%\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "    airplane      0.819     0.858     0.838      1000\n",
+            "  automobile      0.909     0.943     0.926      1000\n",
+            "        bird      0.790     0.703     0.744      1000\n",
+            "         cat      0.752     0.589     0.661      1000\n",
+            "        deer      0.851     0.748     0.796      1000\n",
+            "         dog      0.665     0.821     0.735      1000\n",
+            "        frog      0.726     0.950     0.823      1000\n",
+            "       horse      0.912     0.786     0.844      1000\n",
+            "        ship      0.921     0.898     0.909      1000\n",
+            "       truck      0.912     0.897     0.904      1000\n",
+            "\n",
+            "    accuracy                          0.819     10000\n",
+            "   macro avg      0.826     0.819     0.818     10000\n",
+            "weighted avg      0.826     0.819     0.818     10000\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Pick best model among A/B/FC by validation accuracy and print a classification report.\n",
+        "\n",
+        "best_name = max(summary, key=summary.get)\n",
+        "print(\"Best model:\", best_name)\n",
+        "\n",
+        "model_map = {\n",
+        "    \"Model A (2-Conv)\": model_a,\n",
+        "    \"Model B (Deep + BN + Dropout)\": model_b,\n",
+        "    \"FC Baseline (No Conv)\": fc_model\n",
+        "}\n",
+        "best_model = model_map[best_name]\n",
+        "\n",
+        "test_loss, test_acc, ypred, ytrue = evaluate(best_model, test_loader, criterion,\n",
+        "                                             max_batches=10 if FAST_DEBUG else None,\n",
+        "                                             return_preds=True)\n",
+        "print(f\"Test Acc ({best_name}): {test_acc:.2f}%\")\n",
+        "print(classification_report(ytrue, ypred, target_names=classes, digits=3))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "93b68c2f",
+      "metadata": {
+        "id": "93b68c2f"
+      },
+      "source": [
+        "## 9. Filter Visualization — First Conv Layer"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "026351bf",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 934
+        },
+        "id": "026351bf",
+        "outputId": "7b53d4e0-0373-4714-efb7-ea6b3ab733f3"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Visualizing Model A first-layer filters:\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x1000 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Visualizing Model B first-layer filters:\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x1000 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "def visualize_first_layer_kernels(model, title=\"First Conv Filters\", max_k=32):\n",
+        "    # try to find first conv by walking modules in order\n",
+        "    first_conv = None\n",
+        "    for m in model.modules():\n",
+        "        if isinstance(m, nn.Conv2d):\n",
+        "            first_conv = m\n",
+        "            break\n",
+        "    if first_conv is None:\n",
+        "        print(\"No Conv2d found in model.\")\n",
+        "        return\n",
+        "\n",
+        "    kernels = first_conv.weight.data.clone().cpu()  # [out_c, in_c, k, k]\n",
+        "    # normalize each kernel to 0-1 for visualization\n",
+        "    k = kernels.clone()\n",
+        "    k = (k - k.min(dim=2, keepdim=True)[0].min(dim=3, keepdim=True)[0])\n",
+        "    k = k / (k.max(dim=2, keepdim=True)[0].max(dim=3, keepdim=True)[0] + 1e-8)\n",
+        "\n",
+        "    # Clamp number of filters to display\n",
+        "    k = k[:max_k]\n",
+        "\n",
+        "    grid = vutils.make_grid(k, nrow=8, normalize=False, padding=1)\n",
+        "    plt.figure(figsize=(10, 10))\n",
+        "    plt.title(title)\n",
+        "    plt.imshow(np.transpose(grid.numpy(), (1, 2, 0)))\n",
+        "    plt.axis('off')\n",
+        "    plt.show()\n",
+        "\n",
+        "print(\"Visualizing Model A first-layer filters:\")\n",
+        "visualize_first_layer_kernels(model_a, \"Model A — First Conv Filters\")\n",
+        "print(\"Visualizing Model B first-layer filters:\")\n",
+        "visualize_first_layer_kernels(model_b, \"Model B — First Conv Filters\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "65fc2e99",
+      "metadata": {
+        "id": "65fc2e99"
+      },
+      "source": [
+        "## 10. Adversarial Check — Tiny Random Noise"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "4efdda4f",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 413
+        },
+        "id": "4efdda4f",
+        "outputId": "2696319c-493a-4e95-b6df-1c0872ec01eb"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.04581067..1.0103905].\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 800x400 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "True label: cat\n",
+            "✔️ Prediction unchanged for this sample with tiny noise (try different eps or samples).\n"
+          ]
+        }
+      ],
+      "source": [
+        "@torch.no_grad()\n",
+        "def predict_top1(model, x_single):\n",
+        "    model.eval()\n",
+        "    logits = model(x_single.to(device))\n",
+        "    pred = logits.argmax(1).item()\n",
+        "    return pred, F.softmax(logits, dim=1).max().item()\n",
+        "\n",
+        "# Fetch one clean test image, predict, then add noise\n",
+        "epsilon = 0.05  # small noise scale (on normalized scale)\n",
+        "x0, y0 = next(iter(test_loader))\n",
+        "x0, y0 = x0[:1], y0[:1]  # take one image\n",
+        "\n",
+        "p_clean, conf_clean = predict_top1(best_model, x0)\n",
+        "x_noisy = torch.clamp(x0 + epsilon*torch.randn_like(x0), -3, 3)  # clamp wide range due to normalization\n",
+        "p_noisy, conf_noisy = predict_top1(best_model, x_noisy)\n",
+        "\n",
+        "fig, axs = plt.subplots(1, 2, figsize=(8,4))\n",
+        "axs[0].imshow(np.transpose((x0[0].cpu()*torch.tensor(CIFAR10_STD).view(3,1,1) + torch.tensor(CIFAR10_MEAN).view(3,1,1)).numpy(), (1,2,0)))\n",
+        "axs[0].set_title(f\"Clean: pred={classes[p_clean]} (conf={conf_clean:.2f})\")\n",
+        "axs[0].axis('off')\n",
+        "\n",
+        "axs[1].imshow(np.transpose((x_noisy[0].cpu()*torch.tensor(CIFAR10_STD).view(3,1,1) + torch.tensor(CIFAR10_MEAN).view(3,1,1)).numpy(), (1,2,0)))\n",
+        "axs[1].set_title(f\"Noisy: pred={classes[p_noisy]} (conf={conf_noisy:.2f})\")\n",
+        "axs[1].axis('off')\n",
+        "\n",
+        "plt.show()\n",
+        "\n",
+        "print(f\"True label: {classes[y0.item()]}\")\n",
+        "if p_clean != p_noisy:\n",
+        "    print(\"❗ Prediction changed under tiny random noise — model can be fooled.\")\n",
+        "else:\n",
+        "    print(\"✔️ Prediction unchanged for this sample with tiny noise (try different eps or samples).\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "6f20955d",
+      "metadata": {
+        "id": "6f20955d"
+      },
+      "source": [
+        "## 11. Why are CNNs better than FC here? — Parameter Math & Inductive Bias"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "5b23fc1f",
+      "metadata": {
+        "id": "5b23fc1f"
+      },
+      "source": [
+        "**Key idea:** CNNs **share weights spatially** (convolutions) and enforce **local connectivity**.  \n",
+        "A fully-connected (FC) layer from a 32×32×3 input to a modest 1024 hidden units has:\n",
+        "\n",
+        "\\[ \\text{params} = (32\\cdot 32\\cdot 3)\\times 1024 + 1024 \\approx 3{,}147{,}776 + 1{,}024 \\approx 3.15\\,\\text{M} \\]\n",
+        "\n",
+        "In contrast, a first conv layer with 64 filters of size 3×3 (on 3 input channels) has:\n",
+        "\n",
+        "\\[ \\text{params} = (3\\times 3\\times 3)\\times 64 + 64 = 1{,}792 \\]\n",
+        "\n",
+        "That’s **~1759× fewer** parameters at the first stage alone.  \n",
+        "This dramatic reduction reduces overfitting and captures **translation-equivariant** features such as edges and textures, which are suited to natural images.  \n",
+        "Deeper conv stacks build hierarchical features (edges → motifs → object parts → objects), which FC layers struggle to learn efficiently from small images."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "e20aeca2",
+      "metadata": {
+        "id": "e20aeca2"
+      },
+      "source": [
+        "## 12. Learnings — Bullet Points"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "9b324ad1",
+      "metadata": {
+        "id": "9b324ad1"
+      },
+      "source": [
+        "- **Parameter efficiency:** Convs use far fewer parameters than FC layers for image data, reducing overfitting.\n",
+        "- **Normalization + deeper stacks** (BatchNorm) stabilized training and yielded higher accuracy than shallow nets.\n",
+        "- **Regularization matters:** Dropout and data augmentation (crops/flips) improved generalization measurably.\n",
+        "- **Filter interpretability:** First-layer filters resembled color-edge detectors; deeper layers compose higher-level motifs.\n",
+        "- **Robustness caveat:** Even tiny random noise can sometimes flip predictions, illustrating adversarial sensitivity."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "e2373093",
+      "metadata": {
+        "id": "e2373093"
+      },
+      "source": [
+        "---"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "accelerator": "GPU"
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}