7.Pytorch_Transfer_Learning_VGG16.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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"
    },
    "colab": {
      "name": "6.Pytorch Transfer Learning VGG16.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q4D2Z-_56Lvf"
      },
      "source": [
        "### Transfer Learning with Pytorch\n",
        "\n",
        "### 1.What is Transfer Learning \n",
        "\n",
        "- Transfer Learning is speciafically using a neural network that has been pre-trained on a much larger dataset.\n",
        "- The main benefit of using transfer learning is that the neural network  has already learn the important features from large dataset.\n",
        "- When we use that netwrork on our own dataset, we just need to tweak a few things to achieve good results.\n",
        "\n",
        "![](https://miro.medium.com/max/1400/1*Ww3AMxZeoiB84GVSRBr4Bw.png)\n",
        "\n",
        "### 2.When to use Transfer Learning?\n",
        "- It used when dataset is very small.\n",
        "- Due to huge computational Power.\n",
        "\n",
        "![](https://miro.medium.com/max/1400/1*9GTEzcO8KxxrfutmtsPs3Q.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b_wFomwH6Lvl"
      },
      "source": [
        "### Dataset used in pretrained Model\n",
        "\n",
        "![](https://debuggercafe.com/wp-content/uploads/2019/12/imagenet.png)\n",
        "\n",
        "* Images : 14 Millions\n",
        "* classes : 22000\n",
        "* Organize : [ILSVRC](https://image-net.org/challenges/LSVRC/2017/index)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sggpksj76Lvm"
      },
      "source": [
        "### 1.Load Libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4N5_tRHD6Lvm"
      },
      "source": [
        "# torch loaded..!!!\n",
        "import torch\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "import torch.nn as nn\n",
        "\n",
        "# torchvision loaded..!!!\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "from torchvision import models\n",
        "from torchsummary import summary\n",
        "\n",
        "# other libraries loaded,,,!!!\n",
        "import time\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from tqdm.notebook import tqdm\n"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rhnlFnt76Lvo"
      },
      "source": [
        "### 2.Check the GPU availability"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AguwBhmT6Lvo",
        "outputId": "e0939921-f61e-4bf4-8989-920b1d2ed4ac"
      },
      "source": [
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(device)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda:0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jkqBneAR6Lvp"
      },
      "source": [
        "### 3. Download the dataset and prepare"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2mERX9PN6Lvp"
      },
      "source": [
        "# Tranforms for the training, validation, and testing sets\n",
        "transform = transforms.Compose(\n",
        "    [\n",
        "        transforms.Resize((224,224)),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
        "    ]\n",
        ")"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dxY31lKd6Lvq",
        "outputId": "396cffe4-2cf1-4110-c8ff-90d665e427bd"
      },
      "source": [
        "# Download the training data and testing data\n",
        "trainset = torchvision.datasets.CIFAR10(root='./data_new', train=True, download=True, transform=transform)\n",
        "testset = torchvision.datasets.CIFAR10(root='./data_new', train=False, download=True, transform=transform)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wu4BaB_X6Lvr"
      },
      "source": [
        "# Load the data using DataLoader\n",
        "trainLoader = torch.utils.data.DataLoader(trainset, batch_size= 32, shuffle=True, num_workers=2)\n",
        "testLoader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False, num_workers=2)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qoo3yh3-6Lvr"
      },
      "source": [
        "### 4.Downloading the ResNet18 Network\n",
        "![](https://i.imgur.com/XwcnU5x.png)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nwJ_rGo66Lvr",
        "outputId": "a52ff4e6-d8c4-4dbe-fa34-aaf674dec9a8"
      },
      "source": [
        "for batch_1 in trainLoader:\n",
        "    batch = batch_1\n",
        "    break\n",
        "\n",
        "print(f\"Image shape:{batch[0].shape}\") # Image pixels -> (batch, channel, height, width)\n",
        "print(f\"Label shape:{batch[1].shape}\") # Label -> (batch, 1)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Image shape:torch.Size([32, 3, 224, 224])\n",
            "Label shape:torch.Size([32])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SJbEjuSB6Lvt"
      },
      "source": [
        "### 5.Freezing Convolution Weights\n",
        "- Original dataset contains 1000 Classes.\n",
        "- Last layer set `resnet18.fc = Linear(512,10)`.\n",
        "- Freeze all the weights of convolution block."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fJopVgXA6Lvt",
        "outputId": "ba23e2c3-2ab6-4975-bc5c-2f7ca745738a"
      },
      "source": [
        "# Freeze parameters so we don't backprop through them\n",
        "vgg16 = models.vgg16(pretrained=True)\n",
        "for param in vgg16.features.parameters():\n",
        "    param.requires_grad = False \n",
        "    1\n",
        "vgg16.classifier[6].out_features = 10\n",
        "vgg16 = vgg16.to(device)\n",
        "print(vgg16)\n",
        "print(str(summary(vgg16, (3, 224, 224))))"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "VGG(\n",
            "  (features): Sequential(\n",
            "    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (1): ReLU(inplace=True)\n",
            "    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (3): ReLU(inplace=True)\n",
            "    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (6): ReLU(inplace=True)\n",
            "    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (8): ReLU(inplace=True)\n",
            "    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (11): ReLU(inplace=True)\n",
            "    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (13): ReLU(inplace=True)\n",
            "    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (15): ReLU(inplace=True)\n",
            "    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (18): ReLU(inplace=True)\n",
            "    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (20): ReLU(inplace=True)\n",
            "    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (22): ReLU(inplace=True)\n",
            "    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (25): ReLU(inplace=True)\n",
            "    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (27): ReLU(inplace=True)\n",
            "    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (29): ReLU(inplace=True)\n",
            "    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "  )\n",
            "  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))\n",
            "  (classifier): Sequential(\n",
            "    (0): Linear(in_features=25088, out_features=4096, bias=True)\n",
            "    (1): ReLU(inplace=True)\n",
            "    (2): Dropout(p=0.5, inplace=False)\n",
            "    (3): Linear(in_features=4096, out_features=4096, bias=True)\n",
            "    (4): ReLU(inplace=True)\n",
            "    (5): Dropout(p=0.5, inplace=False)\n",
            "    (6): Linear(in_features=4096, out_features=10, bias=True)\n",
            "  )\n",
            ")\n",
            "----------------------------------------------------------------\n",
            "        Layer (type)               Output Shape         Param #\n",
            "================================================================\n",
            "            Conv2d-1         [-1, 64, 224, 224]           1,792\n",
            "              ReLU-2         [-1, 64, 224, 224]               0\n",
            "            Conv2d-3         [-1, 64, 224, 224]          36,928\n",
            "              ReLU-4         [-1, 64, 224, 224]               0\n",
            "         MaxPool2d-5         [-1, 64, 112, 112]               0\n",
            "            Conv2d-6        [-1, 128, 112, 112]          73,856\n",
            "              ReLU-7        [-1, 128, 112, 112]               0\n",
            "            Conv2d-8        [-1, 128, 112, 112]         147,584\n",
            "              ReLU-9        [-1, 128, 112, 112]               0\n",
            "        MaxPool2d-10          [-1, 128, 56, 56]               0\n",
            "           Conv2d-11          [-1, 256, 56, 56]         295,168\n",
            "             ReLU-12          [-1, 256, 56, 56]               0\n",
            "           Conv2d-13          [-1, 256, 56, 56]         590,080\n",
            "             ReLU-14          [-1, 256, 56, 56]               0\n",
            "           Conv2d-15          [-1, 256, 56, 56]         590,080\n",
            "             ReLU-16          [-1, 256, 56, 56]               0\n",
            "        MaxPool2d-17          [-1, 256, 28, 28]               0\n",
            "           Conv2d-18          [-1, 512, 28, 28]       1,180,160\n",
            "             ReLU-19          [-1, 512, 28, 28]               0\n",
            "           Conv2d-20          [-1, 512, 28, 28]       2,359,808\n",
            "             ReLU-21          [-1, 512, 28, 28]               0\n",
            "           Conv2d-22          [-1, 512, 28, 28]       2,359,808\n",
            "             ReLU-23          [-1, 512, 28, 28]               0\n",
            "        MaxPool2d-24          [-1, 512, 14, 14]               0\n",
            "           Conv2d-25          [-1, 512, 14, 14]       2,359,808\n",
            "             ReLU-26          [-1, 512, 14, 14]               0\n",
            "           Conv2d-27          [-1, 512, 14, 14]       2,359,808\n",
            "             ReLU-28          [-1, 512, 14, 14]               0\n",
            "           Conv2d-29          [-1, 512, 14, 14]       2,359,808\n",
            "             ReLU-30          [-1, 512, 14, 14]               0\n",
            "        MaxPool2d-31            [-1, 512, 7, 7]               0\n",
            "AdaptiveAvgPool2d-32            [-1, 512, 7, 7]               0\n",
            "           Linear-33                 [-1, 4096]     102,764,544\n",
            "             ReLU-34                 [-1, 4096]               0\n",
            "          Dropout-35                 [-1, 4096]               0\n",
            "           Linear-36                 [-1, 4096]      16,781,312\n",
            "             ReLU-37                 [-1, 4096]               0\n",
            "          Dropout-38                 [-1, 4096]               0\n",
            "           Linear-39                 [-1, 1000]       4,097,000\n",
            "================================================================\n",
            "Total params: 138,357,544\n",
            "Trainable params: 123,642,856\n",
            "Non-trainable params: 14,714,688\n",
            "----------------------------------------------------------------\n",
            "Input size (MB): 0.57\n",
            "Forward/backward pass size (MB): 218.78\n",
            "Params size (MB): 527.79\n",
            "Estimated Total Size (MB): 747.15\n",
            "----------------------------------------------------------------\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uXfdvBAU6Lvt"
      },
      "source": [
        "### 6.Optimizer and Loss Function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GGSRZGKe6Lvt"
      },
      "source": [
        "# optimizer\n",
        "optimizer = optim.SGD(vgg16.classifier.parameters(), lr=0.001, momentum=0.9)\n",
        "# loss function\n",
        "criterion = nn.CrossEntropyLoss()"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7N0IfARa6Lvu"
      },
      "source": [
        "### Training and Validation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wdg1qaB06Lvu"
      },
      "source": [
        "# validation function\n",
        "def validate(model, test_dataloader):\n",
        "    model.eval()\n",
        "    val_running_loss = 0.0\n",
        "    val_running_correct = 0\n",
        "    for int, data in enumerate(test_dataloader):\n",
        "        data, target = data[0].to(device), data[1].to(device)\n",
        "        output = model(data)\n",
        "        loss = criterion(output, target)\n",
        "        \n",
        "        val_running_loss += loss.item()\n",
        "        _, preds = torch.max(output.data, 1)\n",
        "        val_running_correct += (preds == target).sum().item()\n",
        "    \n",
        "    val_loss = val_running_loss/len(test_dataloader.dataset)\n",
        "    val_accuracy = 100. * val_running_correct/len(test_dataloader.dataset)\n",
        "    \n",
        "    return val_loss, val_accuracy"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4rFMZKwf6Lvu"
      },
      "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"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Be4-ykGL6Lvv"
      },
      "source": [
        "# training function\n",
        "def fit(model, train_dataloader):\n",
        "    model.train()\n",
        "    train_running_loss = 0.0\n",
        "    train_running_correct = 0\n",
        "    for i, data in enumerate(train_dataloader):\n",
        "        data, target = data[0].to(device), data[1].to(device)\n",
        "        optimizer.zero_grad()\n",
        "        output = model(data)\n",
        "        loss = criterion(output, target)\n",
        "        train_running_loss += loss.item()\n",
        "        _, preds = torch.max(output.data, 1)\n",
        "        train_running_correct += (preds == target).sum().item()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "    train_loss = train_running_loss/len(train_dataloader.dataset)\n",
        "    train_accuracy = 100. * train_running_correct/len(train_dataloader.dataset)\n",
        "    print(f'Train Loss: {train_loss:.4f}, Train Acc: {train_accuracy:.2f}')\n",
        "    \n",
        "    return train_loss, train_accuracy"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9hNpEIzj6Lvv"
      },
      "source": [
        "* `fit()` method calculating gradient and backpropagation.\n",
        "* `fit(), validation()` will keep returning the loss and accuracy values for each epoch."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C5ACo1ZU6Lvw",
        "outputId": "4b59be42-3514-40f5-b299-541b948321fa"
      },
      "source": [
        "train_loss , train_accuracy = [], []\n",
        "val_loss , val_accuracy = [], []\n",
        "start = time.time()\n",
        "for epoch in range(10):\n",
        "    train_epoch_loss, train_epoch_accuracy = fit(vgg16, trainLoader)\n",
        "    val_epoch_loss, val_epoch_accuracy = validate(vgg16, testLoader)\n",
        "    train_loss.append(train_epoch_loss)\n",
        "    train_accuracy.append(train_epoch_accuracy)\n",
        "    val_loss.append(val_epoch_loss)\n",
        "    val_accuracy.append(val_epoch_accuracy)\n",
        "end = time.time()\n",
        "print((end-start)/60, 'minutes')"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train Loss: 0.0138, Train Acc: 84.66\n",
            "Train Loss: 0.0110, Train Acc: 87.69\n",
            "Train Loss: 0.0087, Train Acc: 90.29\n",
            "Train Loss: 0.0070, Train Acc: 92.06\n",
            "Train Loss: 0.0053, Train Acc: 94.20\n",
            "Train Loss: 0.0040, Train Acc: 95.71\n",
            "Train Loss: 0.0029, Train Acc: 96.94\n",
            "Train Loss: 0.0022, Train Acc: 97.78\n",
            "Train Loss: 0.0016, Train Acc: 98.35\n",
            "Train Loss: 0.0013, Train Acc: 98.78\n",
            "100.89961864948273 minutes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 842
        },
        "id": "UAfb5wUx6Lvw",
        "outputId": "aa0d83fa-a45b-42fb-8938-300167385406"
      },
      "source": [
        "plt.figure(figsize=(10, 7))\n",
        "plt.plot(train_accuracy, color='green', label='train accuracy')\n",
        "plt.plot(val_accuracy, color='blue', label='validataion accuracy')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "plt.figure(figsize=(10, 7))\n",
        "plt.plot(train_loss, color='orange', label='train loss')\n",
        "plt.plot(val_loss, color='red', label='validataion loss')\n",
        "plt.legend()\n",
        "plt.savefig('loss.png')\n",
        "plt.show()"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}