final_resnet_train_vision.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a9bc9d86-0494-44aa-94c1-68504cc0ed02",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "# GPU info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "66a1d239-0981-47f2-924f-65a0f6f19ec7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sat Feb  8 18:19:13 2025       \n",
      "+-----------------------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 560.81                 Driver Version: 560.81         CUDA Version: 12.6     |\n",
      "|-----------------------------------------+------------------------+----------------------+\n",
      "| GPU  Name                  Driver-Model | Bus-Id          Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |\n",
      "|                                         |                        |               MIG M. |\n",
      "|=========================================+========================+======================|\n",
      "|   0  NVIDIA GeForce GTX 960M      WDDM  |   00000000:01:00.0 Off |                  N/A |\n",
      "| N/A    0C    P0             N/A /  200W |       0MiB /   4096MiB |      0%      Default |\n",
      "|                                         |                        |                  N/A |\n",
      "+-----------------------------------------+------------------------+----------------------+\n",
      "                                                                                         \n",
      "+-----------------------------------------------------------------------------------------+\n",
      "| Processes:                                                                              |\n",
      "|  GPU   GI   CI        PID   Type   Process name                              GPU Memory |\n",
      "|        ID   ID                                                               Usage      |\n",
      "|=========================================================================================|\n",
      "|  No running processes found                                                             |\n",
      "+-----------------------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "585d5e67-c88d-4182-b974-16f800ebb13b",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "# Import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e57acedf-1073-428c-820f-d37b61b24f4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader, Dataset, random_split\n",
    "from torch import Tensor\n",
    "from torch import optim\n",
    "\n",
    "import torchvision\n",
    "from torchvision import transforms as T\n",
    "from torchvision.utils import make_grid, save_image\n",
    "from torchvision import models\n",
    "\n",
    "from PIL import Image\n",
    "\n",
    "from scipy.io import loadmat\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import re\n",
    "from os import listdir\n",
    "\n",
    "from tqdm import tqdm\n",
    "from torchmetrics import Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "33b1b605-2d68-40fa-ac3a-3c8356e7053b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('2.5.1+cu124', '0.20.1+cu124')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.__version__, torchvision.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ec9ae3f-0aa5-4d93-89d7-6ac4981ff58f",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "# Device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9cc03400-5a0a-4311-9855-44f10622fbee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cuda'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "352bce4a-6307-4412-8121-11690275753e",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "# Utils, functions, and classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "543f6ce3-c511-4339-9886-529d95038977",
   "metadata": {},
   "outputs": [],
   "source": [
    "def num_params(model, trainable=False):\n",
    "    num = sum([p.numel() for p in model.parameters() if p.requires_grad])\n",
    "    print(f\"The number of parameters: {num:,}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5809fd12-c2f7-4ff3-a9dc-0bca059b9f79",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Averaging():\n",
    "    def __init__(self):\n",
    "        self.sum = 0.\n",
    "        self.counter = 0\n",
    "\n",
    "    def __call__(self, val: float) -> float:\n",
    "        self.sum += val\n",
    "        self.counter += 1\n",
    "\n",
    "        return self.sum / self.counter\n",
    "\n",
    "    def reset(self):\n",
    "        self.sum = 0.\n",
    "        self.counter = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "02d20f4f-d142-40f8-8554-9aecdb318b26",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_one_epoch(model, dataloader, optimizer, loss_fn, avg_fn, acc_fn, ep, device):\n",
    "    model.train()\n",
    "    \n",
    "    acc_fn.reset()\n",
    "    avg_fn.reset()\n",
    "    \n",
    "    with tqdm(dataloader, desc=f\"Epoch {ep}\", unit=\" batch\") as trange:\n",
    "       for x_batch, y_batch in trange:\n",
    "           x_batch, y_batch = x_batch.to(device), y_batch.to(device)\n",
    "\n",
    "           # Forward\n",
    "           yp = model(x_batch)\n",
    "           loss = loss_fn(yp, y_batch)\n",
    "           \n",
    "           # Backward\n",
    "           loss.backward()\n",
    "           optimizer.step()\n",
    "           optimizer.zero_grad()\n",
    "\n",
    "           loss_avg = avg_fn(loss.item())\n",
    "           acc_fn(yp, y_batch)\n",
    "           acc_avg = acc_fn.compute().item()\n",
    "\n",
    "           trange.set_postfix(loss=loss_avg, acc=100*acc_avg)\n",
    "    \n",
    "    return model, loss_avg, acc_avg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "baa4b40c-0509-4573-966a-bfd70f43c3d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def validate_one_epoch(model, dataloader, loss_fn, avg_fn, acc_fn, device):\n",
    "    model.eval()\n",
    "    \n",
    "    acc_fn.reset()\n",
    "    avg_fn.reset()\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for x_batch, y_batch in dataloader:\n",
    "            x_batch, y_batch = x_batch.to(device), y_batch.to(device)\n",
    "            \n",
    "            # Forward\n",
    "            yp = model(x_batch)\n",
    "            loss = loss_fn(yp, y_batch)\n",
    "            \n",
    "            loss_avg = avg_fn(loss.item())\n",
    "            acc_fn(yp, y_batch)\n",
    "            acc_avg = acc_fn.compute().item()\n",
    "        \n",
    "    return loss_avg, acc_avg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "749c44ea-e7d0-4a8e-a9a3-0c4eeca27a1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_loss_acc(train_loss, train_acc, valid_loss, valid_acc):\n",
    "    fig, axs = plt.subplots(nrows=1, ncols=2, figsize=(12, 4))\n",
    "\n",
    "    axs[0].plot(train_loss, c='b', label=\"Train Loss\")\n",
    "    axs[0].plot(valid_loss, c='r', label=\"Valid Loss\")\n",
    "    \n",
    "    axs[1].plot(train_acc, c='b', label=\"Valid Acc\")\n",
    "    axs[1].plot(valid_acc, c='r', label=\"Valid Acc\")\n",
    "\n",
    "    axs[0].set_ylabel(\"Cross Entropy Loss\")\n",
    "    axs[0].set_title(\"Learning Curve\")\n",
    "    axs[1].set_ylabel(\"Accuracy\")\n",
    "    axs[1].set_title(\"Accuracy Curve\")\n",
    "    \n",
    "    for ax in axs:\n",
    "        ax.set_xlabel(\"Epoch\")\n",
    "        ax.legend()\n",
    "        ax.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56507cb5-3714-4bb2-8545-6cb11f96897c",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "# Inits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e5c87dad-9b5a-460e-ade2-58a8cbcb2e55",
   "metadata": {},
   "outputs": [],
   "source": [
    "img_size = (224, 224)\n",
    "trans_mean, trans_std = (0.485, 0.456, 0.406), (0.229, 0.224, 0.225)\n",
    "valid_set_size = 0.2\n",
    "train_batch_size = 128\n",
    "valid_batch_size = 256\n",
    "subset_size = 0.3\n",
    "num_cls = 120\n",
    "\n",
    "lr = 0.01\n",
    "epochs = 15\n",
    "\n",
    "loss_fn = nn.CrossEntropyLoss()\n",
    "avg_fn = Averaging()\n",
    "acc_fn = Accuracy(task=\"multiclass\", num_classes=num_cls).to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfa7b9e8-1ea6-4ac3-9d0e-94d59209252f",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "# Preprocessing <a href=\"http://vision.stanford.edu/aditya86/ImageNetDogs/\">Download Dataset</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a34c73f2-dc37-42ac-83d2-9413c92654de",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Transforms for images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "751e3353-9613-4ba3-a937-ebb3078d7c68",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_transforms = T.Compose([T.RandAugment(), T.Resize(img_size), T.ToTensor(), T.Normalize(mean=trans_mean, std=trans_std)])\n",
    "test_transforms = T.Compose([T.Resize(img_size), T.ToTensor(), T.Normalize(mean=trans_mean, std=trans_std)])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2211e1e-f0e9-4a9a-a254-bb6c6ffdbf7f",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Custom dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c0417854-ce41-45b7-b0c6-f85f1829b5c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class StanfordDogsDataset(Dataset):\n",
    "    def __init__(self, transforms, phase=\"train\", root_path=r\"./dogs_dataset\"):\n",
    "        self.transforms = transforms\n",
    "        \n",
    "        images_root_path = f\"{root_path}/images/\"\n",
    "        \n",
    "        mat_file = loadmat(root_path+f\"/{phase}_list\")\n",
    "\n",
    "        self.file_list = mat_file[\"file_list\"]\n",
    "        self.labels = torch.LongTensor(mat_file[\"labels\"]).squeeze() - 1\n",
    "        \n",
    "        self.images = [(images_root_path+f[0][0], l.item()) for f, l in zip(self.file_list, self.labels)]\n",
    "\n",
    "        # unique samples\n",
    "        self.sample_ls = []\n",
    "        pattern = r'-(\\w+)'\n",
    "        for sample in listdir(\"./dogs_dataset/Annotation\"):\n",
    "            match = re.search(pattern, sample.lower())\n",
    "            if match:\n",
    "                self.sample_ls.append(match.group(1))\n",
    "\n",
    "    def __getitem__(self, item_idx: int):\n",
    "        img_path, label = self.images[item_idx]\n",
    "        img = Image.open(img_path).convert(\"RGB\")\n",
    "        img = self.transforms(img)\n",
    "        \n",
    "        return img, label\n",
    "\n",
    "    def get_sample_name(self, label: int):\n",
    "        return self.sample_ls[label]\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.images)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea1e7353-dd17-420b-a53f-ca53497c6ce4",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Read datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2661718c-a697-484e-8d63-c961a47eb1c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "main_train_set = StanfordDogsDataset(train_transforms)\n",
    "test_set = StanfordDogsDataset(test_transforms, \"test\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "559ba121-8403-4619-827e-d5fdd31c0276",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Split train and valid sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2a850e91-564d-4623-9b6c-c4a3fcda44ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set, valid_set = random_split(main_train_set, lengths=[1 - valid_set_size, valid_set_size])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "438ad1fc-f5cc-42dc-8551-4aa6fc4098ff",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Make dataloader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "73427acb-52b8-43b9-9b73-c378c620c49a",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = DataLoader(train_set, train_batch_size, shuffle=True)\n",
    "valid_loader = DataLoader(valid_set, valid_batch_size)\n",
    "test_loader = DataLoader(test_set, valid_batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de1de4f0-7d2d-4449-8f0c-5ed8425bc8ec",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Visialize a batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3238c6d3-915e-497e-b92d-4804574fbb55",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([128, 3, 224, 224]),\n",
       " tensor([100,  83,  72, 111,  29, 119,  98,   3,   3, 118,   6,  68,  56,  31,\n",
       "          97,  11,  94,  39, 107,  51,  12,  14,  32, 110,  46, 112,   5,  67,\n",
       "          40, 113,  31,   9,   3,  46,  25,  52, 116, 108,  31,  13,  87,  78,\n",
       "          69,  43,  43,  68,   7,  20,  18,  47, 116, 116,  31,  84,   0,  67,\n",
       "          64,  82, 102,  43,  63,  91,  18, 114,  24,  35,  63,  81,  13,  17,\n",
       "          12,  19,  43,  18,  78,   4,   2,  86,  79,  36,  34,  90,  66,  18,\n",
       "          56,  26,  15,  85,  10,  85,  83,  72,  99,  20,   8,  50,  33,  46,\n",
       "           0,  24, 119,  26,  45,   5,  50, 110,  61,  87,  50,  71,   4, 103,\n",
       "          15,  14, 103,   7, 119,  75,  83,  30, 104,  20,  57,  30, 112,  72,\n",
       "          27, 108]))"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y = next(iter(train_loader))\n",
    "\n",
    "x.shape, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4718b743-29a8-4bc9-91d3-8fc50471b02e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "img_grid = make_grid(x, nrow=32, padding=6, normalize=True).permute(1, 2, 0)\n",
    "\n",
    "plt.title(\"A batch images\")\n",
    "plt.imshow(img_grid);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82151b77-be79-4d6c-9548-4c27947395db",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "# Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1df65098-dfad-4c91-a0bc-63dfd38bef1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CustomResNet(nn.Module):\n",
    "    def __init__(self, model=models.resnet50, pretrained_weights=models.ResNet50_Weights.IMAGENET1K_V2, num_cls:int=120):\n",
    "        super(CustomResNet, self).__init__()\n",
    "\n",
    "        self.model = model(weights=pretrained_weights)\n",
    "        in_features = self.model.fc.in_features\n",
    "        self.num_cls = num_cls\n",
    "\n",
    "        # Remove the last two layers (AvgPool and FC) to just use the output Feature Map of the Body\n",
    "        self.model = nn.Sequential(*list(self.model.children())[:-2])\n",
    "\n",
    "        self.avg_pool = nn.AdaptiveAvgPool2d(output_size=(1, 1))\n",
    "        self.fc = nn.Linear(in_features=in_features, out_features=self.num_cls)\n",
    "\n",
    "        # Freeze the Body of the model for fine-tunning (Just train the output layer)\n",
    "        self.model.requires_grad_(False)\n",
    "    \n",
    "    def forward(self, x: Tensor):\n",
    "        y = self.model(x)\n",
    "        y = self.avg_pool(y)\n",
    "        y = self.fc(y.flatten(1))\n",
    "        \n",
    "        return y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed9ee2b9-cbc2-4edf-8c79-0a334ad0319b",
   "metadata": {},
   "source": [
    "# Check forward and backward"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6ec5fb80-d945-4b21-90eb-c3b80842a885",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Create a subset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c463c862-40fd-45de-a52f-7cdc026a0714",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### Mini train set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "711c7c30-cc2b-445f-a5a3-eb3477166972",
   "metadata": {},
   "outputs": [],
   "source": [
    "_, train_subset = random_split(train_set, lengths=[1 - subset_size, subset_size])\n",
    "mini_train_loader = DataLoader(train_subset, train_batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb275941-c349-4d11-8cde-fb0046960568",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### Mini valid set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "7b4fa6ba-6b5a-477d-b615-2fbde02bb39f",
   "metadata": {},
   "outputs": [],
   "source": [
    "_, valid_subset = random_split(valid_set, lengths=[1 - subset_size, subset_size])\n",
    "mini_valid_loader = DataLoader(valid_subset, valid_batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17d14b86-491c-4009-9423-88a83fe8e897",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Check forward path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "106d0bcd-6499-4d7f-b10e-1cea097fdef9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of parameters: 245,880\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4.785780429840088"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = CustomResNet().to(device)\n",
    "num_params(model)\n",
    "\n",
    "with torch.no_grad():\n",
    "    yp = model(x.to(device))\n",
    "    loss = loss_fn(yp, y.to(device))\n",
    "\n",
    "torch.cuda.empty_cache()\n",
    "\n",
    "loss.item()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea06b2d7-7f90-4279-af4b-ff5912628b4e",
   "metadata": {},
   "source": [
    "## Check backward path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "977bc8cf-c7f9-48c6-b619-7443720bde19",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 0: 100%|████████████████████████████████████████████████| 23/23 [01:25<00:00,  3.73s/ batch, acc=12.3, loss=4.63]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 40.1, loss: 4.35\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1: 100%|████████████████████████████████████████████████| 23/23 [00:59<00:00,  2.60s/ batch, acc=56.1, loss=3.97]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 55.3, loss: 3.72\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|████████████████████████████████████████████████| 23/23 [00:59<00:00,  2.59s/ batch, acc=68.1, loss=3.29]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 61.1, loss: 3.15\n"
     ]
    }
   ],
   "source": [
    "model = CustomResNet().to(device)\n",
    "optimizer = optim.SGD(params=model.parameters(), lr=lr, momentum=0.9)\n",
    "\n",
    "for ep in range(3):\n",
    "    model, _, _ = train_one_epoch(model, mini_train_loader, optimizer, loss_fn, avg_fn, acc_fn, ep, device)\n",
    "    valid_loss_val, valid_acc_val = validate_one_epoch(model, mini_valid_loader, loss_fn, avg_fn, acc_fn, device)\n",
    "    \n",
    "    print(f\"Valid acc: {100*valid_acc_val:.3}, loss: {valid_loss_val:.3}\")\n",
    "\n",
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed4765bc-17e2-4c22-99b8-af4b5daba23c",
   "metadata": {},
   "source": [
    "# Find efficient hyper-parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c08ca65d-4b4e-48a8-a938-f387ee80ad3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "lr: 0.001\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 0: 100%|████████████████████████████████████████████████| 75/75 [04:14<00:00,  3.39s/ batch, acc=4.96, loss=4.71]\n",
      "Epoch 1: 100%|████████████████████████████████████████████████| 75/75 [03:25<00:00,  2.74s/ batch, acc=30.2, loss=4.49]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "lr: 0.01\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 0: 100%|████████████████████████████████████████████████| 75/75 [03:18<00:00,  2.65s/ batch, acc=48.5, loss=3.98]\n",
      "Epoch 1: 100%|████████████████████████████████████████████████| 75/75 [03:18<00:00,  2.65s/ batch, acc=80.8, loss=2.26]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "lr: 0.02\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 0: 100%|██████████████████████████████████████████████████| 75/75 [03:19<00:00,  2.66s/ batch, acc=56, loss=3.31]\n",
      "Epoch 1: 100%|█████████████████████████████████████████████████| 75/75 [03:21<00:00,  2.69s/ batch, acc=84.2, loss=1.2]\n"
     ]
    }
   ],
   "source": [
    "for lr in [0.001, 0.01, 0.02]:\n",
    "    model = CustomResNet().to(device)\n",
    "    optimizer = optim.SGD(params=model.parameters(), lr=lr, momentum=0.9)\n",
    "\n",
    "    print(f\"\\nlr: {lr}\")\n",
    "    for ep in range(2):\n",
    "        model, _, _ = train_one_epoch(model, train_loader, optimizer, loss_fn, avg_fn, acc_fn, ep, device)\n",
    "\n",
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46fa8938-9102-4106-abd4-b33e5606153e",
   "metadata": {},
   "source": [
    "# Full train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "2ff015ca-ccaa-4f63-a18e-f8f1b14fde7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of parameters: 245,880\n"
     ]
    }
   ],
   "source": [
    "model = CustomResNet().to(device)\n",
    "optimizer = optim.SGD(params=model.parameters(), lr=0.02, momentum=0.9)\n",
    "\n",
    "num_params(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "3bac4bae-2d2c-4650-819e-b0f76f6acc1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loss_hist, valid_loss_hist, train_acc_hist, valid_acc_hist = [], [], [], []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7d955279-f6df-4e8b-92d3-89a7329e749b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 0: 100%|████████████████████████████████████████████████| 75/75 [03:18<00:00,  2.65s/ batch, acc=55.3, loss=3.32]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 81.0, loss: 1.83\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1: 100%|█████████████████████████████████████████████████| 75/75 [04:08<00:00,  3.32s/ batch, acc=84.3, loss=1.2]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 83.0, loss: 0.952\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|███████████████████████████████████████████████| 75/75 [03:42<00:00,  2.96s/ batch, acc=85.9, loss=0.762]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 84.3, loss: 0.75\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|███████████████████████████████████████████████| 75/75 [03:19<00:00,  2.66s/ batch, acc=87.7, loss=0.616]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 84.3, loss: 0.665\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|███████████████████████████████████████████████| 75/75 [03:19<00:00,  2.66s/ batch, acc=88.5, loss=0.546]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 84.3, loss: 0.625\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|███████████████████████████████████████████████| 75/75 [03:18<00:00,  2.65s/ batch, acc=89.6, loss=0.486]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 84.6, loss: 0.593\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|███████████████████████████████████████████████| 75/75 [03:19<00:00,  2.66s/ batch, acc=89.9, loss=0.454]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 84.6, loss: 0.577\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|███████████████████████████████████████████████| 75/75 [04:29<00:00,  3.59s/ batch, acc=90.5, loss=0.421]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 84.9, loss: 0.566\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|███████████████████████████████████████████████| 75/75 [03:18<00:00,  2.65s/ batch, acc=91.1, loss=0.405]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 85.9, loss: 0.534\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|███████████████████████████████████████████████| 75/75 [03:18<00:00,  2.64s/ batch, acc=91.3, loss=0.386]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 85.4, loss: 0.528\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|███████████████████████████████████████████████| 75/75 [03:18<00:00,  2.65s/ batch, acc=91.6, loss=0.37]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 84.8, loss: 0.544\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████████████████████████████████████████| 75/75 [03:18<00:00,  2.65s/ batch, acc=92.3, loss=0.344]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 85.8, loss: 0.522\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████████████████████████████████████████| 75/75 [03:18<00:00,  2.65s/ batch, acc=92.7, loss=0.329]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 84.9, loss: 0.524\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████████████████████████████████████████| 75/75 [03:19<00:00,  2.65s/ batch, acc=92.8, loss=0.316]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 85.1, loss: 0.533\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████████████████████████████████████████| 75/75 [03:18<00:00,  2.65s/ batch, acc=92.9, loss=0.311]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid acc: 85.5, loss: 0.528\n"
     ]
    }
   ],
   "source": [
    "best_acc = 0\n",
    "save_model = None\n",
    "\n",
    "for ep in range(epochs):\n",
    "    model, train_loss_val, train_acc_val = train_one_epoch(model, train_loader, optimizer, loss_fn, avg_fn, acc_fn, ep, device)\n",
    "    valid_loss_val, valid_acc_val = validate_one_epoch(model, valid_loader, loss_fn, avg_fn, acc_fn, device)\n",
    "\n",
    "    train_loss_hist.append(train_loss_val)\n",
    "    valid_loss_hist.append(valid_loss_val)\n",
    "    train_acc_hist.append(train_acc_val)\n",
    "    valid_acc_hist.append(valid_acc_val)\n",
    "\n",
    "    if valid_acc_val > best_acc:\n",
    "        save_model = model\n",
    "    \n",
    "    print(f\"Valid acc: {100*valid_acc_val:.3}, loss: {valid_loss_val:.3}\")\n",
    "\n",
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1369e24d-55ae-4a8e-ad57-ff60e5c516a5",
   "metadata": {},
   "source": [
    "# Plot loss and accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "d1fb17e5-db3b-44ef-a651-72e9bc2539c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_loss_acc(train_loss_hist, train_acc_hist, valid_loss_hist, valid_acc_hist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d7e1bdc-9869-4377-b976-4405713e6475",
   "metadata": {},
   "source": [
    "## Save the trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "a1cf1e78-12bb-49f6-a878-cd4ce675beda",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(save_model, f\"final_model.pt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6ffd225-fbe3-4f8b-b65c-4262666b61a3",
   "metadata": {},
   "source": [
    "# Final test and report"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e8dc0a1-d110-4da5-bd75-ef58b8a04764",
   "metadata": {},
   "source": [
    "## Load the trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "9bd6a962-2c88-4099-b37c-fc0604cfc4ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "final_model = torch.load(\"./final_model.pt\", weights_only=False).to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2223688-1cf7-4f69-8c90-38b2e0458c16",
   "metadata": {},
   "source": [
    "## Run and report the model on Testset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "51a8c043-4115-4e5c-bc7d-52ca6c7e701e",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss, acc = validate_one_epoch(final_model, test_loader, loss_fn, avg_fn, acc_fn, device)\n",
    "\n",
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "a5bfaf16-ba3f-419b-9d41-0ce8f853efbd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testset report on (8580) samples:\n",
      "\tCros Entropy Loss: 0.3806\n",
      "\tAccuracy: 88.76\n"
     ]
    }
   ],
   "source": [
    "print(f\"Testset report on ({len(test_set)}) samples:\\n\\tCros Entropy Loss: {loss:.4}\\n\\tAccuracy: {100*acc:.4}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d4aa40e-7377-40e1-985e-94b202c9f193",
   "metadata": {},
   "source": [
    "## Test your desiered image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "6f78aa8d-5892-4ce0-b21f-dd7f23201a4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The kind of dog is: rottweiler\n"
     ]
    }
   ],
   "source": [
    "test_img = Image.open(r\"./self_test_dogs_images/rottweiler-1-1.jpg\")\n",
    "\n",
    "res = final_model(test_transforms(test_img).unsqueeze(0).to(device))\n",
    "soft = torch.softmax(res, dim=1)\n",
    "res = torch.argmax(soft).item()\n",
    "res = test_set.get_sample_name(res)\n",
    "\n",
    "print(f\"The kind of dog is: {res}\")"
   ]
  }
 ],
 "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.12.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}