13_Testing/30_Enhancing_Testing_With_Test_Time_Augmentation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9e0c293c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os \n",
    "os.environ['KMP_DUPLICATE_LIB_OK']='True'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "903f8943",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import dependencies\n",
    "import time\n",
    "import math\n",
    "import datetime\n",
    "from collections import OrderedDict\n",
    "from tqdm.auto import tqdm\n",
    "from pathlib import Path\n",
    "from thop import profile\n",
    "\n",
    "import torch\n",
    "import torchvision\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.optim import lr_scheduler\n",
    "from torchvision.datasets.mnist import MNIST\n",
    "import torchvision.transforms as transforms\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data.sampler import RandomSampler, SequentialSampler\n",
    "import torch.nn.init as init\n",
    "\n",
    "import mlflow\n",
    "import random\n",
    "import numpy as np\n",
    "import psutil\n",
    "import subprocess\n",
    "from torchsummary import summary\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score\n",
    "\n",
    "import warnings \n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "13abf35c-ae3c-4ff4-8c4f-c5bbb27e87bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# torch.cuda.memory._record_memory_history()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1db77c57-1975-4f86-9188-59fcc8203174",
   "metadata": {},
   "outputs": [],
   "source": [
    "def increment_path(path, exist_ok=False, sep='', mkdir=True):\n",
    "    path = Path(path)\n",
    "    if path.exists() and not exist_ok:\n",
    "        path, suffix = (path.with_suffix(''), path.suffix) if path.is_file() else (path, '')\n",
    "        for n in range(2, 9999):\n",
    "            p = f'{path}{sep}{n}{suffix}'\n",
    "            if not os.path.exists(p):\n",
    "                break\n",
    "        path = Path(p)\n",
    "    if mkdir:\n",
    "        path.mkdir(parents=True, exist_ok=True)\n",
    "    return path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "94032296-1658-4b03-bb63-5c2283e00ce5",
   "metadata": {},
   "outputs": [],
   "source": [
    "EXPERIMENT_NAME = \"exp\"\n",
    "FILE = Path(os.getcwd()).resolve()\n",
    "SAVE_DIR = increment_path(FILE / \"artifacts\" / f\"{EXPERIMENT_NAME}\", exist_ok=False)\n",
    "(SAVE_DIR / 'checkpoints').mkdir(parents=True, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "15c8f025-3784-446b-b6a6-f9570e0bec97",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024/03/13 01:11:36 INFO mlflow.tracking.fluent: Experiment with name 'exp26' does not exist. Creating a new experiment.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Experiment: artifact_location='file:///C:/Users/Hp/Desktop/mldev/2024/Git/mldevworld/Deep-Learning-Essentials/mlruns/26', creation_time=1710272496434, experiment_id='26', last_update_time=1710272496434, lifecycle_stage='active', name='exp26', tags={}>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "local_tracking_uri = f\"sqlite:///mlflow/mlflow.db\"\n",
    "mlflow.set_tracking_uri(local_tracking_uri)\n",
    "mlflow.set_experiment(SAVE_DIR.stem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4b56f9ea-54b0-4175-972a-523290fdbe41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random seed set to 42\n"
     ]
    }
   ],
   "source": [
    "def set_experiment_seed(seed=42):\n",
    "    \"\"\"\n",
    "    Set random seeds and CUDA-related flags for experiment reproducibility.\n",
    "    \"\"\"\n",
    "    # Set random seeds for reproducibility\n",
    "    torch.manual_seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "\n",
    "    # If using GPU, set random seed for CUDA operations\n",
    "    if torch.cuda.is_available():\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "        torch.backends.cudnn.benchmark = False  # Set to False for reproducibility\n",
    "\n",
    "    # Optionally log seed information\n",
    "    print(f\"Random seed set to {seed}\")\n",
    "\n",
    "set_experiment_seed()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "079ce688",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Download MNIST dataset\n",
    "data_train = MNIST(\n",
    "    \"./data/mnist\", download=True, \n",
    "    transform=transforms.Compose([\n",
    "        transforms.Resize((32, 32)),\n",
    "        transforms.RandomRotation(degrees=15),\n",
    "        transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),\n",
    "        transforms.RandomVerticalFlip(),\n",
    "        transforms.ColorJitter(brightness=0.2, contrast=0.2),\n",
    "        transforms.GaussianBlur(kernel_size=1),\n",
    "        transforms.ToTensor()\n",
    "    ])\n",
    ")\n",
    "        \n",
    "data_test = MNIST(\n",
    "    \"./data/mnist\", download=True, train=False,\n",
    "    transform=transforms.Compose([\n",
    "        transforms.Resize((32, 32)),\n",
    "        transforms.ToTensor()\n",
    "    ])\n",
    ")\n",
    "\n",
    "# Define test time transforms\n",
    "tta_transform = transforms.Compose([\n",
    "    transforms.RandomRotation(degrees=15),\n",
    "    transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),\n",
    "    transforms.RandomVerticalFlip(),\n",
    "    transforms.ColorJitter(brightness=0.2, contrast=0.2),\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "372c5b4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define hyperparameters\n",
    "N_CLASSES = 10\n",
    "EPOCHS = 10\n",
    "BATCH_SIZE = 1609\n",
    "DROPOUT_PROB = \t0.12931721102481436\n",
    "USE_BATCHNORM = False\n",
    "LABEL_SMOOTHING = 8.83890730090731e-07\n",
    "LR = 0.028147621640854794\n",
    "WARMUP_PROPORTION = 0.04584907346713653\n",
    "WEIGHT_DECAY = 2.1415275778699216e-06\n",
    "ACCUMULATION_STEPS = 1\n",
    "N_TTA = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "93918f18",
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.figure(figsize=(10,10))\n",
    "# for i in range(25):\n",
    "#     plt.subplot(5,5,i+1)\n",
    "#     plt.xticks([])\n",
    "#     plt.yticks([])\n",
    "#     plt.grid(False)\n",
    "#     plt.imshow(data_train[i][0].permute(1,2,0).numpy(), cmap=plt.cm.binary)\n",
    "#     plt.xlabel(data_train[i][1])\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce264b0f-c32e-4907-bc34-c7644df7d2c7",
   "metadata": {},
   "source": [
    "`torch.utils.data.DataLoader` supports asynchronous data loading and data augmentation in separate worker subprocesses. The default setting for DataLoader is `num_workers=0`, which means that the data loading is synchronous and done in the main process. As a result the main training process has to wait for the data to be available to continue the execution.\r\n",
    "\r\n",
    "Settin`g num_workers >` 0 enables asynchronous data loading and overlap between the training and data loading. num_workers should be tuned depending on the workload, CPU, GPU, and location of training data.`\r\n",
    "\r\n",
    "DataLo`ader acce`pts pin_me`mory argument, which defaults` to F`alse. When using a GPU it’s better to `set pin_memory=`True, this instru`cts DataLo`ader to use pinned memory and enables faster and asynchronous memory copy from the host to the GPU."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fb249649-163b-495a-bd21-94711d5ec411",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_num_workers():\n",
    "    # Calculate the number of CPU cores\n",
    "    num_cpu_cores = os.cpu_count()\n",
    "\n",
    "    # Set a safe maximum multiplier value (e.g., 0.5) to avoid using all available resources\n",
    "    max_multiplier = 0.5\n",
    "\n",
    "    # Calculate the number of workers based on the available resources\n",
    "    multiplier = min(sum(psutil.cpu_percent(interval=1, percpu=True)) / 100.0, max_multiplier)\n",
    "    \n",
    "    # Ensure that num_workers is at least 1\n",
    "    num_workers = max(1, int(num_cpu_cores * multiplier))\n",
    "\n",
    "    return num_workers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5b752015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define train dataloader\n",
    "train_dataloader = DataLoader(\n",
    "    data_train, batch_size=BATCH_SIZE, \n",
    "    sampler=RandomSampler(data_train), \n",
    "    pin_memory=True, num_workers=calculate_num_workers()\n",
    ")\n",
    "\n",
    "# Define test dataloader\n",
    "test_dataloader = DataLoader(\n",
    "    data_test, batch_size=BATCH_SIZE, \n",
    "    sampler=SequentialSampler(data_test),\n",
    "    pin_memory=True, num_workers=calculate_num_workers()\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6864f541-00b1-4851-a1da-288992d8d709",
   "metadata": {},
   "source": [
    "`torch.nn.Conv2d()` has `bias` parameter which defaults to `True` (the same is true for `Conv1d` and `Conv3d` ).\n",
    "\n",
    "If a `nn.Conv2d` layer is directly followed by a `nn.BatchNorm2d` layer, then the bias in the convolution is not needed, instead use `nn.Conv2d(..., bias=False, ....)`. Bias is not needed because in the first step `BatchNorm` subtracts the mean, which effectively cancels out the effect of bias.\n",
    "\n",
    "This is also applicable to 1d and 3d convolutions as long as `BatchNorm`(or other normalization layer) normalizes on the same dimension as convolution’s bias."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "35af50e0-5861-444c-ab61-8581c61f9af0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LeNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(LeNet, self).__init__()\n",
    "                \n",
    "        self.features1 = nn.Sequential(\n",
    "            nn.Conv2d(1, 6, kernel_size=(5, 5), bias=not USE_BATCHNORM),\n",
    "            self._get_norm_layer(6),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=(2, 2), stride=2),\n",
    "            nn.Dropout2d(p=DROPOUT_PROB)\n",
    "        )\n",
    "        \n",
    "        self.features2 = nn.Sequential(\n",
    "            nn.Conv2d(6, 16, kernel_size=(5, 5), bias=not USE_BATCHNORM),\n",
    "            self._get_norm_layer(16),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=(2, 2), stride=2),\n",
    "            nn.Dropout2d(p=DROPOUT_PROB)\n",
    "        )\n",
    "\n",
    "        self.features3 = nn.Sequential(\n",
    "            nn.Conv2d(16, 120, kernel_size=(5, 5), bias=not USE_BATCHNORM),\n",
    "            self._get_norm_layer(120),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout2d(p=DROPOUT_PROB)\n",
    "        )\n",
    "\n",
    "        self.classifier = nn.Sequential(\n",
    "            nn.Linear(120, 84, bias=True),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(p=DROPOUT_PROB),\n",
    "            nn.Linear(84, 10, bias=True)\n",
    "        )\n",
    "\n",
    "        # Initialize layers\n",
    "        self.apply(self._initialize_weights)\n",
    "\n",
    "    def _get_norm_layer(self, channels):\n",
    "        if USE_BATCHNORM:\n",
    "            return nn.BatchNorm2d(channels)\n",
    "        else:\n",
    "            return nn.Identity()\n",
    "\n",
    "    def _initialize_weights(self, m):\n",
    "        if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):\n",
    "            init.kaiming_uniform_(m.weight)\n",
    "            if m.bias is not None:\n",
    "                init.constant_(m.bias, 0)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.features1(x)\n",
    "        x = self.features2(x)\n",
    "        x = self.features3(x)\n",
    "        x = x.view(x.size(0), -1)\n",
    "        x = self.classifier(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "621c6db2-e8a3-42cc-ab36-5694abdf5764",
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "31f61bca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Conv2d-1          [1609, 6, 28, 28]             156\n",
      "          Identity-2          [1609, 6, 28, 28]               0\n",
      "              ReLU-3          [1609, 6, 28, 28]               0\n",
      "         MaxPool2d-4          [1609, 6, 14, 14]               0\n",
      "         Dropout2d-5          [1609, 6, 14, 14]               0\n",
      "            Conv2d-6         [1609, 16, 10, 10]           2,416\n",
      "          Identity-7         [1609, 16, 10, 10]               0\n",
      "              ReLU-8         [1609, 16, 10, 10]               0\n",
      "         MaxPool2d-9           [1609, 16, 5, 5]               0\n",
      "        Dropout2d-10           [1609, 16, 5, 5]               0\n",
      "           Conv2d-11          [1609, 120, 1, 1]          48,120\n",
      "         Identity-12          [1609, 120, 1, 1]               0\n",
      "             ReLU-13          [1609, 120, 1, 1]               0\n",
      "        Dropout2d-14          [1609, 120, 1, 1]               0\n",
      "           Linear-15                 [1609, 84]          10,164\n",
      "             ReLU-16                 [1609, 84]               0\n",
      "          Dropout-17                 [1609, 84]               0\n",
      "           Linear-18                 [1609, 10]             850\n",
      "================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 6.29\n",
      "Forward/backward pass size (MB): 279.96\n",
      "Params size (MB): 0.24\n",
      "Estimated Total Size (MB): 286.48\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Instantiate the model\n",
    "model = LeNet()\n",
    "model = model.to(device)\n",
    "\n",
    "# Test with a random input\n",
    "summary(model, input_size=(1, 32, 32), batch_size=BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d186351-babd-4d4e-886e-d9338ca71640",
   "metadata": {},
   "source": [
    "#### 1. Cross Entropy Loss\n",
    "The standard cross-entropy loss for classification tasks is given by:\n",
    "\n",
    "$$ \\text{Traditional Cross Entropy Loss: } H(y, \\hat{y}) = - \\sum_i y_i \\log(\\hat{y}_i) $$\n",
    "\n",
    " - $y_i$ is a binary indicator of whether class $i$ is the correct classification.  \n",
    " - $p_i$ is the predicted probability of class $i$.\n",
    "\n",
    "#### 2. Label Smoothed Cross Entropy\n",
    "Label Smoothing Cross Entropy Loss introduces a modification to the target distribution:\n",
    "\n",
    " $$ \\text{Label Smoothed Cross Entropy Loss} = - \\sum_i \\left( (1 - \\text{smoothing}) \\cdot 1_{\\{y_i\\}} + \\frac{\\text{smoothing}}{C-1} \\cdot 1_{\\{1 - y_i\\}} \\right) \\cdot \\log(p_i) $$\n",
    "\n",
    "Where:\n",
    "- $1_{\\{y_i\\}}$ is a binary indicator of whether class $i$ is the correct classification.\n",
    "- $p_i$ is the predicted probability of class $i$.\n",
    "- $C$ is the number of classes.\n",
    "- $\\text{smoothing}$  is the smoothing factor.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5556bcc8-3ff2-4169-b316-0a7b17aa1d2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LabelSmoothedCrossEntropy(nn.Module):\n",
    "    def __init__(self, num_classes, smoothing):\n",
    "        super(LabelSmoothedCrossEntropy, self).__init__()\n",
    "        self.num_classes = num_classes\n",
    "        self.smoothing = smoothing\n",
    "        self.confidence = 1.0 - smoothing\n",
    "\n",
    "    def forward(self, input_logits, target):\n",
    "        log_probs = F.log_softmax(input_logits, dim=-1)\n",
    "        true_dist = torch.zeros_like(log_probs)\n",
    "        true_dist.fill_(self.smoothing / (self.num_classes - 1))\n",
    "        true_dist.scatter_(1, target.data.unsqueeze(1), self.confidence)\n",
    "        loss = -torch.sum(true_dist * log_probs) / input_logits.size(0)\n",
    "        return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "262d50c6-de05-416f-8ad7-14792edf403c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize loss\n",
    "# criterion = nn.CrossEntropyLoss()\n",
    "criterion = LabelSmoothedCrossEntropy(num_classes=N_CLASSES, smoothing=LABEL_SMOOTHING)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1365bb52-8cf9-414e-bb7e-d87c073b933b",
   "metadata": {},
   "source": [
    "#### Adam w/ Weight Decay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3412026a-4b8b-4070-9781-6efb964d3446",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize optimizer\n",
    "# optimizer = optim.Adam(model.parameters(), lr=LR)\n",
    "optimizer = optim.AdamW(model.parameters(), lr=LR, weight_decay=WEIGHT_DECAY)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f78d5cf-5ad7-4d10-be31-cb8d498227c4",
   "metadata": {},
   "source": [
    "#### Cosine Annealing With Warmup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6ebc561a-59b6-4848-92f0-bb32d4682d1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_lr_lambda(initial_lr, warmup_steps, total_steps):\n",
    "    def lr_lambda(current_step):\n",
    "        if current_step < warmup_steps:\n",
    "            return initial_lr + (1.0 - initial_lr) * float(current_step) / float(max(1, warmup_steps))\n",
    "        else:\n",
    "            return max(0.0, 0.5 * (1.0 + math.cos(math.pi * (current_step - warmup_steps) / float(total_steps - warmup_steps))))\n",
    "    return lr_lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b45993ef-a7a2-4154-9eeb-d10e5e003e4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "len_dataloader = len(train_dataloader)\n",
    "num_update_steps_per_epoch = max(len_dataloader // ACCUMULATION_STEPS, 1) \n",
    "num_examples = len(train_dataloader.dataset)\n",
    "max_steps = math.ceil(EPOCHS * num_update_steps_per_epoch)\n",
    "num_warmup_steps = math.ceil(max_steps * WARMUP_PROPORTION)\n",
    "lr_lambda = get_lr_lambda(LR, num_warmup_steps, max_steps)\n",
    "scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lr_lambda)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab52c285-645c-4c4f-a051-565c8eb72c94",
   "metadata": {},
   "source": [
    "#### Adaptive Gradient Clipping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d4216258-a9d0-4eda-9aa0-e91543d2f4d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def unitwise_norm(x, norm_type=2.0):\n",
    "    if x.ndim <= 1:\n",
    "        return x.norm(norm_type)\n",
    "    else:\n",
    "        return x.norm(norm_type, dim=tuple(range(1, x.ndim)), keepdim=True)\n",
    "\n",
    "\n",
    "def adaptive_clip_grad(parameters, clip_factor=0.01, eps=1e-3, norm_type=2.0):\n",
    "    if isinstance(parameters, torch.Tensor):\n",
    "        parameters = [parameters]\n",
    "    for p in parameters:\n",
    "        if p.grad is None:\n",
    "            continue\n",
    "        p_data = p.detach()\n",
    "        g_data = p.grad.detach()\n",
    "        max_norm = unitwise_norm(p_data, norm_type=norm_type).clamp_(min=eps).mul_(clip_factor)\n",
    "        grad_norm = unitwise_norm(g_data, norm_type=norm_type)\n",
    "        clipped_grad = g_data * (max_norm / grad_norm.clamp(min=1e-6))\n",
    "        new_grads = torch.where(grad_norm < max_norm, g_data, clipped_grad)\n",
    "        p.grad.detach().copy_(new_grads)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "465ce651-83e8-4526-a9fc-bf799b70446b",
   "metadata": {},
   "source": [
    "#### Logging Model Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "e8aa3340-60e2-4583-8867-d197fb467d33",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_flops(input_size):\n",
    "    input_tensor = torch.randn(*input_size).to(device)\n",
    "    flops, params = profile(model, inputs=(input_tensor,))\n",
    "    return flops\n",
    "\n",
    "def calculate_disk_size():\n",
    "    # Calculate model disk size in bytes\n",
    "    disk_size_bytes = sum(p.numel() * p.element_size() for p in model.parameters())\n",
    "    # Convert bytes to megabytes\n",
    "    disk_size_mb = disk_size_bytes / (1024 * 1024)\n",
    "    return disk_size_mb\n",
    "\n",
    "def get_model_metrics():\n",
    "    num_params = sum(p.numel() for p in model.parameters())\n",
    "    num_trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "    # Set an example input size (adjust based on your actual input size)\n",
    "    input_size = tuple(next(iter(train_dataloader))[0][0].unsqueeze(0).shape)\n",
    "\n",
    "    flops = calculate_flops(input_size)\n",
    "    disk_size = calculate_disk_size()\n",
    "\n",
    "    return {\n",
    "        \"num_params\": num_params,\n",
    "        \"num_trainable_params\": num_trainable_params,\n",
    "        \"flops\": flops,\n",
    "        \"disk_size\": disk_size\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0be3441b-14b2-4251-9bc4-b61b60263606",
   "metadata": {},
   "source": [
    "#### Logging GPU Usage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "02adfbae-1213-4960-b91a-0abf1079256a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_gpu_usage():\n",
    "    try:\n",
    "        # Run nvidia-smi command to get GPU utilization information\n",
    "        result = subprocess.run([\"nvidia-smi\", \"--query-gpu=utilization.gpu\", \"--format=csv,nounits,noheader\"], stdout=subprocess.PIPE, text=True)\n",
    "        gpu_usage = int(result.stdout.strip())\n",
    "        return gpu_usage\n",
    "    except Exception as e:\n",
    "        print(f\"Error getting GPU usage: {e}\")\n",
    "        return None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6297eb60-ff83-4f9a-abbb-47919289ecc4",
   "metadata": {},
   "source": [
    "#### Train\n",
    "\n",
    "##### Gradient Penalty\n",
    "Its primary purpose is to encourage smoothness in the learned representations of the model by penalizing sharp changes or oscillations in the model's gradients.\n",
    "\n",
    "##### Gradient Accumulation\n",
    "Gradient accumulation adds gradients over an effective batch of size `batch_per_iter * iters_to_accumulate` (`* num_procs` if distributed). The scale should be calibrated for the effective batch, which means inf/NaN checking, step skipping if inf/NaN grads are found, and scale updates should occur at effective-batch granularity. Also, grads should remain scaled, and the scale factor should remain constant, while grads for a given effective batch are accumulated. If grads are unscaled (or the scale factor changes) before accumulation is complete, the next backward pass will add scaled grads to unscaled grads (or grads scaled by a different factor) after which it’s impossible to recover the accumulated unscaled grads `step` must apply.\n",
    "\n",
    "##### Automatic Mixed Precision Training\n",
    "Automatic Mixed Precision (AMP) training is a technique used in deep learning to accelerate training by using a combination of lower-precision and higher-precision numerical representations. The primary idea behind AMP is to use lower-precision data types (such as float16) for some parts of the model computation, while maintaining higher precision (such as float32) for critical numerical stability aspects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "34cd9acf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(epoch):\n",
    "    model.train()\n",
    "    total_loss = 0.0\n",
    "    \n",
    "    # Create a GradScaler once at the beginning of training.\n",
    "    scaler = torch.cuda.amp.GradScaler()\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    with tqdm(total=len(train_dataloader), desc=f\"Epoch {epoch}/Training\", unit=\"batch\") as pbar:\n",
    "        for i, (images, labels) in enumerate(train_dataloader):\n",
    "            images, labels = images.to(device), labels.to(device)\n",
    "\n",
    "            # Runs the forward pass with autocasting.\n",
    "            with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=True):\n",
    "                output = model(images)\n",
    "                loss = criterion(output, labels)\n",
    "\n",
    "            # # Scales the loss for autograd.grad's backward pass, producing scaled_grad_params\n",
    "            # scaled_grad_params = torch.autograd.grad(outputs=scaler.scale(loss), inputs=model.parameters(), create_graph=True)\n",
    "    \n",
    "            # # Creates unscaled grad_params before computing the penalty. scaled_grad_params are\n",
    "            # # not owned by any optimizer, so ordinary division is used instead of scaler.unscale_:\n",
    "            # inv_scale = 1. / scaler.get_scale()\n",
    "            # grad_params = [p * inv_scale for p in scaled_grad_params]\n",
    "    \n",
    "            # # Computes the penalty term and adds it to the loss\n",
    "            # with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=True):\n",
    "            #     grad_norm = 0\n",
    "            #     for grad in grad_params:\n",
    "            #         grad_norm += grad.pow(2).sum()\n",
    "            #     grad_norm = grad_norm.sqrt()\n",
    "            #     loss = loss + grad_norm\n",
    "\n",
    "            # Scale the loss by accumulation steps\n",
    "            if ACCUMULATION_STEPS > 1:\n",
    "                with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=True):\n",
    "                    loss = loss / ACCUMULATION_STEPS\n",
    "                \n",
    "            # Applies scaling to the backward call as usual.\n",
    "            # Accumulates leaf gradients that are correctly scaled.\n",
    "            scaler.scale(loss).backward()\n",
    "\n",
    "            if (i + 1) % ACCUMULATION_STEPS == 0:\n",
    "                # Unscales the gradients of optimizer's assigned params in-place\n",
    "                scaler.unscale_(optimizer)\n",
    "                # torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)\n",
    "                adaptive_clip_grad(model.parameters())\n",
    "\n",
    "                # optimizer's gradients are already unscaled, so scaler.step does not unscale them,\n",
    "                # although it still skips optimizer.step() if the gradients contain infs or NaNs.\n",
    "                scaler.step(optimizer)\n",
    "\n",
    "                mlflow.log_metric(\"lr\", optimizer.param_groups[0][\"lr\"])\n",
    "                scheduler.step()\n",
    "\n",
    "                # Updates the scale for next iteration.\n",
    "                scaler.update()\n",
    "                \n",
    "                for param in model.parameters():\n",
    "                    param.grad = None\n",
    "            \n",
    "            total_loss += loss.item()\n",
    "            pbar.update(1)\n",
    "            pbar.set_postfix(loss=total_loss / (i+1), lr=f\"{optimizer.param_groups[0]['lr']:.5f}\")\n",
    "\n",
    "    avg_loss = total_loss / len(train_dataloader.dataset)\n",
    "    mlflow.log_metric(\"train_loss\", avg_loss)\n",
    "        \n",
    "    print(f\"[Train][Epoch {epoch}] Average Loss: {avg_loss:.5f}, Updated Learning Rate: {optimizer.param_groups[0]['lr']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a217af40-7a4e-4a1e-8cfc-133fc220090f",
   "metadata": {},
   "source": [
    "#### Eval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "65850723-b84a-4915-8429-644a1805ba97",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BestLossTracker:\n",
    "    def __init__(self):\n",
    "        self.best_loss = float('inf')\n",
    "    \n",
    "    def update_best_loss(self, avg_loss):\n",
    "        if avg_loss < self.best_loss:\n",
    "            self.best_loss = avg_loss\n",
    "            return True\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c2ca1f2b-086a-4160-a0a6-f0abb7c43100",
   "metadata": {},
   "outputs": [],
   "source": [
    "class EarlyStopping:\n",
    "    def __init__(self, patience=5, delta=0.0):\n",
    "        self.patience = patience\n",
    "        self.delta = delta\n",
    "        self.counter = 0\n",
    "        self.best_loss = float('inf')\n",
    "        self.early_stop = False\n",
    "\n",
    "    def update_best_loss(self, val_loss):\n",
    "        if val_loss < self.best_loss - self.delta:\n",
    "            self.best_loss = val_loss\n",
    "            self.counter = 0\n",
    "        else:\n",
    "            self.counter += 1\n",
    "            if self.counter >= self.patience:\n",
    "                self.early_stop = True\n",
    "\n",
    "        return not self.early_stop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "de2f38e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(epoch, best_loss_tracker):\n",
    "    model.eval()\n",
    "    total_correct = 0\n",
    "    total_loss = 0.0\n",
    "\n",
    "    with tqdm(total=len(test_dataloader), desc=f\"Epoch {epoch}/Testing\", unit=\"batch\") as pbar: \n",
    "        with torch.no_grad():\n",
    "            for i, (images, labels) in enumerate(test_dataloader):\n",
    "                images, labels = images.to(device), labels.to(device)\n",
    "                \n",
    "                # Test-time augmentation\n",
    "                augmented_predictions = []\n",
    "                augmented_losses = []\n",
    "                for _ in range(N_TTA):\n",
    "                    augmented_images = tta_transform(images)\n",
    "                    augmented_output = model(augmented_images)\n",
    "                    augmented_loss = criterion(augmented_output, labels)\n",
    "                    augmented_losses.append(augmented_loss.item())\n",
    "                    augmented_predictions.append(augmented_output.detach().cpu().numpy())\n",
    "\n",
    "                # Take the average loss over augmentations\n",
    "                total_loss += sum(augmented_losses) / len(augmented_losses)\n",
    "                \n",
    "                # Take the average of predictions across augmentations\n",
    "                final_predictions = torch.tensor(np.array(augmented_predictions), dtype=torch.float32).mean(dim=0)\n",
    "                pred = final_predictions.detach().max(1)[1].to(device)\n",
    "                total_correct += pred.eq(labels.view_as(pred)).sum()\n",
    "                \n",
    "    avg_loss = total_loss / len(test_dataloader.dataset)\n",
    "    accuracy = total_correct / len(test_dataloader.dataset)\n",
    "\n",
    "    mlflow.log_metric(\"val_loss\", avg_loss)\n",
    "    mlflow.log_metric(\"val_accuracy\", accuracy)\n",
    "    \n",
    "    if best_loss_tracker.update_best_loss(avg_loss):\n",
    "        checkpoint_name = f\"checkpoint_best_epoch_{epoch}.pth\"\n",
    "        checkpoint_path = str(SAVE_DIR / \"checkpoints\" / checkpoint_name)\n",
    "        torch.save(model.state_dict(), checkpoint_path)\n",
    "        print(f\"[Test][Epoch {epoch}] New best model found! Saving checkpoint. Loss: {avg_loss:.5f}, Accuracy: {accuracy:.3f}\")\n",
    "    else:\n",
    "        print(f\"[Test][Epoch {epoch}] Loss: {avg_loss:.5f}, Accuracy: {accuracy:.3f}\")\n",
    "    \n",
    "    return avg_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e589a1d-848f-4045-813c-662ef287e348",
   "metadata": {},
   "source": [
    "#### Run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "0c3cd024",
   "metadata": {},
   "outputs": [],
   "source": [
    "def run():\n",
    "    with mlflow.start_run(run_name=\"Understanding_CUDA_Memory_Usage\"):\n",
    "        mlflow.log_param(\"torch_version\", torch.__version__)\n",
    "        mlflow.log_param(\"mlflow_version\", mlflow.__version__)\n",
    "\n",
    "        hyper_params = {\n",
    "            \"accumulation_steps\": ACCUMULATION_STEPS, \n",
    "            \"batch_size\": BATCH_SIZE, \n",
    "            \"dropout\":DROPOUT_PROB,\n",
    "            \"epochs\": EPOCHS, \n",
    "            \"batchnorm\": USE_BATCHNORM,\n",
    "            \"label_smoothing\": LABEL_SMOOTHING,\n",
    "            \"start_lr\": LR,\n",
    "            \"warmup_proortion\": WARMUP_PROPORTION,\n",
    "            \"weight_decay\": WEIGHT_DECAY\n",
    "        }\n",
    "\n",
    "        mlflow.log_params(hyper_params)\n",
    "        mlflow.set_tags({\"model\": \"lenet\", \"dataset\": \"mnist\"})\n",
    "        mlflow.pytorch.log_model(model, \"model\")\n",
    "        mlflow.log_param(\"start_time\", datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"))\n",
    "\n",
    "        model_metrics = get_model_metrics()\n",
    "        mlflow.log_param(\"num_params\", model_metrics['num_params'])\n",
    "        mlflow.log_param(\"num_trainable_params\", model_metrics['num_trainable_params'])\n",
    "        mlflow.log_param(\"flops\", model_metrics['flops'])\n",
    "        mlflow.log_param(\"disk_size\", model_metrics['disk_size'])\n",
    "\n",
    "        best_loss_tracker = BestLossTracker()\n",
    "        early_stopping = EarlyStopping(patience=3, delta=1e-6)\n",
    "\n",
    "        start_time = time.time()\n",
    "        for epoch in range(EPOCHS):\n",
    "            train(epoch)\n",
    "            val_loss = test(epoch, best_loss_tracker)\n",
    "            \n",
    "            if get_gpu_usage() is not None:\n",
    "                mlflow.log_metric(\"gpu\", get_gpu_usage(), step=epoch)\n",
    "\n",
    "            if not early_stopping.update_best_loss(val_loss):\n",
    "                print(\"Early stopping triggered.\")\n",
    "                break\n",
    "\n",
    "\n",
    "        total_time = time.time() - start_time\n",
    "        avg_epoch_time = total_time / EPOCHS\n",
    "        avg_batch_time = avg_epoch_time / len(train_dataloader)\n",
    "\n",
    "        mlflow.log_metric(\"total_training_time\", total_time)\n",
    "        mlflow.log_metric(\"average_epoch_time\", avg_epoch_time)\n",
    "        mlflow.log_metric(\"average_batch_time\", avg_batch_time)\n",
    "        mlflow.log_param(\"end_time\", datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"))\n",
    "\n",
    "# torch.cuda.memory._dump_snapshot(\"snapshot.pickle\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "04e628b2-39af-4e82-8d13-e94a3f4ffd86",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024/03/13 01:11:39 WARNING mlflow.utils.requirements_utils: Found torch version (2.2.0+cu118) contains a local version label (+cu118). MLflow logged a pip requirement for this package as 'torch==2.2.0' without the local version label to make it installable from PyPI. To specify pip requirements containing local version labels, please use `conda_env` or `pip_requirements`.\n",
      "2024/03/13 01:11:42 WARNING mlflow.utils.requirements_utils: Found torch version (2.2.0+cu118) contains a local version label (+cu118). MLflow logged a pip requirement for this package as 'torch==2.2.0' without the local version label to make it installable from PyPI. To specify pip requirements containing local version labels, please use `conda_env` or `pip_requirements`.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Register count_convNd() for <class 'torch.nn.modules.conv.Conv2d'>.\n",
      "[INFO] Register zero_ops() for <class 'torch.nn.modules.activation.ReLU'>.\n",
      "[INFO] Register zero_ops() for <class 'torch.nn.modules.pooling.MaxPool2d'>.\n",
      "[INFO] Register zero_ops() for <class 'torch.nn.modules.container.Sequential'>.\n",
      "[INFO] Register count_linear() for <class 'torch.nn.modules.linear.Linear'>.\n",
      "[INFO] Register zero_ops() for <class 'torch.nn.modules.dropout.Dropout'>.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "32457e9923a24d78a3bf7753c3090288",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 0/Training:   0%|          | 0/38 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Train][Epoch 0] Average Loss: 0.00090, Updated Learning Rate: 0.027936158958914464\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "49e0a5cdb3574b6d97a0a568c354dc58",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 0/Testing:   0%|          | 0/7 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test][Epoch 0] New best model found! Saving checkpoint. Loss: 0.00034, Accuracy: 0.926\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "47672a962f454dedb3e8bac4483e2b31",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 1/Training:   0%|          | 0/38 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Train][Epoch 1] Average Loss: 0.00036, Updated Learning Rate: 0.026402075025726137\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2de0b8bcca84464db6945cc0cf84cd16",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 1/Testing:   0%|          | 0/7 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test][Epoch 1] New best model found! Saving checkpoint. Loss: 0.00020, Accuracy: 0.955\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "862ec8918ae9480a8a35df9e85cd0979",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 2/Training:   0%|          | 0/38 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Train][Epoch 2] Average Loss: 0.00027, Updated Learning Rate: 0.023539336241444258\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "391ca8420c784405b5642eaaa11ab819",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 2/Testing:   0%|          | 0/7 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test][Epoch 2] New best model found! Saving checkpoint. Loss: 0.00017, Accuracy: 0.965\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "05ad2cd5c8e7459dbf99e736073c2c6a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 3/Training:   0%|          | 0/38 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Train][Epoch 3] Average Loss: 0.00023, Updated Learning Rate: 0.019656468746473504\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c03388f752c4484193836c0cac4f1c71",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 3/Testing:   0%|          | 0/7 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test][Epoch 3] New best model found! Saving checkpoint. Loss: 0.00014, Accuracy: 0.970\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b4766a31b43a4e25927dc408fab99fb9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 4/Training:   0%|          | 0/38 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Train][Epoch 4] Average Loss: 0.00020, Updated Learning Rate: 0.015171941081675348\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0c6454a6a8384d8ca46df15b6b5fb889",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 4/Testing:   0%|          | 0/7 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test][Epoch 4] New best model found! Saving checkpoint. Loss: 0.00012, Accuracy: 0.971\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "514ff0fee5fb486c99e979dc2d0b623e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 5/Training:   0%|          | 0/38 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Train][Epoch 5] Average Loss: 0.00019, Updated Learning Rate: 0.010569064550042183\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b1712032011b4af5a1bcc3172a0bed63",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 5/Testing:   0%|          | 0/7 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test][Epoch 5] New best model found! Saving checkpoint. Loss: 0.00012, Accuracy: 0.971\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "984c4d8a84954a68b9094a1d77f6db4f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 6/Training:   0%|          | 0/38 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Train][Epoch 6] Average Loss: 0.00017, Updated Learning Rate: 0.006343905274987439\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c86fbb016db2423cb476081e8444a61d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 6/Testing:   0%|          | 0/7 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test][Epoch 6] New best model found! Saving checkpoint. Loss: 0.00010, Accuracy: 0.975\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "75fb84b5ccb04814bd24267b06934ca9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 7/Training:   0%|          | 0/38 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Train][Epoch 7] Average Loss: 0.00016, Updated Learning Rate: 0.0029518216325127794\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9a462de92ae545f2baf0e390b0c26878",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 7/Testing:   0%|          | 0/7 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test][Epoch 7] Loss: 0.00011, Accuracy: 0.977\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f9ef0055a36644d5b21df567a9e3b25c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 8/Training:   0%|          | 0/38 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Train][Epoch 8] Average Loss: 0.00015, Updated Learning Rate: 0.000758388882187354\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2c415fa6ff024ceebabb13b94794fb6c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 8/Testing:   0%|          | 0/7 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test][Epoch 8] New best model found! Saving checkpoint. Loss: 0.00010, Accuracy: 0.978\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "578847133f714eabb50dd39838d0bd26",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 9/Training:   0%|          | 0/38 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Train][Epoch 9] Average Loss: 0.00015, Updated Learning Rate: 0.0\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ca68d44264fc403ca526e786e4c39ba5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 9/Testing:   0%|          | 0/7 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test][Epoch 9] New best model found! Saving checkpoint. Loss: 0.00009, Accuracy: 0.978\n"
     ]
    }
   ],
   "source": [
    "run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f12b1d5c-6bd7-479c-82d9-9d630e47056c",
   "metadata": {},
   "source": [
    "### Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "7ae47305-cd05-4317-b279-631031e8ae73",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(model, dataloader):\n",
    "    model.eval()\n",
    "    all_predictions = []\n",
    "    all_labels = []\n",
    "    all_probabilities = []\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for inputs, labels in dataloader:\n",
    "            outputs = model(inputs.to(device))\n",
    "            _, predictions = torch.max(outputs, 1)\n",
    "            probabilities = torch.nn.functional.softmax(outputs, dim=1)\n",
    "\n",
    "            all_predictions.extend(predictions.cpu().numpy())\n",
    "            all_labels.extend(labels.numpy())\n",
    "            all_probabilities.extend(probabilities.cpu().numpy())\n",
    "\n",
    "    return all_predictions, all_labels, all_probabilities"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "307ee4e9-f00c-4d09-83dd-eebc75b56681",
   "metadata": {},
   "source": [
    "#### Error Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "c638b25d-c4e8-45f9-a814-381f72c1842f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run evaluation and gather predictions, labels and probablities\n",
    "classes = [str(i) for i in range(10)]\n",
    "model_predictions, true_labels, model_probablities = evaluate(model, test_dataloader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "004eea67-788b-4501-a1b3-d31944d6f487",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_classification_report(y_true, y_pred, target_names):\n",
    "    print(classification_report(y_true, y_pred, target_names=target_names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "31ea4aca-cb0c-4276-aae9-9d1665b33a12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.99      0.99       980\n",
      "           1       1.00      0.99      0.99      1135\n",
      "           2       0.92      0.95      0.94      1032\n",
      "           3       0.99      0.98      0.98      1010\n",
      "           4       0.98      0.98      0.98       982\n",
      "           5       0.97      0.93      0.95       892\n",
      "           6       0.98      0.99      0.99       958\n",
      "           7       0.96      0.99      0.98      1028\n",
      "           8       0.98      0.99      0.99       974\n",
      "           9       0.97      0.97      0.97      1009\n",
      "\n",
      "    accuracy                           0.97     10000\n",
      "   macro avg       0.97      0.97      0.97     10000\n",
      "weighted avg       0.97      0.97      0.97     10000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print_classification_report(true_labels, model_predictions, classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e2d02e8-b4f8-401f-8641-361eeb4e54f6",
   "metadata": {},
   "source": [
    "### Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "30296f9c-1409-4734-9e15-6a5700f464b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(y_true, y_pred, classes, title='Confusion Matrix', cmap=plt.cm.Blues):\n",
    "    cm = confusion_matrix(y_true, y_pred)\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    sns.heatmap(cm, annot=True, fmt=\"d\", cmap=cmap, xticklabels=classes, yticklabels=classes)\n",
    "    plt.title(title)\n",
    "    plt.xlabel('Predicted Label')\n",
    "    plt.ylabel('True Label')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "af118226-8bb7-44d7-b56d-daf52ebdb63c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(true_labels, model_predictions, classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ad56254-c91d-4950-a4ee-9695b90bec59",
   "metadata": {},
   "source": [
    "### Classwise Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "b5242205-3431-4e79-8caf-3a23a4c361c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "classes = [i for i in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "feffe680-dc93-4b89-8284-cac850619345",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Class 0 Metrics:\n",
      "  Precision: 1.0000\n",
      "  Recall:    0.9888\n",
      "  F1-Score:  0.9944\n",
      "\n",
      "Class 1 Metrics:\n",
      "  Precision: 1.0000\n",
      "  Recall:    0.9868\n",
      "  F1-Score:  0.9933\n",
      "\n",
      "Class 2 Metrics:\n",
      "  Precision: 1.0000\n",
      "  Recall:    0.9525\n",
      "  F1-Score:  0.9757\n",
      "\n",
      "Class 3 Metrics:\n",
      "  Precision: 1.0000\n",
      "  Recall:    0.9802\n",
      "  F1-Score:  0.9900\n",
      "\n",
      "Class 4 Metrics:\n",
      "  Precision: 1.0000\n",
      "  Recall:    0.9776\n",
      "  F1-Score:  0.9887\n",
      "\n",
      "Class 5 Metrics:\n",
      "  Precision: 1.0000\n",
      "  Recall:    0.9260\n",
      "  F1-Score:  0.9616\n",
      "\n",
      "Class 6 Metrics:\n",
      "  Precision: 1.0000\n",
      "  Recall:    0.9896\n",
      "  F1-Score:  0.9948\n",
      "\n",
      "Class 7 Metrics:\n",
      "  Precision: 1.0000\n",
      "  Recall:    0.9864\n",
      "  F1-Score:  0.9931\n",
      "\n",
      "Class 8 Metrics:\n",
      "  Precision: 1.0000\n",
      "  Recall:    0.9867\n",
      "  F1-Score:  0.9933\n",
      "\n",
      "Class 9 Metrics:\n",
      "  Precision: 1.0000\n",
      "  Recall:    0.9663\n",
      "  F1-Score:  0.9829\n",
      "\n",
      "Overall Accuracy: 0.9746\n"
     ]
    }
   ],
   "source": [
    "y_test, y_pred = np.array(true_labels), np.array(model_predictions)\n",
    "for cls in classes:\n",
    "    cls_indices = (y_test == cls)\n",
    "    cls_precision = precision_score(y_test[cls_indices], y_pred[cls_indices], average='weighted')\n",
    "    cls_recall = recall_score(y_test[cls_indices], y_pred[cls_indices], average='weighted')\n",
    "    cls_f1_score = f1_score(y_test[cls_indices], y_pred[cls_indices], average='weighted')\n",
    "    \n",
    "    print(f\"\\nClass {cls} Metrics:\")\n",
    "    print(f\"  Precision: {cls_precision:.4f}\")\n",
    "    print(f\"  Recall:    {cls_recall:.4f}\")\n",
    "    print(f\"  F1-Score:  {cls_f1_score:.4f}\")\n",
    "\n",
    "# Print overall accuracy\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(f\"\\nOverall Accuracy: {accuracy:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6807ff1b-5415-4e7d-b1d5-b6471ee6c777",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}