5_cifar10_using_resnet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8OM0_YDU1MmX"
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "# The following is to downlaod and use pretrained models from the model-zoo\n",
    "import torchvision.models as models\n",
    "#--------------------------------------------------------------------------\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "e5l2Mn1FhkP6"
   },
   "outputs": [],
   "source": [
    "# Hyperparameters\n",
    "batch_size = 256\n",
    "# Learning rate\n",
    "lr = 0.001\n",
    "# Number of training epochs\n",
    "num_epochs = 2\n",
    "# Device configuration\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)\n",
    "# Path to dataset\n",
    "dataset_root_path = '/home/sprakashdash/Documents/DLFA/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AuiekLk4hkQO"
   },
   "source": [
    "The output of torchvision datasets are PILImage images of range [0, 1].\n",
    "We transform them to Tensors of normalized range [-1, 1].\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "bwnRbBSGhkQS",
    "outputId": "9b982ba1-0220-4d73-905e-31bb45bbcbf9"
   },
   "outputs": [],
   "source": [
    "normalize = transforms.Normalize(\n",
    "   mean=[0.485, 0.456, 0.406],\n",
    "   std=[0.229, 0.224, 0.225]\n",
    ")\n",
    "trans = transforms.Compose([transforms.Resize(224),\n",
    "                               transforms.CenterCrop(224),\n",
    "                               transforms.ToTensor(),\n",
    "                               normalize])\n",
    "\n",
    "trainset = torchvision.datasets.CIFAR10(root=dataset_root_path, train=True,\n",
    "                                        download=True, transform=trans)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "\n",
    "testset = torchvision.datasets.CIFAR10(root=dataset_root_path, train=False,\n",
    "                                       download=True, transform=trans)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=2*batch_size,\n",
    "                                         shuffle=False, num_workers=2)\n",
    "\n",
    "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "aKRe2rhdhkQl",
    "outputId": "d817857f-3dbc-4acf-970d-148bcb6031ba"
   },
   "outputs": [],
   "source": [
    "print(trainset.train_list.__len__())\n",
    "print(testset.test_list.__len__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "07cJaB8ahkSB"
   },
   "outputs": [],
   "source": [
    "# Download the pretrained Resnet50 model and load it to the device (GPU)\n",
    "resnet50 = models.resnet50(pretrained=True)\n",
    "resnet50 = resnet50.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-oa9YUpphkSa"
   },
   "outputs": [],
   "source": [
    "# Freeze the layers\n",
    "for param in resnet50.parameters():\n",
    "    param.requires_grad = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JRiPYRADhkSw"
   },
   "outputs": [],
   "source": [
    "# Change the last layer to cifar10 number of output classes.\n",
    "# Also unfreeze the penultimate layer. We will finetune just these two layers.\n",
    "resnet50.fc = nn.Sequential(\n",
    "                      nn.Linear(2048, 256), \n",
    "                      nn.ReLU(), \n",
    "                      nn.Linear(256, 10)\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "h9KEdmyphkTN"
   },
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(resnet50.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRAINING THE NETWORK\n",
    "\n",
    "resnet50 = resnet50.to(device)\n",
    "for epoch in range(num_epochs):  # loop over the dataset multiple times\n",
    "    running_loss = 0.0\n",
    "    pbar = tqdm(trainloader)\n",
    "    i = 0\n",
    "    for data in pbar:\n",
    "        # get the inputs\n",
    "        inputs, labels = data\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward + backward + optimize\n",
    "        outputs = resnet50(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # print statistics\n",
    "        running_loss += loss.item()\n",
    "        \n",
    "        pbar.set_description(\"Processing epoch {:d} minibatch {:d} train loss {:.3f}\".format(epoch,\\\n",
    "                                                            i+1, running_loss/(i+1)))\n",
    "        i += 1\n",
    "\n",
    "print('Finished Training')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now if you don't have enough juice for ResNet then a memory overflow will occour. But, no worries. I made a [Kaggle Kernel](https://www.kaggle.com/sprakashdash/cifar10-using-resnet?scriptVersionId=19860482) where I ran this code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0k4d7neVhkTm"
   },
   "source": [
    "5. Test the network on the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "nyz2vWYfhkVQ",
    "outputId": "166dc0b1-45e2-438b-9b28-6d49de72a642"
   },
   "outputs": [],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "i = 0\n",
    "with torch.no_grad():\n",
    "    pbar = tqdm(testloader)\n",
    "    for data in pbar:\n",
    "        images, labels = data\n",
    "        images = images.to(device)\n",
    "        labels = labels.to(device)\n",
    "        outputs = resnet50(images)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "        pbar.set_description(\"minibatch {:d} test accuracy {:4.2f}%\".format(i+1,\\\n",
    "                                                            100.0*correct/total))\n",
    "        i += 1\n",
    "\n",
    "print('Accuracy of the network on the 10000 test images: %4.2f %%' % (100.0 * correct / total))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9GFK2liD1LLC"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "cifar10_tutorial_resnet.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}