Addalin_230187746.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "GXQTc_W7YFdd"
   },
   "outputs": [],
   "source": [
    "# importing libraries\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import torchvision.transforms as transforms\n",
    "import torch\n",
    "import torchvision"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Checking for Cuda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6161,
     "status": "ok",
     "timestamp": 1706977661049,
     "user": {
      "displayName": "Paulo Rauber",
      "userId": "08697591328641962840"
     },
     "user_tz": 0
    },
    "id": "P972v29oYIl0",
    "outputId": "a046e101-afd2-4bab-a8bf-626836d3bae0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cuda.\n"
     ]
    }
   ],
   "source": [
    "# checking if cuda is available\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "print(f'Using {device}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading and Data Transforming CIFAR-10 dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0qNQhcPoZE7k"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "# defining data transformations for training and testing datasets\n",
    "transform_train = transforms.Compose([\n",
    "    transforms.RandomCrop(32, padding=4, padding_mode='reflect'),  # Randomly crop the image with reflection padding\n",
    "    transforms.RandomHorizontalFlip(),  # Randomly flip the image horizontally\n",
    "    transforms.ToTensor(),  # Convert the image to a PyTorch tensor\n",
    "    transforms.Normalize((-0.0028, -0.0045, -0.0044), (1.2187, 1.2189, 1.2989))  # Normalize the image tensor\n",
    "])\n",
    "\n",
    "transform_test = transforms.Compose([\n",
    "    transforms.ToTensor(),  # Convert the image to a PyTorch tensor\n",
    "    transforms.Normalize((-0.0028, -0.0045, -0.0044), (1.2187, 1.2189, 1.2989))  # Normalize the image tensor\n",
    "])\n",
    "\n",
    "# loading CIFAR-10 training dataset\n",
    "trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)\n",
    "# DataLoader for the training dataset\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=3)\n",
    "\n",
    "# loading CIFAR-10 testing dataset\n",
    "testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n",
    "# DataLoader for the testing dataset\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=3)\n",
    "\n",
    "# Referenced from:\n",
    "# Das, K. (2020). CIFAR10 ResNet: 90+% accuracy;less than 5 min. Kaggle. Retrieved April 9, 2024, from\n",
    "# https://www.kaggle.com/code/kmldas/cifar10-resnet-90-accuracy-less-than-5-min"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ResNet18 Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "UJ9YUgsRbzjj"
   },
   "outputs": [],
   "source": [
    "# adopted from week 8 ResNet lab  \n",
    "# defining a Residual Block module for the ResNet architecture\n",
    "class ResNetBlock(torch.nn.Module):\n",
    "    def __init__(self, input_channels, output_channels, stride=1):\n",
    "        super(ResNetBlock, self).__init__()\n",
    "\n",
    "        # First convolutional layer with batch normalization and ReLU activation\n",
    "        self.conv1 = torch.nn.Conv2d(input_channels, output_channels, kernel_size=3, padding=1, stride=stride)\n",
    "        self.bn1 = torch.nn.BatchNorm2d(output_channels)\n",
    "        self.relu1 = torch.nn.ReLU()\n",
    "\n",
    "        # Second convolutional layer with batch normalization\n",
    "        self.conv2 = torch.nn.Conv2d(output_channels, output_channels, kernel_size=3, padding=1)\n",
    "        self.bn2 = torch.nn.BatchNorm2d(output_channels)\n",
    "\n",
    "        # Third convolutional layer for adjusting dimensions which is optional\n",
    "        self.conv3 = None\n",
    "        if (input_channels != output_channels) or (stride != 1):\n",
    "            self.conv3 = torch.nn.Conv2d(input_channels, output_channels, kernel_size=1, stride=stride)\n",
    "\n",
    "        self.relu2 = torch.nn.ReLU()\n",
    "\n",
    "    def forward(self, x):\n",
    "        # passing through the first convolutional layer\n",
    "        out = self.conv1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.relu1(out)\n",
    "\n",
    "        # passing through the second convolutional layer\n",
    "        out = self.conv2(out)\n",
    "        out = self.bn2(out)\n",
    "\n",
    "        # apply the third convolutional layer and add the residual, which is optional \n",
    "        if self.conv3:\n",
    "            out += self.conv3(x)\n",
    "        else:\n",
    "            out += x\n",
    "\n",
    "        # applying ReLU activation to the output\n",
    "        return self.relu2(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "EDW3Jd_mdxdh"
   },
   "outputs": [],
   "source": [
    "# adopted from week 8 ResNet lab \n",
    "# macroblock in the ResNet architecture with two ResNet blocks\n",
    "class ResNetMacroblock(torch.nn.Module):\n",
    "    def __init__(self, input_channels, output_channels, first_macroblock=False):\n",
    "        super(ResNetMacroblock, self).__init__()\n",
    "\n",
    "        # determining the stride if it is the first macroblock or not\n",
    "        s = 1 if first_macroblock else 2\n",
    "\n",
    "        # first ResNet block\n",
    "        self.rb1 = ResNetBlock(input_channels, output_channels, stride=s)\n",
    "        # second ResNet block\n",
    "        self.rb2 = ResNetBlock(output_channels, output_channels, stride=1)\n",
    "\n",
    "    # passing through the macroblock\n",
    "    def forward(self, x):\n",
    "        # passing through the first ResNet block\n",
    "        out = self.rb1(x)\n",
    "        # passing through the second ResNet block\n",
    "        out = self.rb2(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "mb6ZCd5Ji5jR"
   },
   "outputs": [],
   "source": [
    "# adopted from week 8 ResNet lab \n",
    "# defining ResNet18 architecture\n",
    "class ResNet18(torch.nn.Module):\n",
    "    def __init__(self, num_outputs):\n",
    "        super(ResNet18, self).__init__()\n",
    "\n",
    "        # number of output classes\n",
    "        self.num_outputs = num_outputs\n",
    "\n",
    "        # initial convolutional layer\n",
    "        self.conv = torch.nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False) \n",
    "        # batch normalization layer\n",
    "        self.bn = torch.nn.BatchNorm2d(64)\n",
    "        # activation function\n",
    "        self.relu = torch.nn.ReLU()\n",
    "        # max pooling layer\n",
    "        self.maxpool = torch.nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
    "\n",
    "        # ResNet macroblocks\n",
    "        self.rmb1 = ResNetMacroblock(64, 64, first_macroblock=True)\n",
    "        self.rmb2 = ResNetMacroblock(64, 128)\n",
    "        self.rmb3 = ResNetMacroblock(128, 256)\n",
    "        self.rmb4 = ResNetMacroblock(256, 512)\n",
    "\n",
    "        # adaptive average pooling layer\n",
    "        self.channel_avg = torch.nn.AdaptiveAvgPool2d((1, 1))\n",
    "        # flatting the output tensor\n",
    "        self.flatten = torch.nn.Flatten()\n",
    "        # defining the fully connected layer for classification\n",
    "        self.linear = torch.nn.Linear(512, self.num_outputs)\n",
    "\n",
    "    # passing through the network\n",
    "    def forward(self, x):\n",
    "        out = self.conv(x)\n",
    "        out = self.bn(out)\n",
    "        out = self.relu(out)\n",
    "        out = self.maxpool(out)\n",
    "\n",
    "        out = self.rmb1(out)\n",
    "        out = self.rmb2(out)\n",
    "        out = self.rmb3(out)\n",
    "        out = self.rmb4(out)\n",
    "\n",
    "        out = self.channel_avg(out)\n",
    "        out = self.flatten(out)\n",
    "        out = self.linear(out)\n",
    "\n",
    "        return out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 257,
     "status": "ok",
     "timestamp": 1706977673398,
     "user": {
      "displayName": "Paulo Rauber",
      "userId": "08697591328641962840"
     },
     "user_tz": 0
    },
    "id": "mVm8CigRpT5z",
    "outputId": "355a5611-d7a5-4f52-aaad-e0cb61fa5b43"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ResNet18(\n",
       "  (conv): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (relu): ReLU()\n",
       "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "  (rmb1): ResNetMacroblock(\n",
       "    (rb1): ResNetBlock(\n",
       "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu1): ReLU()\n",
       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu2): ReLU()\n",
       "    )\n",
       "    (rb2): ResNetBlock(\n",
       "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu1): ReLU()\n",
       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu2): ReLU()\n",
       "    )\n",
       "  )\n",
       "  (rmb2): ResNetMacroblock(\n",
       "    (rb1): ResNetBlock(\n",
       "      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu1): ReLU()\n",
       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2))\n",
       "      (relu2): ReLU()\n",
       "    )\n",
       "    (rb2): ResNetBlock(\n",
       "      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu1): ReLU()\n",
       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu2): ReLU()\n",
       "    )\n",
       "  )\n",
       "  (rmb3): ResNetMacroblock(\n",
       "    (rb1): ResNetBlock(\n",
       "      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu1): ReLU()\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2))\n",
       "      (relu2): ReLU()\n",
       "    )\n",
       "    (rb2): ResNetBlock(\n",
       "      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu1): ReLU()\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu2): ReLU()\n",
       "    )\n",
       "  )\n",
       "  (rmb4): ResNetMacroblock(\n",
       "    (rb1): ResNetBlock(\n",
       "      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu1): ReLU()\n",
       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2))\n",
       "      (relu2): ReLU()\n",
       "    )\n",
       "    (rb2): ResNetBlock(\n",
       "      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu1): ReLU()\n",
       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu2): ReLU()\n",
       "    )\n",
       "  )\n",
       "  (channel_avg): AdaptiveAvgPool2d(output_size=(1, 1))\n",
       "  (flatten): Flatten(start_dim=1, end_dim=-1)\n",
       "  (linear): Linear(in_features=512, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Applies Xavier initialization \n",
    "def init_weights(m):\n",
    "    if type(m) == torch.nn.Linear or type(m) == torch.nn.Conv2d:\n",
    "        torch.nn.init.xavier_uniform_(m.weight)\n",
    "\n",
    "# an instance of the ResNet18 model with 10 output classes and moving it to the device\n",
    "model = ResNet18(10).to(device) \n",
    "\n",
    "model.apply(init_weights) # Applies `init_weights` to every `torch.nn.Module` inside `model`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "I1bWZuTTpr0-"
   },
   "source": [
    "## Loss function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "N60NFd7Qpwzu"
   },
   "outputs": [],
   "source": [
    "# calculating loss with Cross Entropy Loss\n",
    "criterion = torch.nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EFGyPE1LpynB"
   },
   "source": [
    "## Optimization Algorithm\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "qXHtHHaCpz0f"
   },
   "outputs": [],
   "source": [
    "# Adam optimizer with learning rate 0.02\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.02)\n",
    "\n",
    "# Referenced from:\n",
    "# Das, K. (2020). CIFAR10 ResNet: 90+% accuracy;less than 5 min. Kaggle. Retrieved April 9, 2024, from\n",
    "# https://www.kaggle.com/code/kmldas/cifar10-resnet-90-accuracy-less-than-5-min"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning Rate Scheduler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# learning rate scheduler with OneCycleLR, starting lr=0.02, total epochs=30, and steps per epoch equal to the length of the trainloader\n",
    "scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=0.02, total_steps=30*len(trainloader))\n",
    "\n",
    "# Referenced from:\n",
    "# Das, K. (2020). CIFAR10 ResNet: 90+% accuracy;less than 5 min. Kaggle. Retrieved April 9, 2024, from\n",
    "# https://www.kaggle.com/code/kmldas/cifar10-resnet-90-accuracy-less-than-5-min"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training and Testing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "executionInfo": {
     "elapsed": 2224060,
     "status": "ok",
     "timestamp": 1706979958394,
     "user": {
      "displayName": "Paulo Rauber",
      "userId": "08697591328641962840"
     },
     "user_tz": 0
    },
    "id": "oSL5i_VSqUg4",
    "outputId": "90244ebc-a724-4b05-e580-f9651922bac3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.11/site-packages/torch/optim/lr_scheduler.py:136: UserWarning: Detected call of `lr_scheduler.step()` before `optimizer.step()`. In PyTorch 1.1.0 and later, you should call them in the opposite order: `optimizer.step()` before `lr_scheduler.step()`.  Failure to do this will result in PyTorch skipping the first value of the learning rate schedule. See more details at https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate\n",
      "  warnings.warn(\"Detected call of `lr_scheduler.step()` before `optimizer.step()`. \"\n",
      "/opt/conda/lib/python3.11/site-packages/torch/nn/modules/conv.py:456: UserWarning: Applied workaround for CuDNN issue, install nvrtc.so (Triggered internally at /opt/conda/conda-bld/pytorch_1702400440653/work/aten/src/ATen/native/cudnn/Conv_v8.cpp:80.)\n",
      "  return F.conv2d(input, weight, bias, self.stride,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy: 50.178\n",
      "Test Accuracy: 58.64\n",
      "Epoch 1\n",
      "Train Accuracy: 66.26\n",
      "Test Accuracy: 70.21\n",
      "Epoch 2\n",
      "Train Accuracy: 72.672\n",
      "Test Accuracy: 76.01\n",
      "Epoch 3\n",
      "Train Accuracy: 76.252\n",
      "Test Accuracy: 68.66\n",
      "Epoch 4\n",
      "Train Accuracy: 79.114\n",
      "Test Accuracy: 78.76\n",
      "Epoch 5\n",
      "Train Accuracy: 81.148\n",
      "Test Accuracy: 77.1\n",
      "Epoch 6\n",
      "Train Accuracy: 82.568\n",
      "Test Accuracy: 80.82\n",
      "Epoch 7\n",
      "Train Accuracy: 83.954\n",
      "Test Accuracy: 82.32\n",
      "Epoch 8\n",
      "Train Accuracy: 84.982\n",
      "Test Accuracy: 82.74\n",
      "Epoch 9\n",
      "Train Accuracy: 85.972\n",
      "Test Accuracy: 83.15\n",
      "Epoch 10\n",
      "Train Accuracy: 86.634\n",
      "Test Accuracy: 82.39\n",
      "Epoch 11\n",
      "Train Accuracy: 87.258\n",
      "Test Accuracy: 84.8\n",
      "Epoch 12\n",
      "Train Accuracy: 88.5\n",
      "Test Accuracy: 84.17\n",
      "Epoch 13\n",
      "Train Accuracy: 88.784\n",
      "Test Accuracy: 83.76\n",
      "Epoch 14\n",
      "Train Accuracy: 89.278\n",
      "Test Accuracy: 85.69\n",
      "Epoch 15\n",
      "Train Accuracy: 89.86\n",
      "Test Accuracy: 85.9\n",
      "Epoch 16\n",
      "Train Accuracy: 90.364\n",
      "Test Accuracy: 84.68\n",
      "Epoch 17\n",
      "Train Accuracy: 90.744\n",
      "Test Accuracy: 86.41\n",
      "Epoch 18\n",
      "Train Accuracy: 91.23\n",
      "Test Accuracy: 87.78\n",
      "Epoch 19\n",
      "Train Accuracy: 91.474\n",
      "Test Accuracy: 87.96\n",
      "Epoch 20\n",
      "Train Accuracy: 91.942\n",
      "Test Accuracy: 88.55\n",
      "Epoch 21\n",
      "Train Accuracy: 92.182\n",
      "Test Accuracy: 84.84\n",
      "Epoch 22\n",
      "Train Accuracy: 92.472\n",
      "Test Accuracy: 86.53\n",
      "Epoch 23\n",
      "Train Accuracy: 92.794\n",
      "Test Accuracy: 86.6\n",
      "Epoch 24\n",
      "Train Accuracy: 93.006\n",
      "Test Accuracy: 87.41\n",
      "Epoch 25\n",
      "Train Accuracy: 93.236\n",
      "Test Accuracy: 88.04\n",
      "Epoch 26\n",
      "Train Accuracy: 93.612\n",
      "Test Accuracy: 86.67\n",
      "Epoch 27\n",
      "Train Accuracy: 93.9\n",
      "Test Accuracy: 88.15\n",
      "Epoch 28\n",
      "Train Accuracy: 93.91\n",
      "Test Accuracy: 88.28\n",
      "Epoch 29\n",
      "Train Accuracy: 94.278\n",
      "Test Accuracy: 86.59\n",
      "Best Test Accuracy: 88.55% achieved at epoch 20\n"
     ]
    }
   ],
   "source": [
    "# Initializing variables \n",
    "train_correct_total = 0\n",
    "train_total_samples = 0\n",
    "test_correct_total = 0\n",
    "test_total_samples = 0\n",
    "train_losses = []  \n",
    "train_accuracies = []  \n",
    "test_accuracies = []  \n",
    "\n",
    "# Training the network\n",
    "def train(epoch):\n",
    "    global train_correct_total, train_total_samples\n",
    "    print(\"Epoch \" + str(epoch))\n",
    "    model.train()  # setting model to training mode\n",
    "    train_loss = 0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    for batch_idx, (inputs, targets) in enumerate(trainloader):\n",
    "        inputs, targets = inputs.to(device), targets.to(device)\n",
    "        optimizer.zero_grad()  \n",
    "        outputs = model(inputs)  \n",
    "        loss = criterion(outputs, targets) \n",
    "        loss.backward()  \n",
    "        optimizer.step()  \n",
    "\n",
    "        train_loss += loss.item()  \n",
    "        _, predicted = outputs.max(1) \n",
    "        total += targets.size(0)  \n",
    "        correct += predicted.eq(targets).sum().item()  \n",
    "    \n",
    "    # collecting correct predictions and total samples for training\n",
    "    train_correct_total += correct\n",
    "    train_total_samples += total\n",
    "    train_accuracy = 100.*correct/total  # calculating training accuracy\n",
    "    train_accuracies.append(train_accuracy)  \n",
    "    train_losses.append(train_loss / len(trainloader))  \n",
    "\n",
    "    print('Train Accuracy: ' +  str(train_accuracy))\n",
    "\n",
    "# Testing the network\n",
    "def test(epoch):\n",
    "    global best_acc, test_correct_total, test_total_samples\n",
    "    model.eval()  # setting model to evaluation mode\n",
    "    test_loss = 0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    with torch.no_grad():\n",
    "        for batch_idx, (inputs, targets) in enumerate(testloader):\n",
    "            inputs, targets = inputs.to(device), targets.to(device)\n",
    "            outputs = model(inputs) \n",
    "            loss = criterion(outputs, targets) \n",
    "\n",
    "            test_loss += loss.item() \n",
    "            _, predicted = outputs.max(1) \n",
    "            total += targets.size(0)  \n",
    "            correct += predicted.eq(targets).sum().item()  \n",
    "    \n",
    "    # collecting correct predictions and total samples for testing\n",
    "    test_correct_total += correct\n",
    "    test_total_samples += total\n",
    "    test_accuracy = 100.*correct/total  # calculating testing accuracy\n",
    "    test_accuracies.append(test_accuracy)  \n",
    "\n",
    "    print('Test Accuracy: ' +  str(test_accuracy))\n",
    "\n",
    "best_acc = 0\n",
    "best_epoch = 0\n",
    "start_epoch = 0\n",
    "num_epochs = 30\n",
    "\n",
    "for epoch in range(start_epoch, start_epoch+num_epochs):\n",
    "    scheduler.step()  # updating the learning rate scheduler\n",
    "    train(epoch)  # training model for one epoch\n",
    "    test(epoch)  # testing model on the testing dataset\n",
    "    \n",
    "    if test_accuracies[-1] > best_acc:\n",
    "        best_acc = test_accuracies[-1]\n",
    "        best_epoch = epoch\n",
    "        \n",
    "print(\"Best Test Accuracy: {:.2f}% achieved at epoch {}\".format(best_acc, best_epoch))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plotting loss for each training batch\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(train_losses, label='Training Loss')\n",
    "plt.xlabel('Training Batch')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Loss for Each Training Batch')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# plotting training and testing accuracy for each training epoch\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(range(start_epoch, num_epochs), train_accuracies, label='Training Accuracy')\n",
    "plt.plot(range(start_epoch, num_epochs), test_accuracies, label='Testing Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy (%)')\n",
    "plt.title('Training and Testing Accuracy for Each Epoch')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "celltoolbar": "Slideshow",
  "colab": {
   "gpuType": "T4",
   "provenance": []
  },
  "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}