6.Pytorch Transfer Learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "### Transfer Learning with Pytorch\r\n",
    "\r\n",
    "### 1.What is Transfer Learning \r\n",
    "\r\n",
    "- Transfer Learning is speciafically using a neural network that has been pre-trained on a much larger dataset.\r\n",
    "- The main benefit of using transfer learning is that the neural network  has already learn the important features from large dataset.\r\n",
    "- When we use that netwrork on our own dataset, we just need to tweak a few things to achieve good results.\r\n",
    "\r\n",
    "![](https://miro.medium.com/max/1400/1*Ww3AMxZeoiB84GVSRBr4Bw.png)\r\n",
    "\r\n",
    "### 2.When to use Transfer Learning?\r\n",
    "- It used when dataset is very small.\r\n",
    "- Due to huge computational Power.\r\n",
    "\r\n",
    "![](https://miro.medium.com/max/1400/1*9GTEzcO8KxxrfutmtsPs3Q.png)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Dataset used in pretrained Model\r\n",
    "\r\n",
    "![](https://debuggercafe.com/wp-content/uploads/2019/12/imagenet.png)\r\n",
    "\r\n",
    "* Images : 14 Millions\r\n",
    "* classes : 22000\r\n",
    "* Organize : [ILSVRC](https://image-net.org/challenges/LSVRC/2017/index)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 1.Load Libraries"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "# torch loaded..!!!\r\n",
    "import torch\r\n",
    "import torch.nn.functional as F\r\n",
    "import torch.optim as optim\r\n",
    "import torch.nn as nn\r\n",
    "\r\n",
    "# torchvision loaded..!!!\r\n",
    "import torchvision\r\n",
    "import torchvision.transforms as transforms\r\n",
    "from torchvision import models\r\n",
    "from torchsummary import summary\r\n",
    "\r\n",
    "# other libraries loaded,,,!!!\r\n",
    "import time\r\n",
    "import numpy as np\r\n",
    "import matplotlib.pyplot as plt\r\n",
    "from tqdm.notebook import tqdm\r\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 2.Check the GPU availability"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\r\n",
    "print(device)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 3. Download the dataset and prepare"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "# Tranforms for the training, validation, and testing sets\r\n",
    "transform = transforms.Compose(\r\n",
    "    [\r\n",
    "        transforms.Resize((224,224)),\r\n",
    "        transforms.ToTensor(),\r\n",
    "        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\r\n",
    "    ]\r\n",
    ")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "# Download the training data and testing data\r\n",
    "trainset = torchvision.datasets.CIFAR10(root='./data_new', train=True, download=True, transform=transform)\r\n",
    "testset = torchvision.datasets.CIFAR10(root='./data_new', train=False, download=True, transform=transform)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data_new\\cifar-10-python.tar.gz\n"
     ]
    },
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "170499072it [00:28, 5990303.03it/s]                               \n"
     ]
    },
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Extracting ./data_new\\cifar-10-python.tar.gz to ./data_new\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "# Load the data using DataLoader\r\n",
    "trainLoader = torch.utils.data.DataLoader(trainset, batch_size= 32, shuffle=True, num_workers=2)\r\n",
    "testLoader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False, num_workers=2)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 4.Downloading the ResNet18 Network\r\n",
    "![](https://i.imgur.com/XwcnU5x.png)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "for batch_1 in trainLoader:\r\n",
    "    batch = batch_1\r\n",
    "    break\r\n",
    "\r\n",
    "print(f\"Image shape:{batch[0].shape}\") # Image pixels -> (batch, channel, height, width)\r\n",
    "print(f\"Label shape:{batch[1].shape}\") # Label -> (batch, 1)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Image shape:torch.Size([32, 3, 224, 224])\n",
      "Label shape:torch.Size([32])\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "resnet18 = models.resnet18(pretrained=True)\r\n",
    "num_features = resnet18.fc.in_features\r\n",
    "resnet18.fc = nn.Linear(num_features, 10)\r\n",
    "resnet18.to(device)\r\n",
    "print(str(summary(resnet18.to(device), (3, 224, 224), depth=1, device=device)))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "C:\\Users\\SHIVA\\miniconda3\\envs\\pytorch19\\lib\\site-packages\\torch\\nn\\functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at  ..\\c10/core/TensorImpl.h:1156.)\n",
      "  return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)\n"
     ]
    },
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "==========================================================================================\n",
      "Layer (type:depth-idx)                   Output Shape              Param #\n",
      "==========================================================================================\n",
      "├─Conv2d: 1-1                            [-1, 64, 112, 112]        9,408\n",
      "├─BatchNorm2d: 1-2                       [-1, 64, 112, 112]        128\n",
      "├─ReLU: 1-3                              [-1, 64, 112, 112]        --\n",
      "├─MaxPool2d: 1-4                         [-1, 64, 56, 56]          --\n",
      "├─Sequential: 1-5                        [-1, 64, 56, 56]          147,968\n",
      "├─Sequential: 1-6                        [-1, 128, 28, 28]         525,568\n",
      "├─Sequential: 1-7                        [-1, 256, 14, 14]         2,099,712\n",
      "├─Sequential: 1-8                        [-1, 512, 7, 7]           8,393,728\n",
      "├─AdaptiveAvgPool2d: 1-9                 [-1, 512, 1, 1]           --\n",
      "├─Linear: 1-10                           [-1, 10]                  5,130\n",
      "==========================================================================================\n",
      "Total params: 11,181,642\n",
      "Trainable params: 11,181,642\n",
      "Non-trainable params: 0\n",
      "Total mult-adds (M): 140.34\n",
      "==========================================================================================\n",
      "Input size (MB): 0.57\n",
      "Forward/backward pass size (MB): 12.25\n",
      "Params size (MB): 42.65\n",
      "Estimated Total Size (MB): 55.48\n",
      "==========================================================================================\n",
      "==========================================================================================\n",
      "Layer (type:depth-idx)                   Output Shape              Param #\n",
      "==========================================================================================\n",
      "├─Conv2d: 1-1                            [-1, 64, 112, 112]        9,408\n",
      "├─BatchNorm2d: 1-2                       [-1, 64, 112, 112]        128\n",
      "├─ReLU: 1-3                              [-1, 64, 112, 112]        --\n",
      "├─MaxPool2d: 1-4                         [-1, 64, 56, 56]          --\n",
      "├─Sequential: 1-5                        [-1, 64, 56, 56]          147,968\n",
      "├─Sequential: 1-6                        [-1, 128, 28, 28]         525,568\n",
      "├─Sequential: 1-7                        [-1, 256, 14, 14]         2,099,712\n",
      "├─Sequential: 1-8                        [-1, 512, 7, 7]           8,393,728\n",
      "├─AdaptiveAvgPool2d: 1-9                 [-1, 512, 1, 1]           --\n",
      "├─Linear: 1-10                           [-1, 10]                  5,130\n",
      "==========================================================================================\n",
      "Total params: 11,181,642\n",
      "Trainable params: 11,181,642\n",
      "Non-trainable params: 0\n",
      "Total mult-adds (M): 140.34\n",
      "==========================================================================================\n",
      "Input size (MB): 0.57\n",
      "Forward/backward pass size (MB): 12.25\n",
      "Params size (MB): 42.65\n",
      "Estimated Total Size (MB): 55.48\n",
      "==========================================================================================\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 5.Freezing Convolution Weights\r\n",
    "- Original dataset contains 1000 Classes.\r\n",
    "- Last layer set `resnet18.fc = Linear(512,10)`.\r\n",
    "- Freeze all the weights of convolution block."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "# Freeze parameters so we don't backprop through them\r\n",
    "# for param in resnet18.parameters():\r\n",
    "#     param.requires_grad = False"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 6.Optimizer and Loss Function"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "# Define the loss function and optimizer\r\n",
    "loss_fn = nn.CrossEntropyLoss()\r\n",
    "optimizer = optim.SGD(resnet18.fc.parameters(), lr=0.001, momentum=0.9)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 7.Training and Validation"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "source": [
    "def validation(model, testLoader):\r\n",
    "    model.eval()\r\n",
    "    val_running_loss = 0\r\n",
    "    val_running_correct = 0\r\n",
    "    # 1. Load the data\r\n",
    "    for int, data in enumerate(testLoader, 0):\r\n",
    "        # 2. Get the inputs and labels\r\n",
    "        inputs, labels = data[0].to(device), data[1].to(device)\r\n",
    "        \r\n",
    "        # 3. Forward pass\r\n",
    "        outputs = model(inputs)\r\n",
    "        \r\n",
    "        # 4. Calculate the loss\r\n",
    "        loss = loss_fn(outputs, labels)\r\n",
    "        \r\n",
    "        # 5. Calculate the val_loss\r\n",
    "        val_running_loss += loss.item()\r\n",
    "        \r\n",
    "        # 6. torch.max returns the max value and the index of the max value\r\n",
    "        _, preds = torch.max(outputs, 1)\r\n",
    "        \r\n",
    "        # 7. Calculate the val correct  \r\n",
    "        val_running_correct += (preds == labels).sum().item()\r\n",
    "    \r\n",
    "    val_loss = val_running_loss / len(testLoader.dataset)\r\n",
    "    val_accuracy = val_running_correct / len(testLoader.dataset)\r\n",
    "        \r\n",
    "    return val_loss, val_accuracy\r\n",
    "    "
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    " In validation method we are calculating the loss and accuracy. but we are not doing any backpropagating the gradient, backpropagation is only required during training"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "source": [
    "def fit(model, trainLoader):\r\n",
    "    model.train()\r\n",
    "    train_running_loss = 0\r\n",
    "    train_running_correct = 0\r\n",
    "    # 1. Load the data\r\n",
    "    for i, data in enumerate(trainLoader, 0):\r\n",
    "        # 2. Get the inputs and labels\r\n",
    "        inputs, labels = data[0].to(device), data[1].to(device)\r\n",
    "        \r\n",
    "        # 3. zero the parameter gradients\r\n",
    "        optimizer.zero_grad()\r\n",
    "        \r\n",
    "        # 4. forward pass\r\n",
    "        output = model(inputs)\r\n",
    "        \r\n",
    "        # 5. Calculate the loss\r\n",
    "        loss = loss_fn(output, labels)\r\n",
    "        train_running_loss += loss.item()\r\n",
    "        \r\n",
    "        # 6. predict the output\r\n",
    "        _, preds = torch.max(output.data, 1)\r\n",
    "        train_running_correct += (preds - labels).sum().item()\r\n",
    "        \r\n",
    "        # 7. backward pass\r\n",
    "        loss.backward()\r\n",
    "        \r\n",
    "        # 8. optimize the weights\r\n",
    "        optimizer.step()\r\n",
    "        \r\n",
    "    train_loss = train_running_loss / len(trainLoader.dataset)\r\n",
    "    train_accuracy = train_running_correct/len(trainLoader.dataset)\r\n",
    "    # print(f\"Train Loss: {train_loss:.2f}, Train Acc: {train_accuracy:.2f}\")\r\n",
    "    \r\n",
    "    return train_loss, train_accuracy       \r\n",
    "    "
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "* `fit()` method calculating gradient and backpropagation.\r\n",
    "* `fit(), validation()` will keep returning the loss and accuracy values for each epoch."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "source": [
    "train_loss , train_accuracy = [], []\r\n",
    "val_loss , val_accuracy = [], []\r\n",
    "start = time.time()\r\n",
    "for epoch in range(10):\r\n",
    "    start_epoch = time.time()\r\n",
    "    train_epoch_loss, train_epoch_accuracy = fit(resnet18, trainLoader)\r\n",
    "    val_epoch_loss, val_epoch_accuracy = validation(resnet18, testLoader)\r\n",
    "    i = epoch + 1\r\n",
    "    train_loss.append(train_epoch_loss)\r\n",
    "    train_accuracy.append(train_epoch_accuracy)\r\n",
    "    val_loss.append(val_epoch_loss)\r\n",
    "    val_accuracy.append(val_epoch_accuracy)\r\n",
    "    end_epoch = time.time()\r\n",
    "    total_time = end_epoch - start_epoch\r\n",
    "    print(f\"Epoch : {i}/{10} ETA:{total_time:.2f} seconds, Train Loss: {train_epoch_loss:.4f}, Train Acc: {train_epoch_accuracy:.2f}, Val Loss: {val_epoch_loss}, Val Acc: {val_epoch_accuracy}\")\r\n",
    "    \r\n",
    "end = time.time()\r\n",
    "print((end-start)/60, 'minutes')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Epoch : 1/10 ETA:144.10 seconds, Train Loss: 0.0184, Train Acc: 0.01, Val Loss: 0.018194763697683813, Val Acc: 0.8012\n",
      "Epoch : 2/10 ETA:151.63 seconds, Train Loss: 0.0183, Train Acc: 0.01, Val Loss: 0.017984453096985816, Val Acc: 0.8001\n",
      "Epoch : 3/10 ETA:164.47 seconds, Train Loss: 0.0180, Train Acc: 0.02, Val Loss: 0.01749786235243082, Val Acc: 0.8105\n",
      "Epoch : 4/10 ETA:174.91 seconds, Train Loss: 0.0180, Train Acc: 0.01, Val Loss: 0.017611042676866053, Val Acc: 0.8067\n",
      "Epoch : 5/10 ETA:170.74 seconds, Train Loss: 0.0180, Train Acc: 0.01, Val Loss: 0.017491949382424356, Val Acc: 0.809\n",
      "Epoch : 6/10 ETA:170.06 seconds, Train Loss: 0.0179, Train Acc: 0.01, Val Loss: 0.01748853136599064, Val Acc: 0.807\n",
      "Epoch : 7/10 ETA:166.22 seconds, Train Loss: 0.0177, Train Acc: 0.01, Val Loss: 0.01750915951281786, Val Acc: 0.8109\n",
      "Epoch : 8/10 ETA:166.30 seconds, Train Loss: 0.0177, Train Acc: 0.01, Val Loss: 0.017499353241920472, Val Acc: 0.8103\n",
      "Epoch : 9/10 ETA:163.44 seconds, Train Loss: 0.0178, Train Acc: 0.01, Val Loss: 0.01760139015465975, Val Acc: 0.8083\n",
      "Epoch : 10/10 ETA:164.15 seconds, Train Loss: 0.0177, Train Acc: 0.01, Val Loss: 0.017467146189510823, Val Acc: 0.812\n",
      "27.26687217950821 minutes\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 8. Plot the graph"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "source": [
    "plt.figure(figsize=(10, 7))\r\n",
    "plt.plot(train_accuracy, color='green', label='train accuracy')\r\n",
    "plt.plot(val_accuracy, color='blue', label='validataion accuracy')\r\n",
    "plt.legend()\r\n",
    "plt.show()\r\n",
    "\r\n",
    "plt.figure(figsize=(10, 7))\r\n",
    "plt.plot(train_loss, color='orange', label='train loss')\r\n",
    "plt.plot(val_loss, color='red', label='validataion loss')\r\n",
    "plt.legend()\r\n",
    "plt.savefig('loss.png')\r\n",
    "plt.show()"
   ],
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     }
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "metadata": {}
  }
 ],
 "metadata": {
  "orig_nbformat": 4,
  "language_info": {
   "name": "python",
   "version": "3.8.0",
   "mimetype": "text/x-python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "pygments_lexer": "ipython3",
   "nbconvert_exporter": "python",
   "file_extension": ".py"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.8.0 64-bit ('pytorch19': conda)"
  },
  "interpreter": {
   "hash": "884a8f81666a19c0851426c83cd6eaa7b212468ad852fb3caa21591c98d4369f"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}