diff --git "a/res.ipynb" "b/res.ipynb"
deleted file mode 100644--- "a/res.ipynb"
+++ /dev/null
@@ -1,1179 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "48cc854c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import torch as t\n",
-    "from datasets import load_dataset\n",
-    "import os\n",
-    "from torchvision import transforms, datasets"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "c65dc116",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Using device: mps\n"
-     ]
-    }
-   ],
-   "source": [
-    "device = t.device(\"cuda\" if t.cuda.is_available() else\n",
-    "                      \"mps\" if t.backends.mps.is_available() else\n",
-    "                      \"cpu\")\n",
-    "\n",
-    "print(f\"Using device: {device}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "c4f23bb8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch.nn as nn\n",
-    "\n",
-    "class BottleneckBlock(nn.Module):\n",
-    "    expansion = 4\n",
-    "\n",
-    "    def __init__(self, in_channels, mid_channels, stride=1):\n",
-    "        super(BottleneckBlock, self).__init__()\n",
-    "        \n",
-    "        out_channels = mid_channels * self.expansion\n",
-    "\n",
-    "        \n",
-    "        self.conv1 = nn.Conv2d(in_channels, mid_channels, kernel_size=1, bias=False)\n",
-    "        self.bn1 = nn.BatchNorm2d(mid_channels)\n",
-    "        \n",
-    "        self.conv2 = nn.Conv2d(mid_channels, mid_channels, kernel_size=3, stride=stride, padding=1, bias=False)\n",
-    "        self.bn2 = nn.BatchNorm2d(mid_channels)\n",
-    "        \n",
-    "        self.conv3 = nn.Conv2d(mid_channels, out_channels, kernel_size=1, bias=False)\n",
-    "        self.bn3 = nn.BatchNorm2d(out_channels)\n",
-    "        \n",
-    "        self.relu = nn.ReLU(inplace=True)\n",
-    "\n",
-    "        self.shortcut = nn.Sequential()\n",
-    "\n",
-    "        if stride != 1 or in_channels != out_channels:\n",
-    "            self.shortcut = nn.Sequential(\n",
-    "                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),\n",
-    "                nn.BatchNorm2d(out_channels)\n",
-    "            )\n",
-    "\n",
-    "    def forward(self, x):\n",
-    "        identity = x\n",
-    "\n",
-    "        out = self.conv1(x)\n",
-    "        out = self.bn1(out)\n",
-    "        out = self.relu(out)\n",
-    "\n",
-    "        out = self.conv2(out)\n",
-    "        out = self.bn2(out)\n",
-    "        out = self.relu(out)\n",
-    "\n",
-    "        out = self.conv3(out)\n",
-    "        out = self.bn3(out)\n",
-    "        \n",
-    "        identity = self.shortcut(identity)\n",
-    "\n",
-    "        out += identity\n",
-    "        out = self.relu(out)\n",
-    "\n",
-    "        return out        \n",
-    "        \n",
-    "\n",
-    "class ResNet50(nn.Module):\n",
-    "    def __init__(self, num_classes=16, channels_img=3):\n",
-    "        super(ResNet50, self).__init__()\n",
-    "        \n",
-    "        self.in_channels = 64\n",
-    "\n",
-    "        self.conv1 = nn.Conv2d(channels_img, 64, kernel_size=7, stride=2, padding=3, bias=False)\n",
-    "        self.bn1 = nn.BatchNorm2d(64)\n",
-    "        self.relu = nn.ReLU(inplace=True)\n",
-    "        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
-    "\n",
-    "        self.stage1 = self._make_layer(mid_channels=64, num_blocks=3, stride=1)\n",
-    "        \n",
-    "        self.stage2 = self._make_layer(mid_channels=128, num_blocks=4, stride=2)\n",
-    "        \n",
-    "        self.stage3 = self._make_layer(mid_channels=256, num_blocks=6, stride=2)\n",
-    "        \n",
-    "        self.stage4 = self._make_layer(mid_channels=512, num_blocks=3, stride=2)\n",
-    "\n",
-    "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
-    "\n",
-    "        self.fc = nn.Linear(512 * 4, num_classes) # 512*4 = 2048\n",
-    "\n",
-    "    def _make_layer(self, mid_channels, num_blocks, stride):\n",
-    "        layers = []\n",
-    "        \n",
-    "        layers.append(BottleneckBlock(self.in_channels, mid_channels, stride))\n",
-    "        \n",
-    "        self.in_channels = mid_channels * 4\n",
-    "\n",
-    "        for _ in range(num_blocks - 1):\n",
-    "            layers.append(BottleneckBlock(self.in_channels, mid_channels, stride=1))\n",
-    "\n",
-    "        return nn.Sequential(*layers)\n",
-    "\n",
-    "    def forward(self, x):\n",
-    "        # Stem\n",
-    "        x = self.conv1(x)\n",
-    "        x = self.bn1(x)\n",
-    "        x = self.relu(x)\n",
-    "        x = self.maxpool(x)\n",
-    "\n",
-    "        # Stages\n",
-    "        x = self.stage1(x)\n",
-    "        x = self.stage2(x)\n",
-    "        x = self.stage3(x)\n",
-    "        x = self.stage4(x)\n",
-    "\n",
-    "        # Head\n",
-    "        x = self.avgpool(x)\n",
-    "        x = t.flatten(x, 1) # Flatten from (N, 2048, 1, 1) to (N, 2048)\n",
-    "        x = self.fc(x)\n",
-    "\n",
-    "        return x        \n",
-    "\n",
-    "        "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "7b8d02be",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "ResNet50(\n",
-      "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
-      "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "  (relu): ReLU(inplace=True)\n",
-      "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
-      "  (stage1): Sequential(\n",
-      "    (0): BottleneckBlock(\n",
-      "      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential(\n",
-      "        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      )\n",
-      "    )\n",
-      "    (1): BottleneckBlock(\n",
-      "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential()\n",
-      "    )\n",
-      "    (2): BottleneckBlock(\n",
-      "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential()\n",
-      "    )\n",
-      "  )\n",
-      "  (stage2): Sequential(\n",
-      "    (0): BottleneckBlock(\n",
-      "      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential(\n",
-      "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
-      "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      )\n",
-      "    )\n",
-      "    (1): BottleneckBlock(\n",
-      "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential()\n",
-      "    )\n",
-      "    (2): BottleneckBlock(\n",
-      "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential()\n",
-      "    )\n",
-      "    (3): BottleneckBlock(\n",
-      "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential()\n",
-      "    )\n",
-      "  )\n",
-      "  (stage3): Sequential(\n",
-      "    (0): BottleneckBlock(\n",
-      "      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential(\n",
-      "        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
-      "        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      )\n",
-      "    )\n",
-      "    (1): BottleneckBlock(\n",
-      "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential()\n",
-      "    )\n",
-      "    (2): BottleneckBlock(\n",
-      "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential()\n",
-      "    )\n",
-      "    (3): BottleneckBlock(\n",
-      "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential()\n",
-      "    )\n",
-      "    (4): BottleneckBlock(\n",
-      "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential()\n",
-      "    )\n",
-      "    (5): BottleneckBlock(\n",
-      "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential()\n",
-      "    )\n",
-      "  )\n",
-      "  (stage4): Sequential(\n",
-      "    (0): BottleneckBlock(\n",
-      "      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential(\n",
-      "        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
-      "        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      )\n",
-      "    )\n",
-      "    (1): BottleneckBlock(\n",
-      "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential()\n",
-      "    )\n",
-      "    (2): BottleneckBlock(\n",
-      "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-      "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
-      "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-      "      (relu): ReLU(inplace=True)\n",
-      "      (shortcut): Sequential()\n",
-      "    )\n",
-      "  )\n",
-      "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
-      "  (fc): Linear(in_features=2048, out_features=16, bias=True)\n",
-      ")\n"
-     ]
-    }
-   ],
-   "source": [
-    "resnet50 = ResNet50().to(device)\n",
-    "print(resnet50)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cc70660c",
-   "metadata": {},
-   "source": [
-    "## model loading"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "fda1cd94",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Success! Keys remapped and model loaded.\n"
-     ]
-    }
-   ],
-   "source": [
-    "import torch\n",
-    "\n",
-    "# Load the state_dict\n",
-    "checkpoint_path = \"/Users/arpit-zstch1557/.cache/huggingface/hub/models--arpit-gour02--document-classification/snapshots/513288d93433d338d3df97b3c62b1b0375dd0d6c/resnet50_epoch_5.pth\"\n",
-    "state_dict = torch.load(checkpoint_path, map_location=device, weights_only=False)\n",
-    "\n",
-    "new_state_dict = {}\n",
-    "for key, value in state_dict.items():\n",
-    "    new_key = key.replace(\"layer\", \"stage\")\n",
-    "    new_state_dict[new_key] = value\n",
-    "\n",
-    "try:\n",
-    "    resnet50.load_state_dict(new_state_dict)\n",
-    "    resnet50.eval()\n",
-    "    print(\"Success! Keys remapped and model loaded.\")\n",
-    "except Exception as e:\n",
-    "    print(f\"Structural mismatch still exists: {e}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "56438cc9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def force_3_channels(tensor):\n",
-    "    if tensor.shape[0] == 1:\n",
-    "        return tensor.repeat(3, 1, 1)\n",
-    "    return tensor\n",
-    "\n",
-    "\n",
-    "data_transforms = {\n",
-    "    'train': transforms.Compose([\n",
-    "        transforms.Resize((224, 224)),\n",
-    "        transforms.ColorJitter(brightness=0.2, contrast=0.2),\n",
-    "        transforms.RandomRotation(degrees=2),\n",
-    "        transforms.ToTensor(),\n",
-    "        transforms.Lambda(force_3_channels),\n",
-    "        transforms.Normalize(mean=[0.485, 0.456, 0.406], \n",
-    "                             std=[0.229, 0.224, 0.225])\n",
-    "    ]),\n",
-    "    \n",
-    "    'val': transforms.Compose([\n",
-    "        transforms.Resize((224, 224)),\n",
-    "        transforms.ToTensor(),\n",
-    "        transforms.Lambda(force_3_channels),\n",
-    "        transforms.Normalize(mean=[0.485, 0.456, 0.406], \n",
-    "                             std=[0.229, 0.224, 0.225])\n",
-    "    ]),\n",
-    "\n",
-    "    'test': transforms.Compose([\n",
-    "        transforms.Resize((224, 224)),\n",
-    "        transforms.ToTensor(),\n",
-    "        transforms.Lambda(force_3_channels),\n",
-    "        transforms.Normalize(mean=[0.485, 0.456, 0.406], \n",
-    "                            std=[0.229, 0.224, 0.225])\n",
-    "    ])\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "e8f19c6d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from torch.utils.data import DataLoader\n",
-    "\n",
-    "test  = datasets.ImageFolder(\"./rvl_cdip_data/test\", transform=data_transforms[\"test\"])\n",
-    "test_dataloader = DataLoader(test, batch_size=64, num_workers=0)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "c26c6a6d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "39999"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "len(test)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "fc87a69f",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0, torch.Size([64, 3, 224, 224]), torch.Size([64])\n",
-      "1, torch.Size([64, 3, 224, 224]), torch.Size([64])\n"
-     ]
-    }
-   ],
-   "source": [
-    "for idx, (images, labels) in enumerate(test_dataloader):\n",
-    "    print(f\"{idx}, {images.size()}, {labels.size()}\")\n",
-    "    if idx == 1:\n",
-    "        break"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "1c553fd3",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Input shape: torch.Size([64, 3, 224, 224])\n",
-      "Output shape: torch.Size([64, 16])\n"
-     ]
-    }
-   ],
-   "source": [
-    "dummy_input = torch.randn(64, 3, 224, 224).to(device)\n",
-    "\n",
-    "#Forward pass\n",
-    "output = resnet50(dummy_input)\n",
-    "\n",
-    "print(\"Input shape:\", dummy_input.shape)\n",
-    "print(\"Output shape:\", output.shape)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "a56bfe1a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "loss_fn = nn.CrossEntropyLoss()\n",
-    "optimizer = torch.optim.SGD(resnet50.parameters(), lr=0.01, momentum=0.9)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5e7a8a67",
-   "metadata": {},
-   "source": [
-    "## testing"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "b7edfe3d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def test_loop(dataloader, model, loss_fn, device):\n",
-    "    resnet50.eval()\n",
-    "    correct = 0\n",
-    "    total = 0\n",
-    "    \n",
-    "    with torch.no_grad():\n",
-    "        for idx, (images, labels) in enumerate(test_dataloader):\n",
-    "            # print(idx)\n",
-    "            images, labels = images.to(device), labels.to(device)\n",
-    "            logits = model(images)\n",
-    "\n",
-    "            _, pred_indices = torch.max(logits, 1)\n",
-    "\n",
-    "            total += images.size(0)\n",
-    "            correct += (pred_indices == labels).sum().item()\n",
-    "            # print(correct)\n",
-    "\n",
-    "    acc = (correct/total)*100\n",
-    "    print(f\"Test Accuracy: {acc:.2f}%\")\n",
-    "    return acc\n",
-    "\n",
-    "\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "cfaf14e7",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Test Accuracy: 85.68%\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "85.68214205355133"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "test_loop(test_dataloader, resnet50, loss_fn, device)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a0a54cb8",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "2e8c9010",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Generating Confusion Matrix... (This takes a minute)\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "b71bb882434e4c1798ee59bef038a306",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "  0%|          | 0/625 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1400x1000 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "from sklearn.metrics import confusion_matrix\n",
-    "import seaborn as sns\n",
-    "import numpy as np\n",
-    "from tqdm.auto import tqdm\n",
-    "\n",
-    "def plot_confusion_matrix(model, loader, device, classes):\n",
-    "    y_true = []\n",
-    "    y_pred = []\n",
-    "    \n",
-    "    print(\"Generating Confusion Matrix... (This takes a minute)\")\n",
-    "    model.eval()\n",
-    "    with torch.no_grad():\n",
-    "        for inputs, labels in tqdm(loader, leave=False):\n",
-    "            inputs = inputs.to(device)\n",
-    "            outputs = model(inputs)\n",
-    "            _, preds = torch.max(outputs, 1)\n",
-    "            \n",
-    "            y_true.extend(labels.cpu().numpy())\n",
-    "            y_pred.extend(preds.cpu().numpy())\n",
-    "            \n",
-    "    # Compute Matrix\n",
-    "    cm = confusion_matrix(y_true, y_pred)\n",
-    "    \n",
-    "    plt.figure(figsize=(14, 10))\n",
-    "    \n",
-    "    sns.heatmap(\n",
-    "        cm, \n",
-    "        annot=True,      \n",
-    "        fmt='d',         \n",
-    "        cmap='Blues', \n",
-    "        xticklabels=classes, \n",
-    "        yticklabels=classes,\n",
-    "        annot_kws={\"size\": 8} \n",
-    "    )\n",
-    "    \n",
-    "    plt.xlabel('Predicted')\n",
-    "    plt.ylabel('True')\n",
-    "    plt.title('Confusion Matrix: ResNet-50 on RVL-CDIP')\n",
-    "    plt.xticks(rotation=45, ha='right') \n",
-    "    plt.show()\n",
-    "    \n",
-    "# Run it\n",
-    "plot_confusion_matrix(resnet50, test_dataloader, device, test.classes)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ae49f07b",
-   "metadata": {},
-   "source": [
-    "## Class-wise Accuracy"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "452cedaa",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from collections import Counter\n",
-    "\n",
-    "total_per_class = Counter(test.targets)\n",
-    "\n",
-    "correct_per_class = {}\n",
-    "for idx, (images, labels) in enumerate(test_dataloader):\n",
-    "    images, labels = images.to(device), labels.to(device)\n",
-    "    logits = resnet50(images)\n",
-    "    _, pred_indices = torch.max(logits, 1)\n",
-    "    \n",
-    "    for label, pred in zip(labels, pred_indices):\n",
-    "        label_item = label.item()\n",
-    "        pred_item = pred.item()\n",
-    "        \n",
-    "        if label_item == pred_item:\n",
-    "            if label_item in correct_per_class:\n",
-    "                correct_per_class[label_item] += 1\n",
-    "            else:\n",
-    "                correct_per_class[label_item] = 1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "f4ef7597",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_items([(0, 2515), (1, 2505), (2, 2516), (3, 2527), (4, 2506), (5, 2532), (6, 2477), (7, 2464), (8, 2492), (9, 2463), (10, 2489), (11, 2435), (12, 2537), (13, 2571), (14, 2498), (15, 2472)])\n",
-      "dict_items([(0, 2118), (1, 2229), (2, 2467), (3, 2084), (4, 2032), (5, 2409), (6, 2184), (7, 1936), (8, 2248), (9, 2078), (10, 1906), (11, 1893), (12, 2379), (13, 2385), (14, 1704), (15, 2220)])\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(total_per_class.items())\n",
-    "print(correct_per_class.items())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "id": "e964c40a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Class: 0 , Accuracy: 84.21%\n",
-      "Class: 1 , Accuracy: 88.98%\n",
-      "Class: 2 , Accuracy: 98.05%\n",
-      "Class: 3 , Accuracy: 82.47%\n",
-      "Class: 4 , Accuracy: 81.09%\n",
-      "Class: 5 , Accuracy: 95.14%\n",
-      "Class: 6 , Accuracy: 88.17%\n",
-      "Class: 7 , Accuracy: 78.57%\n",
-      "Class: 8 , Accuracy: 90.21%\n",
-      "Class: 9 , Accuracy: 84.37%\n",
-      "Class: 10 , Accuracy: 76.58%\n",
-      "Class: 11 , Accuracy: 77.74%\n",
-      "Class: 12 , Accuracy: 93.77%\n",
-      "Class: 13 , Accuracy: 92.77%\n",
-      "Class: 14 , Accuracy: 68.21%\n",
-      "Class: 15 , Accuracy: 89.81%\n"
-     ]
-    }
-   ],
-   "source": [
-    "for (cls_idx, total), (cls_idx, correct)  in zip(total_per_class.items(), correct_per_class.items()):\n",
-    "    print(f\"Class: {cls_idx} , Accuracy: {(correct/total)*100:.2f}%\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "id": "1f57b36d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['advertisement',\n",
-       " 'budget',\n",
-       " 'email',\n",
-       " 'file folder',\n",
-       " 'form',\n",
-       " 'handwritten',\n",
-       " 'invoice',\n",
-       " 'letter',\n",
-       " 'memo',\n",
-       " 'news article',\n",
-       " 'presentation',\n",
-       " 'questionnaire',\n",
-       " 'resume',\n",
-       " 'scientific publication',\n",
-       " 'scientific report',\n",
-       " 'specification']"
-      ]
-     },
-     "execution_count": 44,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "test.classes"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "id": "0e93b237",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Evaluating...\n",
-      "\n",
-      "CLASS NAME                | TOTAL    | CORRECT  | ACCURACY  \n",
-      "-----------------------------------------------------------------\n",
-      "advertisement             | 2515     | 2118     | 84.21% ⚠️\n",
-      "budget                    | 2505     | 2229     | 88.98% ⚠️\n",
-      "email                     | 2516     | 2467     | 98.05% ✅\n",
-      "file folder               | 2527     | 2084     | 82.47% ⚠️\n",
-      "form                      | 2506     | 2032     | 81.09% ⚠️\n",
-      "handwritten               | 2532     | 2409     | 95.14% ✅\n",
-      "invoice                   | 2477     | 2184     | 88.17% ⚠️\n",
-      "letter                    | 2464     | 1936     | 78.57% ❌\n",
-      "memo                      | 2492     | 2248     | 90.21% ✅\n",
-      "news article              | 2463     | 2078     | 84.37% ⚠️\n",
-      "presentation              | 2489     | 1906     | 76.58% ❌\n",
-      "questionnaire             | 2435     | 1893     | 77.74% ❌\n",
-      "resume                    | 2537     | 2379     | 93.77% ✅\n",
-      "scientific publication    | 2571     | 2385     | 92.77% ✅\n",
-      "scientific report         | 2498     | 1704     | 68.21% ❌\n",
-      "specification             | 2472     | 2220     | 89.81% ⚠️\n"
-     ]
-    }
-   ],
-   "source": [
-    "from collections import Counter\n",
-    "import torch\n",
-    "\n",
-    "# 1. SETUP: Reverse the mapping to get Names from Numbers\n",
-    "# test.class_to_idx is {'email': 2, ...} -> we want {2: 'email', ...}\n",
-    "idx_to_class = {v: k for k, v in test.class_to_idx.items()}\n",
-    "\n",
-    "# 2. CALCULATE TOTALS\n",
-    "# (Assumes 'test' is an ImageFolder or similar dataset with .targets)\n",
-    "total_per_class = Counter(test.targets)\n",
-    "correct_per_class = {}\n",
-    "\n",
-    "resnet50.eval()\n",
-    "\n",
-    "# 3. EVALUATION LOOP\n",
-    "print(\"Evaluating...\")\n",
-    "with torch.no_grad():\n",
-    "    for images, labels in test_dataloader:\n",
-    "        images, labels = images.to(device), labels.to(device)\n",
-    "        \n",
-    "        logits = resnet50(images)\n",
-    "        _, preds = torch.max(logits, 1)\n",
-    "        \n",
-    "        # Vectorized check for correctness\n",
-    "        matches = (preds == labels)\n",
-    "        \n",
-    "        # Update correct counts\n",
-    "        for label, is_correct in zip(labels, matches):\n",
-    "            if is_correct:\n",
-    "                label_item = label.item()\n",
-    "                correct_per_class[label_item] = correct_per_class.get(label_item, 0) + 1\n",
-    "\n",
-    "# 4. FINAL REPORT (The Fixed Logic)\n",
-    "print(f\"\\n{'CLASS NAME':<25} | {'TOTAL':<8} | {'CORRECT':<8} | {'ACCURACY':<10}\")\n",
-    "print(\"-\" * 65)\n",
-    "\n",
-    "# Sort by index (0, 1, 2...) to keep it organized\n",
-    "for cls_idx in sorted(total_per_class.keys()):\n",
-    "    \n",
-    "    # Get Name\n",
-    "    class_name = idx_to_class[cls_idx]\n",
-    "    \n",
-    "    # Get Stats\n",
-    "    total = total_per_class[cls_idx]\n",
-    "    correct = correct_per_class.get(cls_idx, 0) # Safety: defaults to 0 if none correct\n",
-    "    \n",
-    "    # Calculate\n",
-    "    acc = (correct / total) * 100\n",
-    "    \n",
-    "    # Grade\n",
-    "    grade = \"✅\" if acc > 90 else \"⚠️\" if acc > 80 else \"❌\"\n",
-    "    \n",
-    "    print(f\"{class_name:<25} | {total:<8} | {correct:<8} | {acc:.2f}% {grade}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 49,
-   "id": "dfa49598",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "DETAILED CLASSIFICATION REPORT\n",
-      "------------------------------------------------------------\n",
-      "                        precision    recall  f1-score   support\n",
-      "\n",
-      "         advertisement      0.903     0.842     0.872      2515\n",
-      "                budget      0.782     0.890     0.832      2505\n",
-      "                 email      0.976     0.981     0.978      2516\n",
-      "           file folder      0.855     0.825     0.840      2527\n",
-      "                  form      0.725     0.811     0.766      2506\n",
-      "           handwritten      0.892     0.951     0.921      2532\n",
-      "               invoice      0.874     0.882     0.878      2477\n",
-      "                letter      0.939     0.786     0.856      2464\n",
-      "                  memo      0.955     0.902     0.928      2492\n",
-      "          news article      0.924     0.844     0.882      2463\n",
-      "          presentation      0.782     0.766     0.774      2489\n",
-      "         questionnaire      0.841     0.777     0.808      2435\n",
-      "                resume      0.927     0.938     0.932      2537\n",
-      "scientific publication      0.840     0.928     0.882      2571\n",
-      "     scientific report      0.631     0.682     0.656      2498\n",
-      "         specification      0.934     0.898     0.916      2472\n",
-      "\n",
-      "              accuracy                          0.857     39999\n",
-      "             macro avg      0.861     0.856     0.857     39999\n",
-      "          weighted avg      0.861     0.857     0.858     39999\n",
-      "\n",
-      "------------------------------------------------------------\n",
-      "Top-1 Accuracy: 85.68%\n",
-      "Top-3 Accuracy: 95.62% (How often the right answer is in the top 3)\n",
-      "------------------------------------------------------------\n"
-     ]
-    }
-   ],
-   "source": [
-    "from sklearn.metrics import classification_report, top_k_accuracy_score\n",
-    "import torch\n",
-    "\n",
-    "class_names = [\n",
-    "    'advertisement', \n",
-    "    'budget', \n",
-    "    'email', \n",
-    "    'file folder', \n",
-    "    'form', \n",
-    "    'handwritten', \n",
-    "    'invoice', \n",
-    "    'letter', \n",
-    "    'memo', \n",
-    "    'news article', \n",
-    "    'presentation', \n",
-    "    'questionnaire', \n",
-    "    'resume', \n",
-    "    'scientific publication', \n",
-    "    'scientific report', \n",
-    "    'specification'\n",
-    "]\n",
-    "# 1. GATHER PREDICTIONS\n",
-    "y_true = []\n",
-    "y_pred = []\n",
-    "y_score = [] # Needed for Top-3 accuracy (probabilities)\n",
-    "\n",
-    "resnet50.eval()\n",
-    "with torch.no_grad():\n",
-    "    for images, labels in test_dataloader:\n",
-    "        images = images.to(device)\n",
-    "        labels = labels.to(device)\n",
-    "        \n",
-    "        outputs = resnet50(images)\n",
-    "        probabilities = torch.nn.functional.softmax(outputs, dim=1)\n",
-    "        _, preds = torch.max(outputs, 1)\n",
-    "        \n",
-    "        y_true.extend(labels.cpu().numpy())\n",
-    "        y_pred.extend(preds.cpu().numpy())\n",
-    "        y_score.extend(probabilities.cpu().numpy())\n",
-    "\n",
-    "# 2. PRINT THE REPORT (Precision, Recall, F1)\n",
-    "print(\"\\nDETAILED CLASSIFICATION REPORT\")\n",
-    "print(\"-\" * 60)\n",
-    "# target_names=class_names maps numbers back to 'Email', 'Resume' etc.\n",
-    "print(classification_report(y_true, y_pred, target_names=class_names, digits=3))\n",
-    "\n",
-    "# 3. CALCULATE TOP-3 ACCURACY\n",
-    "top1 = top_k_accuracy_score(y_true, y_score, k=1)\n",
-    "top3 = top_k_accuracy_score(y_true, y_score, k=3)\n",
-    "\n",
-    "print(\"-\" * 60)\n",
-    "print(f\"Top-1 Accuracy: {top1*100:.2f}%\")\n",
-    "print(f\"Top-3 Accuracy: {top3*100:.2f}% (How often the right answer is in the top 3)\")\n",
-    "print(\"-\" * 60)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "aa700138",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "✅ File Loaded Successfully!\n",
-      "Data Keys Found: ['train_loss', 'train_acc', 'val_loss', 'val_acc']\n",
-      "✅ Graph saved to: results/loss_and_acc_curve.png\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1400x600 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import torch\n",
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "\n",
-    "# --- 1. Load the History File ---\n",
-    "file_path = '/Users/arpit-zstch1557/Projects/document-classification/training_history.pth'\n",
-    "\n",
-    "try:\n",
-    "    # Load data (map_location='cpu' ensures it works even without GPU)\n",
-    "    history = torch.load(file_path, map_location='cpu')\n",
-    "    print(\"✅ File Loaded Successfully!\")\n",
-    "    print(f\"Data Keys Found: {list(history.keys())}\")\n",
-    "    \n",
-    "    # Handle cases where history might be nested under a 'history' key\n",
-    "    if 'history' in history:\n",
-    "        history = history['history']\n",
-    "        \n",
-    "except Exception as e:\n",
-    "    print(f\"❌ Error loading file: {e}\")\n",
-    "    exit()\n",
-    "\n",
-    "# --- 2. Setup Plot Style ---\n",
-    "sns.set_style(\"whitegrid\") # Makes it look academic/professional\n",
-    "plt.figure(figsize=(14, 6)) # Wide layout for side-by-side plots\n",
-    "\n",
-    "# --- 3. Plot Loss Curves (Left Side) ---\n",
-    "plt.subplot(1, 2, 1)\n",
-    "# Try to find standard keys (adapt if your keys are named differently)\n",
-    "t_loss = history.get('train_loss') or history.get('loss')\n",
-    "v_loss = history.get('val_loss') or history.get('validation_loss')\n",
-    "\n",
-    "if t_loss: plt.plot(t_loss, label='Training Loss', color='blue', linewidth=2, marker='o', markersize=4)\n",
-    "if v_loss: plt.plot(v_loss, label='Validation Loss', color='red', linewidth=2, linestyle='--', marker='s', markersize=4)\n",
-    "\n",
-    "plt.title('Loss during Training', fontsize=14, fontweight='bold')\n",
-    "plt.xlabel('Epochs', fontsize=12)\n",
-    "plt.ylabel('Loss', fontsize=12)\n",
-    "plt.legend()\n",
-    "plt.grid(True, linestyle='--', alpha=0.7)\n",
-    "\n",
-    "# --- 4. Plot Accuracy Curves (Right Side) ---\n",
-    "plt.subplot(1, 2, 2)\n",
-    "t_acc = history.get('train_acc') or history.get('accuracy') or history.get('acc')\n",
-    "v_acc = history.get('val_acc') or history.get('validation_accuracy') or history.get('val_accuracy')\n",
-    "\n",
-    "if t_acc: plt.plot(t_acc, label='Training Accuracy', color='green', linewidth=2, marker='o', markersize=4)\n",
-    "if v_acc: plt.plot(v_acc, label='Validation Accuracy', color='orange', linewidth=2, linestyle='--', marker='s', markersize=4)\n",
-    "\n",
-    "plt.title('Accuracy during Training', fontsize=14, fontweight='bold')\n",
-    "plt.xlabel('Epochs', fontsize=12)\n",
-    "plt.ylabel('Accuracy', fontsize=12)\n",
-    "plt.legend()\n",
-    "plt.grid(True, linestyle='--', alpha=0.7)\n",
-    "\n",
-    "# --- 5. Save and Show ---\n",
-    "plt.tight_layout()\n",
-    "output_path = 'results/loss_and_acc_curve.png'\n",
-    "plt.savefig(output_path, dpi=300)\n",
-    "print(f\"✅ Graph saved to: {output_path}\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6fdbdefa",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[1.098800715803532,\n",
-       " 0.6109571453126136,\n",
-       " 0.4965410860932533,\n",
-       " 0.42825428385224623,\n",
-       " 0.37778599239479677]"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "04495800",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[0.6943156488895417,\n",
-       " 0.8044540574789047,\n",
-       " 0.5931311735272408,\n",
-       " 0.4671015265010297,\n",
-       " 0.5441862164806575]"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d81c1298",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "lab_env",
-   "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.13.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}