torch_transfer_learning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#---------------------------------------#\n",
    "# author : https://github.com/vidit1999 #\n",
    "#---------------------------------------#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "k9xkWBZK6Yt3"
   },
   "outputs": [],
   "source": [
    "import copy\n",
    "import time\n",
    "import warnings\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torchvision\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torchvision.transforms as T\n",
    "\n",
    "from google.colab import files\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision.datasets import CIFAR100\n",
    "from torchvision.models import resnet18\n",
    "from torchsummary import summary\n",
    "\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5IyYicrbaoZl",
    "outputId": "fffec32e-e118-4c2e-9e77-51c7b13dec58"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f980cf916f0>"
      ]
     },
     "execution_count": 2,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 10\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "mBkwe_etxi_Y"
   },
   "outputs": [],
   "source": [
    "resnet = resnet18(pretrained=True)\n",
    "resnet.fc = nn.Identity()\n",
    "\n",
    "for params in resnet.parameters():\n",
    "    params.requires_grad = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oyvIi5G1RX5T",
    "outputId": "75d0bf2e-f8f7-4a41-dfca-ee963ccb97df"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device : cuda\n",
      "GPU Count : 1\n"
     ]
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "\n",
    "device_count = torch.cuda.device_count()\n",
    "torch.backends.cudnn.benchmark = True\n",
    "\n",
    "normal_input_shape = (3, 32, 32)\n",
    "pre_trained_input_shape = (3, 224, 224)\n",
    "batch_size = 200\n",
    "epochs = 10\n",
    "normal_learning_rate = 0.001\n",
    "transfer_learning_rate = 0.001\n",
    "momentum = 0.9\n",
    "\n",
    "print(\"Device :\", device)\n",
    "print(\"GPU Count :\", device_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "kR13PbL_OY67"
   },
   "outputs": [],
   "source": [
    "def get_data_loaders(validation_split=0.1, model_type='normal'):\n",
    "    if model_type == 'pretrained':\n",
    "        mean=[0.485, 0.456, 0.406]\n",
    "        std=[0.229, 0.224, 0.225]\n",
    "    else:\n",
    "        mean = [0.5071, 0.4867, 0.4408]\n",
    "        std = [0.2675, 0.2565, 0.2761]\n",
    "    \n",
    "    transform =  T.Compose(\n",
    "        [\n",
    "            T.Resize(size=(224 if model_type == 'pretrained' else 32)),\n",
    "            T.ToTensor(),\n",
    "            T.Normalize(mean, std)\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    data_set = {}\n",
    "\n",
    "    data = CIFAR100(root=\"./data/train\",train=True, download=True, transform=transform)\n",
    "    data_set['test'] = CIFAR100(root=\"./data/test\", train=False, download=True, transform=transform)\n",
    "\n",
    "    val_len = int(len(data)*validation_split)\n",
    "\n",
    "    data_set['validation'], data_set['train'] = torch.utils.data.random_split(data, [val_len, len(data)-val_len])\n",
    "    \n",
    "    print()\n",
    "    print(\"Train data length\", len(data_set['train']))\n",
    "    print(\"Valiation data length\", len(data_set['validation']))\n",
    "    print(\"Test data length\", len(data_set['test']))\n",
    "    print()\n",
    "\n",
    "    data_loader = dict(\n",
    "        [\n",
    "        (k, DataLoader(dataset=v, batch_size=batch_size, shuffle=(k == 'train'), pin_memory=True, num_workers=4*device_count, drop_last=True))\n",
    "        for k, v in data_set.items() \n",
    "        ]\n",
    "    )\n",
    "    \n",
    "    return data_loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1UMsiCrYVKm9",
    "outputId": "79b8a326-424e-42ac-891c-57e240a88e62"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "\n",
      "Train data length 45000\n",
      "Valiation data length 5000\n",
      "Test data length 10000\n",
      "\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "\n",
      "Train data length 45000\n",
      "Valiation data length 5000\n",
      "Test data length 10000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# !rm -rf ./data\n",
    "\n",
    "normal_data_loader = get_data_loaders(validation_split=0.1, model_type='normal')\n",
    "transfered_data_loader = get_data_loaders(validation_split=0.1, model_type='pretrained')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "CdrKmWxJPFou"
   },
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self, pre_trained=None):\n",
    "        super(Net, self).__init__()\n",
    "\n",
    "        self.conv_layers = nn.Sequential(\n",
    "            nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.BatchNorm2d(num_features=16),\n",
    "            nn.MaxPool2d(2, 2),\n",
    "\n",
    "            nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.BatchNorm2d(num_features=32),\n",
    "            nn.MaxPool2d(2, 2),\n",
    "\n",
    "            nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.BatchNorm2d(num_features=64),\n",
    "            nn.MaxPool2d(2, 2),\n",
    "\n",
    "            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.BatchNorm2d(num_features=128),\n",
    "            nn.MaxPool2d(2, 2),\n",
    "            \n",
    "            nn.Conv2d(128, 512, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.BatchNorm2d(num_features=512),\n",
    "            nn.MaxPool2d(2, 2),\n",
    "\n",
    "            nn.Flatten(),\n",
    "        )\n",
    "        self.pre_trained = nn.Identity() if pre_trained == None else pre_trained\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(in_features=512, out_features=256),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(in_features=256, out_features=100),\n",
    "        )\n",
    "        \n",
    "\n",
    "    def forward(self, x):\n",
    "        if isinstance(self.pre_trained, nn.Identity):\n",
    "            x = self.conv_layers(x)\n",
    "        else:\n",
    "            x = self.pre_trained(x)\n",
    "        \n",
    "        x = self.fc(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bYffOdexanqd",
    "outputId": "41bb7a26-a451-47cd-b294-4a0efc7b06a7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normal Conv Net :\n",
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Conv2d-1          [200, 16, 32, 32]             448\n",
      "              ReLU-2          [200, 16, 32, 32]               0\n",
      "       BatchNorm2d-3          [200, 16, 32, 32]              32\n",
      "         MaxPool2d-4          [200, 16, 16, 16]               0\n",
      "            Conv2d-5          [200, 32, 16, 16]           4,640\n",
      "              ReLU-6          [200, 32, 16, 16]               0\n",
      "       BatchNorm2d-7          [200, 32, 16, 16]              64\n",
      "         MaxPool2d-8            [200, 32, 8, 8]               0\n",
      "            Conv2d-9            [200, 64, 8, 8]          18,496\n",
      "             ReLU-10            [200, 64, 8, 8]               0\n",
      "      BatchNorm2d-11            [200, 64, 8, 8]             128\n",
      "        MaxPool2d-12            [200, 64, 4, 4]               0\n",
      "           Conv2d-13           [200, 128, 4, 4]          73,856\n",
      "             ReLU-14           [200, 128, 4, 4]               0\n",
      "      BatchNorm2d-15           [200, 128, 4, 4]             256\n",
      "        MaxPool2d-16           [200, 128, 2, 2]               0\n",
      "           Conv2d-17           [200, 512, 2, 2]         590,336\n",
      "             ReLU-18           [200, 512, 2, 2]               0\n",
      "      BatchNorm2d-19           [200, 512, 2, 2]           1,024\n",
      "        MaxPool2d-20           [200, 512, 1, 1]               0\n",
      "          Flatten-21                 [200, 512]               0\n",
      "           Linear-22                 [200, 256]         131,328\n",
      "             ReLU-23                 [200, 256]               0\n",
      "           Linear-24                 [200, 100]          25,700\n",
      "================================================================\n",
      "Total params: 846,308\n",
      "Trainable params: 846,308\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 2.34\n",
      "Forward/backward pass size (MB): 164.22\n",
      "Params size (MB): 3.23\n",
      "Estimated Total Size (MB): 169.79\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "net = Net().to(device)\n",
    "print(\"Normal Conv Net :\")\n",
    "summary(model=net, input_size=normal_input_shape, batch_size=batch_size, device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9dBGJpJOeyj6",
    "outputId": "7b9647b6-8f4a-4089-ea62-a062e4641b5a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ResNet Transfer Net :\n",
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Conv2d-1        [200, 64, 112, 112]           9,408\n",
      "       BatchNorm2d-2        [200, 64, 112, 112]             128\n",
      "              ReLU-3        [200, 64, 112, 112]               0\n",
      "         MaxPool2d-4          [200, 64, 56, 56]               0\n",
      "            Conv2d-5          [200, 64, 56, 56]          36,864\n",
      "       BatchNorm2d-6          [200, 64, 56, 56]             128\n",
      "              ReLU-7          [200, 64, 56, 56]               0\n",
      "            Conv2d-8          [200, 64, 56, 56]          36,864\n",
      "       BatchNorm2d-9          [200, 64, 56, 56]             128\n",
      "             ReLU-10          [200, 64, 56, 56]               0\n",
      "       BasicBlock-11          [200, 64, 56, 56]               0\n",
      "           Conv2d-12          [200, 64, 56, 56]          36,864\n",
      "      BatchNorm2d-13          [200, 64, 56, 56]             128\n",
      "             ReLU-14          [200, 64, 56, 56]               0\n",
      "           Conv2d-15          [200, 64, 56, 56]          36,864\n",
      "      BatchNorm2d-16          [200, 64, 56, 56]             128\n",
      "             ReLU-17          [200, 64, 56, 56]               0\n",
      "       BasicBlock-18          [200, 64, 56, 56]               0\n",
      "           Conv2d-19         [200, 128, 28, 28]          73,728\n",
      "      BatchNorm2d-20         [200, 128, 28, 28]             256\n",
      "             ReLU-21         [200, 128, 28, 28]               0\n",
      "           Conv2d-22         [200, 128, 28, 28]         147,456\n",
      "      BatchNorm2d-23         [200, 128, 28, 28]             256\n",
      "           Conv2d-24         [200, 128, 28, 28]           8,192\n",
      "      BatchNorm2d-25         [200, 128, 28, 28]             256\n",
      "             ReLU-26         [200, 128, 28, 28]               0\n",
      "       BasicBlock-27         [200, 128, 28, 28]               0\n",
      "           Conv2d-28         [200, 128, 28, 28]         147,456\n",
      "      BatchNorm2d-29         [200, 128, 28, 28]             256\n",
      "             ReLU-30         [200, 128, 28, 28]               0\n",
      "           Conv2d-31         [200, 128, 28, 28]         147,456\n",
      "      BatchNorm2d-32         [200, 128, 28, 28]             256\n",
      "             ReLU-33         [200, 128, 28, 28]               0\n",
      "       BasicBlock-34         [200, 128, 28, 28]               0\n",
      "           Conv2d-35         [200, 256, 14, 14]         294,912\n",
      "      BatchNorm2d-36         [200, 256, 14, 14]             512\n",
      "             ReLU-37         [200, 256, 14, 14]               0\n",
      "           Conv2d-38         [200, 256, 14, 14]         589,824\n",
      "      BatchNorm2d-39         [200, 256, 14, 14]             512\n",
      "           Conv2d-40         [200, 256, 14, 14]          32,768\n",
      "      BatchNorm2d-41         [200, 256, 14, 14]             512\n",
      "             ReLU-42         [200, 256, 14, 14]               0\n",
      "       BasicBlock-43         [200, 256, 14, 14]               0\n",
      "           Conv2d-44         [200, 256, 14, 14]         589,824\n",
      "      BatchNorm2d-45         [200, 256, 14, 14]             512\n",
      "             ReLU-46         [200, 256, 14, 14]               0\n",
      "           Conv2d-47         [200, 256, 14, 14]         589,824\n",
      "      BatchNorm2d-48         [200, 256, 14, 14]             512\n",
      "             ReLU-49         [200, 256, 14, 14]               0\n",
      "       BasicBlock-50         [200, 256, 14, 14]               0\n",
      "           Conv2d-51           [200, 512, 7, 7]       1,179,648\n",
      "      BatchNorm2d-52           [200, 512, 7, 7]           1,024\n",
      "             ReLU-53           [200, 512, 7, 7]               0\n",
      "           Conv2d-54           [200, 512, 7, 7]       2,359,296\n",
      "      BatchNorm2d-55           [200, 512, 7, 7]           1,024\n",
      "           Conv2d-56           [200, 512, 7, 7]         131,072\n",
      "      BatchNorm2d-57           [200, 512, 7, 7]           1,024\n",
      "             ReLU-58           [200, 512, 7, 7]               0\n",
      "       BasicBlock-59           [200, 512, 7, 7]               0\n",
      "           Conv2d-60           [200, 512, 7, 7]       2,359,296\n",
      "      BatchNorm2d-61           [200, 512, 7, 7]           1,024\n",
      "             ReLU-62           [200, 512, 7, 7]               0\n",
      "           Conv2d-63           [200, 512, 7, 7]       2,359,296\n",
      "      BatchNorm2d-64           [200, 512, 7, 7]           1,024\n",
      "             ReLU-65           [200, 512, 7, 7]               0\n",
      "       BasicBlock-66           [200, 512, 7, 7]               0\n",
      "AdaptiveAvgPool2d-67           [200, 512, 1, 1]               0\n",
      "         Identity-68                 [200, 512]               0\n",
      "           ResNet-69                 [200, 512]               0\n",
      "           Linear-70                 [200, 256]         131,328\n",
      "             ReLU-71                 [200, 256]               0\n",
      "           Linear-72                 [200, 100]          25,700\n",
      "================================================================\n",
      "Total params: 11,333,540\n",
      "Trainable params: 157,028\n",
      "Non-trainable params: 11,176,512\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 114.84\n",
      "Forward/backward pass size (MB): 12559.53\n",
      "Params size (MB): 43.23\n",
      "Estimated Total Size (MB): 12717.61\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "transfer_net = Net(pre_trained=resnet).to(device)\n",
    "print(\"ResNet Transfer Net :\")\n",
    "summary(model=transfer_net, input_size=pre_trained_input_shape, batch_size=batch_size, device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "xFlgOfF5u7HY"
   },
   "outputs": [],
   "source": [
    "def model_train(model, criterion, optimizer, data_loader, epochs,\n",
    "                epochs_to_watch = -1, accuracy_min_diff = 0.001, max_val_acc_needed = None):\n",
    "    history = {\n",
    "        'epochs' : 0,\n",
    "        'train' : {\n",
    "            'losses' : [],\n",
    "            'accuracies' : [],\n",
    "            'total_loss' : 0,\n",
    "            'total_acc' : 0\n",
    "        },\n",
    "        'validation' : {\n",
    "            'losses' : [],\n",
    "            'accuracies' : [],\n",
    "            'total_loss' : 0,\n",
    "            'total_acc' : 0\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    best_state_dict = copy.deepcopy(model.state_dict())\n",
    "    best_val_acc = -float('inf')\n",
    "    epochs_no_improve = 0\n",
    "    width = len(str(epochs))\n",
    "\n",
    "    train_start = time.time()\n",
    "    # =============================================\n",
    "\n",
    "    for e in range(1, epochs+1):\n",
    "        try:\n",
    "            epoch_start = time.time()\n",
    "            total_loss = 0\n",
    "            total_acc = 0\n",
    "            \n",
    "            print(f\"Epoch[{e:0{width}}/{epochs}] :: \", end=\"\")\n",
    "            # ===============================================\n",
    "            for phase in ['train', 'validation']:\n",
    "\n",
    "                loader = data_loader[phase]\n",
    "\n",
    "                model.train(phase == 'train')\n",
    "                with torch.set_grad_enabled(phase == 'train'):\n",
    "                    for images, labels in loader:\n",
    "                        # shift data to device\n",
    "                        images, labels =  images.to(device), labels.to(device)\n",
    "                        \n",
    "                        # clear gradients\n",
    "                        optimizer.zero_grad()\n",
    "\n",
    "                        # get the output and calculate loss\n",
    "                        output = model(images)\n",
    "                        loss = criterion(output, labels)\n",
    "\n",
    "                        if phase == 'train':\n",
    "                            # adjust the variables\n",
    "                            loss.backward()\n",
    "                            optimizer.step()\n",
    "\n",
    "                        # calculate accuracy and add to total accuracy\n",
    "                        _ , pred = torch.max(output.data, 1)\n",
    "                        history[phase]['total_acc'] += (labels == pred).sum().item()\n",
    "\n",
    "                        # add loss\n",
    "                        history[phase]['total_loss'] += (loss.item() * loader.batch_size)\n",
    "            \n",
    "                    # calculate average loss and accuracy\n",
    "                    history[phase]['total_loss'] /= len(loader.dataset)\n",
    "                    history[phase]['total_acc']  /= len(loader.dataset)\n",
    "\n",
    "                    # append losses and accuracies\n",
    "                    history[phase]['losses'].append(history[phase]['total_loss'])\n",
    "                    history[phase]['accuracies'].append(history[phase]['total_acc'])\n",
    "\n",
    "            # ===============================================\n",
    "            \n",
    "            epoch_end = time.time()\n",
    "            \n",
    "            history['epochs'] += 1\n",
    "\n",
    "            print(\n",
    "                f\"Train (Loss = {history['train']['total_loss'] : .4f}, Acc = {history['train']['total_acc'] : .4f}), \"\n",
    "                f\"Validation (Loss = {history['validation']['total_loss'] : .4f}, Acc = {history['validation']['total_acc'] : .4f}), \"\n",
    "                f\"Epoch Time = {epoch_end - epoch_start : .2f}s, Total Time = {epoch_end - train_start : .2f}s\"\n",
    "            )\n",
    "\n",
    "            if best_val_acc < history['validation']['total_acc']:\n",
    "                best_state_dict = copy.deepcopy(model.state_dict())\n",
    "            \n",
    "            if history['validation']['total_acc'] - best_val_acc >= accuracy_min_diff:\n",
    "                epochs_no_improve = 0\n",
    "            else:\n",
    "                epochs_no_improve += 1\n",
    "                if epochs_no_improve == epochs_to_watch:\n",
    "                    print(f\"No validation accuracy improvement for {epochs_to_watch} epochs. Early Stopping!!\")\n",
    "                    break\n",
    "            \n",
    "            best_val_acc = max(best_val_acc, history['validation']['total_acc'])\n",
    "\n",
    "            if max_val_acc_needed != None and best_val_acc >= max_val_acc_needed:\n",
    "                print(f\"Validation Accuracy : {best_val_acc}, Specified maximum accuracy achieved. Stopping!!\")\n",
    "                break\n",
    "            \n",
    "        except KeyboardInterrupt:\n",
    "            print(\"Keyboard interrupt occured. Stopping!!\")\n",
    "            break\n",
    "\n",
    "    # =============================================\n",
    "    train_end = time.time()\n",
    "\n",
    "    print(f\"\\nTotal Training Time : {train_end - train_start : .2f}s\")\n",
    "\n",
    "    # get best model\n",
    "    model.load_state_dict(best_state_dict)\n",
    "\n",
    "    # remove unnecessary keys\n",
    "    for phase in ['train', 'validation']:\n",
    "        history[phase].pop('total_loss', None)\n",
    "        history[phase].pop('total_acc', None)\n",
    "    \n",
    "    return model, history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "tfVCBW2V0Sb2"
   },
   "outputs": [],
   "source": [
    "def model_test(model, criterion, test_loader):\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        total_test_acc = 0\n",
    "        total_test_loss = 0\n",
    "        \n",
    "        test_start = time.time()\n",
    "\n",
    "        for images, labels in test_loader:\n",
    "            # shift data to device\n",
    "            images, labels = images.to(device), labels.to(device)\n",
    "\n",
    "            # get the output and loss\n",
    "            output = model(images)\n",
    "            loss = criterion(output, labels)\n",
    "\n",
    "            # calculate test accuracy and loss\n",
    "            _ , pred = torch.max(output.data, 1)\n",
    "            total_test_acc += (labels == pred).sum().item()\n",
    "            total_test_loss += (loss.item() * test_loader.batch_size)\n",
    "        \n",
    "        test_end = time.time()\n",
    "\n",
    "        print(f\"Test time : {test_end - test_start : .2f}s\")\n",
    "        print(f\"Test Loss : {total_test_loss/len(test_loader.dataset) : .4f}\")\n",
    "        print(f\"Test Accuracy : {total_test_acc/len(test_loader.dataset) : .4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "cFB3Oh57h1yU"
   },
   "outputs": [],
   "source": [
    "def plot_history(history, suptitle):\n",
    "    fig, (loss_ax, acc_ax) = plt.subplots(1, 2, figsize=(20,5))\n",
    "\n",
    "    fig.suptitle(suptitle)\n",
    "\n",
    "    loss_ax.plot(range(1, history['epochs']+1), history['train']['losses'], label=\"Training Loss\", marker='x')\n",
    "    loss_ax.plot(range(1, history['epochs']+1), history['validation']['losses'], label=\"Validation Loss\", marker='x')\n",
    "    loss_ax.set_title(\"Training and Validation Losses\")\n",
    "    loss_ax.set_xlabel(\"Epochs\")\n",
    "    loss_ax.set_ylabel(\"Losses\")\n",
    "    loss_ax.legend()\n",
    "\n",
    "    acc_ax.plot(range(1, history['epochs']+1), history['train']['accuracies'], label=\"Training Acc\", marker='x')\n",
    "    acc_ax.plot(range(1, history['epochs']+1), history['validation']['accuracies'], label=\"Validation Acc\", marker='x')\n",
    "    acc_ax.set_title(\"Training and Validation Accuracies\")\n",
    "    acc_ax.set_xlabel(\"Epochs\")\n",
    "    acc_ax.set_ylabel(\"Accuracies\")\n",
    "    acc_ax.legend()\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "JXvDntZcollX"
   },
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss().to(device)\n",
    "normal_optimizer = optim.SGD(net.parameters(), lr=normal_learning_rate, momentum=momentum)\n",
    "transfer_optimizer = optim.SGD(transfer_net.parameters(), lr=transfer_learning_rate, momentum=momentum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hm7YIu8mjsoz",
    "outputId": "c8deab46-bbef-4b4f-80e2-f1db0ae69db0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch[01/10] :: Train (Loss =  4.2781, Acc =  0.0724), Validation (Loss =  3.9562, Acc =  0.1170), Epoch Time =  8.94s, Total Time =  8.94s\n",
      "Epoch[02/10] :: Train (Loss =  3.7079, Acc =  0.1542), Validation (Loss =  3.5504, Acc =  0.1794), Epoch Time =  9.00s, Total Time =  17.94s\n",
      "Epoch[03/10] :: Train (Loss =  3.3497, Acc =  0.2104), Validation (Loss =  3.2719, Acc =  0.2166), Epoch Time =  9.05s, Total Time =  27.00s\n",
      "Epoch[04/10] :: Train (Loss =  3.0638, Acc =  0.2590), Validation (Loss =  3.0597, Acc =  0.2520), Epoch Time =  8.96s, Total Time =  35.96s\n",
      "Epoch[05/10] :: Train (Loss =  2.8293, Acc =  0.3017), Validation (Loss =  2.9051, Acc =  0.2799), Epoch Time =  9.00s, Total Time =  44.96s\n",
      "Epoch[06/10] :: Train (Loss =  2.6250, Acc =  0.3422), Validation (Loss =  2.7746, Acc =  0.3047), Epoch Time =  9.04s, Total Time =  54.00s\n",
      "Epoch[07/10] :: Train (Loss =  2.4493, Acc =  0.3777), Validation (Loss =  2.6862, Acc =  0.3139), Epoch Time =  8.83s, Total Time =  62.83s\n",
      "Epoch[08/10] :: Train (Loss =  2.2860, Acc =  0.4148), Validation (Loss =  2.6167, Acc =  0.3373), Epoch Time =  8.89s, Total Time =  71.72s\n",
      "Epoch[09/10] :: Train (Loss =  2.1426, Acc =  0.4456), Validation (Loss =  2.5515, Acc =  0.3507), Epoch Time =  8.98s, Total Time =  80.70s\n",
      "Epoch[10/10] :: Train (Loss =  2.0009, Acc =  0.4813), Validation (Loss =  2.5038, Acc =  0.3629), Epoch Time =  9.12s, Total Time =  89.83s\n",
      "\n",
      "Total Training Time :  89.83s\n"
     ]
    }
   ],
   "source": [
    "best_normal_model, normal_model_history = model_train(\n",
    "    model=net, criterion=criterion,\n",
    "    optimizer=normal_optimizer, data_loader=normal_data_loader,\n",
    "    epochs=epochs\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "LoeAbgeDnv0f",
    "outputId": "d615e5dc-7e68-40f1-ec7b-4041c4452709"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch[01/10] :: Train (Loss =  4.5452, Acc =  0.0334), Validation (Loss =  4.4446, Acc =  0.0702), Epoch Time =  74.49s, Total Time =  74.49s\n",
      "Epoch[02/10] :: Train (Loss =  4.3100, Acc =  0.1293), Validation (Loss =  4.1495, Acc =  0.1946), Epoch Time =  74.38s, Total Time =  148.88s\n",
      "Epoch[03/10] :: Train (Loss =  3.9483, Acc =  0.2306), Validation (Loss =  3.7324, Acc =  0.2838), Epoch Time =  74.34s, Total Time =  223.23s\n",
      "Epoch[04/10] :: Train (Loss =  3.5087, Acc =  0.3018), Validation (Loss =  3.3015, Acc =  0.3239), Epoch Time =  74.46s, Total Time =  297.70s\n",
      "Epoch[05/10] :: Train (Loss =  3.1095, Acc =  0.3537), Validation (Loss =  2.9502, Acc =  0.3749), Epoch Time =  74.64s, Total Time =  372.35s\n",
      "Epoch[06/10] :: Train (Loss =  2.7987, Acc =  0.3932), Validation (Loss =  2.6908, Acc =  0.4123), Epoch Time =  74.46s, Total Time =  446.82s\n",
      "Epoch[07/10] :: Train (Loss =  2.5651, Acc =  0.4206), Validation (Loss =  2.4957, Acc =  0.4275), Epoch Time =  74.42s, Total Time =  521.24s\n",
      "Epoch[08/10] :: Train (Loss =  2.3893, Acc =  0.4433), Validation (Loss =  2.3382, Acc =  0.4483), Epoch Time =  74.83s, Total Time =  596.08s\n",
      "Epoch[09/10] :: Train (Loss =  2.2506, Acc =  0.4582), Validation (Loss =  2.2203, Acc =  0.4643), Epoch Time =  74.90s, Total Time =  670.99s\n",
      "Epoch[10/10] :: Train (Loss =  2.1418, Acc =  0.4744), Validation (Loss =  2.1291, Acc =  0.4737), Epoch Time =  74.72s, Total Time =  745.73s\n",
      "\n",
      "Total Training Time :  745.74s\n"
     ]
    }
   ],
   "source": [
    "best_transfer_model, transfer_model_history = model_train(\n",
    "    model=transfer_net, criterion=criterion,\n",
    "    optimizer=transfer_optimizer, data_loader=transfered_data_loader,\n",
    "    epochs=epochs\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 370
    },
    "id": "nMVQ6Nnijqu_",
    "outputId": "c2cf5ed9-94d4-4400-cf08-c999305e5b68"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_history(normal_model_history, \"Normal CNN Model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 370
    },
    "id": "oVsuJY14j_Uf",
    "outputId": "d23afaf5-ad4d-4deb-89c7-e66d56891859"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_history(transfer_model_history, \"ResNet Pretrained Transfered Model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1YKDsdpPn0sP",
    "outputId": "2417489e-5998-418b-b742-fd8b0ef22c1f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test time :  1.79s\n",
      "Test Loss :  2.5027\n",
      "Test Accuracy :  0.3611\n"
     ]
    }
   ],
   "source": [
    "model_test(model=best_normal_model, criterion=criterion, test_loader=normal_data_loader['test'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "vJAmlXLTkXhU",
    "outputId": "a26b9a22-48c8-4eca-8d47-231d668d6b28"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test time :  15.41s\n",
      "Test Loss :  2.1266\n",
      "Test Accuracy :  0.4734\n"
     ]
    }
   ],
   "source": [
    "model_test(model=best_transfer_model, criterion=criterion, test_loader=transfered_data_loader['test'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oTjDz1TX5bea",
    "outputId": "63769920-654f-408f-d081-5e1445f609b6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New Conv Net :\n",
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Conv2d-1          [200, 16, 32, 32]             448\n",
      "              ReLU-2          [200, 16, 32, 32]               0\n",
      "       BatchNorm2d-3          [200, 16, 32, 32]              32\n",
      "         MaxPool2d-4          [200, 16, 16, 16]               0\n",
      "            Conv2d-5          [200, 32, 16, 16]           4,640\n",
      "              ReLU-6          [200, 32, 16, 16]               0\n",
      "       BatchNorm2d-7          [200, 32, 16, 16]              64\n",
      "         MaxPool2d-8            [200, 32, 8, 8]               0\n",
      "            Conv2d-9            [200, 64, 8, 8]          18,496\n",
      "             ReLU-10            [200, 64, 8, 8]               0\n",
      "      BatchNorm2d-11            [200, 64, 8, 8]             128\n",
      "        MaxPool2d-12            [200, 64, 4, 4]               0\n",
      "           Conv2d-13           [200, 128, 4, 4]          73,856\n",
      "             ReLU-14           [200, 128, 4, 4]               0\n",
      "      BatchNorm2d-15           [200, 128, 4, 4]             256\n",
      "        MaxPool2d-16           [200, 128, 2, 2]               0\n",
      "           Conv2d-17           [200, 512, 2, 2]         590,336\n",
      "             ReLU-18           [200, 512, 2, 2]               0\n",
      "      BatchNorm2d-19           [200, 512, 2, 2]           1,024\n",
      "        MaxPool2d-20           [200, 512, 1, 1]               0\n",
      "          Flatten-21                 [200, 512]               0\n",
      "           Linear-22                 [200, 256]         131,328\n",
      "             ReLU-23                 [200, 256]               0\n",
      "           Linear-24                 [200, 100]          25,700\n",
      "================================================================\n",
      "Total params: 846,308\n",
      "Trainable params: 846,308\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 2.34\n",
      "Forward/backward pass size (MB): 164.22\n",
      "Params size (MB): 3.23\n",
      "Estimated Total Size (MB): 169.79\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "_net = Net().to(device)\n",
    "_normal_optimizer = optim.SGD(_net.parameters(), lr=normal_learning_rate, momentum=momentum)\n",
    "\n",
    "print(\"New Conv Net :\")\n",
    "summary(model=_net, input_size=normal_input_shape, batch_size=batch_size, device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "BAN16XZC1C8S",
    "outputId": "921efb48-07ea-493a-93ec-9a43f70c4d5c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch[001/100] :: Train (Loss =  4.3198, Acc =  0.0679), Validation (Loss =  4.0060, Acc =  0.1204), Epoch Time =  8.89s, Total Time =  8.89s\n",
      "Epoch[002/100] :: Train (Loss =  3.7274, Acc =  0.1523), Validation (Loss =  3.5702, Acc =  0.1730), Epoch Time =  8.85s, Total Time =  17.74s\n",
      "Epoch[003/100] :: Train (Loss =  3.3492, Acc =  0.2089), Validation (Loss =  3.3095, Acc =  0.2116), Epoch Time =  8.82s, Total Time =  26.57s\n",
      "Epoch[004/100] :: Train (Loss =  3.0824, Acc =  0.2570), Validation (Loss =  3.1375, Acc =  0.2432), Epoch Time =  8.74s, Total Time =  35.31s\n",
      "Epoch[005/100] :: Train (Loss =  2.8661, Acc =  0.2968), Validation (Loss =  2.9573, Acc =  0.2764), Epoch Time =  8.81s, Total Time =  44.12s\n",
      "Epoch[006/100] :: Train (Loss =  2.6699, Acc =  0.3345), Validation (Loss =  2.8340, Acc =  0.2945), Epoch Time =  8.96s, Total Time =  53.08s\n",
      "Epoch[007/100] :: Train (Loss =  2.4893, Acc =  0.3722), Validation (Loss =  2.7427, Acc =  0.3165), Epoch Time =  8.82s, Total Time =  61.90s\n",
      "Epoch[008/100] :: Train (Loss =  2.3215, Acc =  0.4061), Validation (Loss =  2.6619, Acc =  0.3295), Epoch Time =  8.86s, Total Time =  70.77s\n",
      "Epoch[009/100] :: Train (Loss =  2.1687, Acc =  0.4441), Validation (Loss =  2.6332, Acc =  0.3429), Epoch Time =  8.73s, Total Time =  79.50s\n",
      "Epoch[010/100] :: Train (Loss =  2.0283, Acc =  0.4775), Validation (Loss =  2.6115, Acc =  0.3483), Epoch Time =  8.91s, Total Time =  88.41s\n",
      "Epoch[011/100] :: Train (Loss =  1.8864, Acc =  0.5101), Validation (Loss =  2.5645, Acc =  0.3591), Epoch Time =  8.82s, Total Time =  97.23s\n",
      "Epoch[012/100] :: Train (Loss =  1.7527, Acc =  0.5425), Validation (Loss =  2.5498, Acc =  0.3641), Epoch Time =  8.81s, Total Time =  106.05s\n",
      "Epoch[013/100] :: Train (Loss =  1.6186, Acc =  0.5815), Validation (Loss =  2.5646, Acc =  0.3635), Epoch Time =  8.78s, Total Time =  114.83s\n",
      "Epoch[014/100] :: Train (Loss =  1.4921, Acc =  0.6121), Validation (Loss =  2.5641, Acc =  0.3609), Epoch Time =  8.79s, Total Time =  123.63s\n",
      "Epoch[015/100] :: Train (Loss =  1.3543, Acc =  0.6489), Validation (Loss =  2.5891, Acc =  0.3625), Epoch Time =  8.86s, Total Time =  132.48s\n",
      "Epoch[016/100] :: Train (Loss =  1.2284, Acc =  0.6848), Validation (Loss =  2.6323, Acc =  0.3649), Epoch Time =  8.81s, Total Time =  141.29s\n",
      "Epoch[017/100] :: Train (Loss =  1.1001, Acc =  0.7227), Validation (Loss =  2.6721, Acc =  0.3629), Epoch Time =  8.84s, Total Time =  150.13s\n",
      "No validation accuracy improvement for 5 epochs. Early Stopping!!\n",
      "\n",
      "Total Training Time :  150.13s\n"
     ]
    }
   ],
   "source": [
    "_best_normal_model, _normal_model_history = model_train(\n",
    "    model=_net, criterion=criterion,\n",
    "    optimizer=_normal_optimizer, data_loader=normal_data_loader,\n",
    "    epochs=100, epochs_to_watch=5, accuracy_min_diff = 0.001,\n",
    "    max_val_acc_needed=max(transfer_model_history['validation']['accuracies'])\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 370
    },
    "id": "rUrxUueF47HO",
    "outputId": "ef8db7d2-2511-4f6c-b5f6-5765941045ed"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_history(_normal_model_history, \"Normal CNN Model Second\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "g2FjT-o55HxA",
    "outputId": "bc779c87-7f07-4e8a-a6cf-ccd3eb5556bd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test time :  1.77s\n",
      "Test Loss :  2.6038\n",
      "Test Accuracy :  0.3712\n"
     ]
    }
   ],
   "source": [
    "model_test(model=_best_normal_model, criterion=criterion, test_loader=normal_data_loader['test'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "skpzkD4X5_NS"
   },
   "outputs": [],
   "source": [
    "torch.save(best_normal_model, 'normal_cnn.pth')\n",
    "torch.save(best_transfer_model, 'resnet_transfered.pth')\n",
    "torch.save(_best_normal_model, '_normal_cnn.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 17
    },
    "id": "Mo3P8OmD6rWB",
    "outputId": "80a71ad7-65d2-4100-90d2-f2c493ea10f2"
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "    async function download(id, filename, size) {\n",
       "      if (!google.colab.kernel.accessAllowed) {\n",
       "        return;\n",
       "      }\n",
       "      const div = document.createElement('div');\n",
       "      const label = document.createElement('label');\n",
       "      label.textContent = `Downloading \"${filename}\": `;\n",
       "      div.appendChild(label);\n",
       "      const progress = document.createElement('progress');\n",
       "      progress.max = size;\n",
       "      div.appendChild(progress);\n",
       "      document.body.appendChild(div);\n",
       "\n",
       "      const buffers = [];\n",
       "      let downloaded = 0;\n",
       "\n",
       "      const channel = await google.colab.kernel.comms.open(id);\n",
       "      // Send a message to notify the kernel that we're ready.\n",
       "      channel.send({})\n",
       "\n",
       "      for await (const message of channel.messages) {\n",
       "        // Send a message to notify the kernel that we're ready.\n",
       "        channel.send({})\n",
       "        if (message.buffers) {\n",
       "          for (const buffer of message.buffers) {\n",
       "            buffers.push(buffer);\n",
       "            downloaded += buffer.byteLength;\n",
       "            progress.value = downloaded;\n",
       "          }\n",
       "        }\n",
       "      }\n",
       "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
       "      const a = document.createElement('a');\n",
       "      a.href = window.URL.createObjectURL(blob);\n",
       "      a.download = filename;\n",
       "      div.appendChild(a);\n",
       "      a.click();\n",
       "      div.remove();\n",
       "    }\n",
       "  "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "download(\"download_5e423798-04d2-49ab-bebb-3534f1c0246d\", \"normal_cnn.pth\", 3409422)"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "    async function download(id, filename, size) {\n",
       "      if (!google.colab.kernel.accessAllowed) {\n",
       "        return;\n",
       "      }\n",
       "      const div = document.createElement('div');\n",
       "      const label = document.createElement('label');\n",
       "      label.textContent = `Downloading \"${filename}\": `;\n",
       "      div.appendChild(label);\n",
       "      const progress = document.createElement('progress');\n",
       "      progress.max = size;\n",
       "      div.appendChild(progress);\n",
       "      document.body.appendChild(div);\n",
       "\n",
       "      const buffers = [];\n",
       "      let downloaded = 0;\n",
       "\n",
       "      const channel = await google.colab.kernel.comms.open(id);\n",
       "      // Send a message to notify the kernel that we're ready.\n",
       "      channel.send({})\n",
       "\n",
       "      for await (const message of channel.messages) {\n",
       "        // Send a message to notify the kernel that we're ready.\n",
       "        channel.send({})\n",
       "        if (message.buffers) {\n",
       "          for (const buffer of message.buffers) {\n",
       "            buffers.push(buffer);\n",
       "            downloaded += buffer.byteLength;\n",
       "            progress.value = downloaded;\n",
       "          }\n",
       "        }\n",
       "      }\n",
       "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
       "      const a = document.createElement('a');\n",
       "      a.href = window.URL.createObjectURL(blob);\n",
       "      a.download = filename;\n",
       "      div.appendChild(a);\n",
       "      a.click();\n",
       "      div.remove();\n",
       "    }\n",
       "  "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "download(\"download_b02eda70-a791-4597-971d-228a191e757e\", \"resnet_transfered.pth\", 48204166)"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "    async function download(id, filename, size) {\n",
       "      if (!google.colab.kernel.accessAllowed) {\n",
       "        return;\n",
       "      }\n",
       "      const div = document.createElement('div');\n",
       "      const label = document.createElement('label');\n",
       "      label.textContent = `Downloading \"${filename}\": `;\n",
       "      div.appendChild(label);\n",
       "      const progress = document.createElement('progress');\n",
       "      progress.max = size;\n",
       "      div.appendChild(progress);\n",
       "      document.body.appendChild(div);\n",
       "\n",
       "      const buffers = [];\n",
       "      let downloaded = 0;\n",
       "\n",
       "      const channel = await google.colab.kernel.comms.open(id);\n",
       "      // Send a message to notify the kernel that we're ready.\n",
       "      channel.send({})\n",
       "\n",
       "      for await (const message of channel.messages) {\n",
       "        // Send a message to notify the kernel that we're ready.\n",
       "        channel.send({})\n",
       "        if (message.buffers) {\n",
       "          for (const buffer of message.buffers) {\n",
       "            buffers.push(buffer);\n",
       "            downloaded += buffer.byteLength;\n",
       "            progress.value = downloaded;\n",
       "          }\n",
       "        }\n",
       "      }\n",
       "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
       "      const a = document.createElement('a');\n",
       "      a.href = window.URL.createObjectURL(blob);\n",
       "      a.download = filename;\n",
       "      div.appendChild(a);\n",
       "      a.click();\n",
       "      div.remove();\n",
       "    }\n",
       "  "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "download(\"download_e7f951a0-8981-48e9-a4d6-8b1cd6ba6511\", \"_normal_cnn.pth\", 3409422)"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "files.download('normal_cnn.pth')\n",
    "files.download('resnet_transfered.pth')\n",
    "files.download('_normal_cnn.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "eCMnVh71B5NH"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "torch_transfer_learning.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}