Pytorch/Basic Pytorch Concepts in practice by building MNIST CNN model .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Pytorch Concepts in practice by building MNIST CNN model "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Load Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "from torchvision import datasets\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from sklearn.metrics import recall_score\n",
    "import matplotlib.pyplot as plt\n",
    "from iterstrat.ml_stratifiers import MultilabelStratifiedKFold\n",
    "import joblib\n",
    "from tqdm import tqdm\n",
    "import os\n",
    "import random\n",
    "\n",
    "%reload_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Read / Import Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 32 # or 64, 128\n",
    "\n",
    "## transform the data into 'tensors' using the 'transforms' module\n",
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor()]\n",
    ")\n",
    "\n",
    "## download training dataset\n",
    "trainset = torchvision.datasets.MNIST(root='./data', train=True,\n",
    "                                        download=True, transform=transform)\n",
    "## download testing dataset\n",
    "testset = torchvision.datasets.MNIST(root='./data', train=False,\n",
    "                                       download=True, transform=transform)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Load Data on DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Feed data in batches into deep-learning models\n",
    "# num_workers=0 in Windows machine\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=BATCH_SIZE,\n",
    "                                          shuffle=True, num_workers=0) \n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=BATCH_SIZE,\n",
    "                                         shuffle=False, num_workers=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Explore the Data (EDA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "## functions to show an image\n",
    "def imshow(img):\n",
    "    #img = img / 2 + 0.5     # unnormalize\n",
    "    npimg = img.numpy()\n",
    "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
    "\n",
    "## get some random training images\n",
    "dataiter = iter(trainloader)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "## show images\n",
    "imshow(torchvision.utils.make_grid(images))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image batch dimensions: torch.Size([32, 1, 28, 28])\n",
      "Image label dimensions: torch.Size([32])\n"
     ]
    }
   ],
   "source": [
    "## Check the dimensions of a batch:\n",
    "for images, labels in trainloader:\n",
    "    print(\"Image batch dimensions:\", images.shape)\n",
    "    print(\"Image label dimensions:\", labels.shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Image batch dimensions: torch.Size([32, 1, 28, 28]) -->\n",
    "# 32: samples, 1 color channel, 28 x 28 (height x width) \n",
    "# Image label dimensions: torch.Size([32])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Create a model, optimizer and criterion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The model below consists of an __init__() portion where you include the layers and components of the neural network. \n",
    "# In our model, we have a convolutional layer denoted by nn.Conv2d(...). \n",
    "# We are dealing with an image dataset that is in grayscale so we only need one channel going in, so \"in_channels=1\". \n",
    "# We hope to get a nice representation of this layer, so we use \"out_channels=32\". \n",
    "# Kernel size is 3, and for the rest of parameters, we use the default values which you can find here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(MyModel, self).__init__()\n",
    "\n",
    "        # 28x28x1 => 26x26x32\n",
    "        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3)\n",
    "        self.d1 = nn.Linear(26 * 26 * 32, 128) # 128 represents the size we want as output, and (26*26*32) represents the dimension of the incoming data\n",
    "        self.d2 = nn.Linear(128, 10) #  The same applies for the second dense layer (d2) where the dimension of the output of the previous linear layer was added as in_features=128,\n",
    "        # and 10 is the size of the output (It should be same the final number of classes we want to predict)\n",
    "        \n",
    "        # To see how to calculate this, go to https://pytorch.org/docs/stable/nn.html?highlight=linear#conv2d\n",
    "\n",
    "        # Apply an activation function such as ReLU in the middle of each layer\n",
    "        # For prediction purposes, we then apply a softmax layer to the last transformation and return the output of that.\n",
    "    def forward(self, x):\n",
    "    # 32x1x28x28 => 32x32x26x26\n",
    "        x = self.conv1(x)\n",
    "        x = F.relu(x)\n",
    "\n",
    "        # flatten => 32 x (32*26*26)\n",
    "        x = x.flatten(start_dim = 1)\n",
    "\n",
    "        # 32 x (32*26*26) => 32x128\n",
    "        x = self.d1(x)\n",
    "        x = F.relu(x)\n",
    "\n",
    "        # logits => 32x10\n",
    "        logits = self.d2(x)\n",
    "        out = F.softmax(logits, dim=1)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1. Test one batch "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batch size: torch.Size([32, 1, 28, 28])\n",
      "torch.Size([32, 10])\n"
     ]
    }
   ],
   "source": [
    "model = MyModel()\n",
    "## We always want to test 1 batch\n",
    "for images, labels in trainloader:\n",
    "    print(\"batch size:\", images.shape)\n",
    "    out = model(images)\n",
    "    print(out.shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 optimizer and criterion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define Model\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "model = MyModel()\n",
    "model = model.to(device)\n",
    "# Learning Rate / Epoch\n",
    "learning_rate = 0.001\n",
    "num_epochs = 5\n",
    "# optimizer\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
    "# criterion\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Custom accuracy function\n",
    "def get_accuracy(logit, target, batch_size):\n",
    "    ''' Obtain accuracy for training round '''\n",
    "    corrects = (torch.max(logit, 1)[1].view(target.size()).data == target.data).sum()\n",
    "    accuracy = 100.0 * corrects/batch_size\n",
    "    return accuracy.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 | Loss: 1.6421 | Train Accuracy: 82.21\n",
      "Epoch: 1 | Loss: 1.5032 | Train Accuracy: 96.13\n",
      "Epoch: 2 | Loss: 1.4870 | Train Accuracy: 97.70\n",
      "Epoch: 3 | Loss: 1.4801 | Train Accuracy: 98.34\n",
      "Epoch: 4 | Loss: 1.4758 | Train Accuracy: 98.76\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(num_epochs):\n",
    "    train_running_loss = 0.0\n",
    "    train_acc = 0.0\n",
    "\n",
    "    model = model.train()\n",
    "\n",
    "    ## training step\n",
    "    for i, (images, labels) in enumerate(trainloader):\n",
    "        \n",
    "        images = images.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        ## forward + backprop + loss\n",
    "        logits = model(images)\n",
    "        loss = criterion(logits, labels)\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "\n",
    "        ## update model params\n",
    "        optimizer.step()\n",
    "\n",
    "        train_running_loss += loss.detach().item()\n",
    "        train_acc += get_accuracy(logits, labels, BATCH_SIZE)\n",
    "    \n",
    "    model.eval()\n",
    "    print('Epoch: %d | Loss: %.4f | Train Accuracy: %.2f' \\\n",
    "          %(epoch, train_running_loss / i, train_acc/i)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Test the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Avg. Test Accuracy: 98.34\n"
     ]
    }
   ],
   "source": [
    "test_acc = 0.0\n",
    "for i, (images, labels) in enumerate(testloader, 0):\n",
    "    images = images.to(device)\n",
    "    labels = labels.to(device)\n",
    "    outputs = model(images)\n",
    "    test_acc += get_accuracy(outputs, labels, BATCH_SIZE)\n",
    "        \n",
    "print('Avg. Test Accuracy: %.2f'%( test_acc/i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Inspired by\n",
    "# https://medium.com/dair-ai/building-rnns-is-fun-with-pytorch-and-google-colab-3903ea9a3a79"
   ]
  }
 ],
 "metadata": {
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}