lecture_11.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 2,
 "metadata": {
  "language_info": {
   "name": "python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "version": "3.7.6-final"
  },
  "orig_nbformat": 2,
  "file_extension": ".py",
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3,
  "kernelspec": {
   "name": "python37664bitfastaiconda149f4ca18fae45818735beadf08062d0",
   "display_name": "Python 3.7.6 64-bit ('fastai': conda)"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lecture 11:\n",
    "\n",
    "\n",
    "* We are going to create toy inception modules and then use them in our model.\n",
    "* Everything else remains same as the lecture 10.\n",
    "* The dataset to be used is the **_MINST Dataset_** given by pytorch package\n",
    "\n",
    "\n",
    "_It is worth noting that we can create a new network component as a class and then use that object in our core network. This is really a very neat and useful implementation_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing the stock libraries\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from torchvision import datasets, transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating the CUDA environment\n",
    "\n",
    "from torch import cuda\n",
    "device = 'cuda' if cuda.is_available() else 'cpu'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating the dataset for the model\n",
    "\n",
    "train_dataset = datasets.MNIST(root='./data/', train=True, transform=transforms.ToTensor(), download=True)\n",
    "test_dataset = datasets.MNIST(root='./data/', train=False, transform=transforms.ToTensor(), download=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating the dataloader for the input to the model\n",
    "\n",
    "train_dataloader = DataLoader(dataset=train_dataset, batch_size=32, shuffle=True)\n",
    "test_dataloader = DataLoader(dataset=test_dataset, batch_size=32, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is where we are defining the inception component, which is a network in itself. But once defined as a class we can then use the object ob this class in other networks as a reusable element. \n",
    "\n",
    "class InceptionM(torch.nn.Module):\n",
    "\n",
    "    # Initialize\n",
    "    def __init__(self, in_channels):\n",
    "        super(InceptionM, self).__init__()\n",
    "        self.branch_01_02 = torch.nn.Conv2d(in_channels, 24, kernel_size=1)\n",
    "        self.branch_02_01 = torch.nn.Conv2d(in_channels, 16, kernel_size=1)\n",
    "        \n",
    "        self.branch_03_01 = torch.nn.Conv2d(in_channels, 16, kernel_size=1)\n",
    "        self.branch_03_02 = torch.nn.Conv2d(16, 24, kernel_size=5, padding=2)\n",
    "\n",
    "        self.branch_04_01 = torch.nn.Conv2d(in_channels, 16, kernel_size=1)\n",
    "        self.branch_04_02 = torch.nn.Conv2d(16, 24, kernel_size=3, padding=1)\n",
    "        self.branch_04_03 = torch.nn.Conv2d(24, 24, kernel_size=3, padding=1)\n",
    "        \n",
    "        \n",
    "    def forward(self, x):\n",
    "        branch_01_02 = self.branch_01_02(torch.nn.functional.avg_pool2d(x, kernel_size=3, stride=1, padding=1))\n",
    "        \n",
    "        branch_02_01 = self.branch_02_01(x)\n",
    "        \n",
    "        branch_03_01 = self.branch_03_01(x)\n",
    "        branch_03_02 = self.branch_03_02(branch_03_01)\n",
    "\n",
    "        branch_04_01 = self.branch_04_01(x)\n",
    "        branch_04_02 = self.branch_04_02(branch_04_01)\n",
    "        branch_04_03 = self.branch_04_03(branch_04_02)\n",
    "\n",
    "        outputs = [branch_01_02,branch_02_01,branch_03_02,branch_04_03]\n",
    "\n",
    "        return torch.cat(outputs, 1)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "Model(\n  (conv1): Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1))\n  (conv2): Conv2d(88, 20, kernel_size=(5, 5), stride=(1, 1))\n  (incep_1): InceptionM(\n    (branch_01_02): Conv2d(10, 24, kernel_size=(1, 1), stride=(1, 1))\n    (branch_02_01): Conv2d(10, 16, kernel_size=(1, 1), stride=(1, 1))\n    (branch_03_01): Conv2d(10, 16, kernel_size=(1, 1), stride=(1, 1))\n    (branch_03_02): Conv2d(16, 24, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n    (branch_04_01): Conv2d(10, 16, kernel_size=(1, 1), stride=(1, 1))\n    (branch_04_02): Conv2d(16, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n    (branch_04_03): Conv2d(24, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n  )\n  (incep_2): InceptionM(\n    (branch_01_02): Conv2d(20, 24, kernel_size=(1, 1), stride=(1, 1))\n    (branch_02_01): Conv2d(20, 16, kernel_size=(1, 1), stride=(1, 1))\n    (branch_03_01): Conv2d(20, 16, kernel_size=(1, 1), stride=(1, 1))\n    (branch_03_02): Conv2d(16, 24, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n    (branch_04_01): Conv2d(20, 16, kernel_size=(1, 1), stride=(1, 1))\n    (branch_04_02): Conv2d(16, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n    (branch_04_03): Conv2d(24, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n  )\n  (l1): Linear(in_features=1408, out_features=10, bias=True)\n  (max): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n)"
     },
     "metadata": {},
     "execution_count": 6
    }
   ],
   "source": [
    "# Creating the Model\n",
    "\n",
    "class Model(torch.nn.Module):\n",
    "\n",
    "    ## Initiatize\n",
    "    def __init__(self):\n",
    "        super(Model, self).__init__()\n",
    "        self.conv1 = torch.nn.Conv2d(1,10,kernel_size=5)\n",
    "        self.conv2 = torch.nn.Conv2d(88,20,kernel_size=5)\n",
    "\n",
    "        self.incep_1 = InceptionM(in_channels=10)\n",
    "        self.incep_2 = InceptionM(in_channels=20)\n",
    "\n",
    "        self.l1 = torch.nn.Linear(1408, 10)\n",
    "\n",
    "        self.max = torch.nn.MaxPool2d(2)\n",
    "\n",
    "\n",
    "    ## Forward\n",
    "    def forward(self, x):\n",
    "        in_size = x.size(0)\n",
    "        x = torch.nn.functional.relu(self.max(self.conv1(x)))\n",
    "        x = self.incep_1(x)\n",
    "        x = torch.nn.functional.relu(self.max(self.conv2(x)))\n",
    "        x = self.incep_2(x)\n",
    "        x = x.view(in_size, -1)\n",
    "        x = self.l1(x)\n",
    "        return torch.nn.functional.log_softmax(x)\n",
    "\n",
    "model = Model()\n",
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the loss function and optimizer\n",
    "\n",
    "criterion = torch.nn.CrossEntropyLoss(reduction='mean')\n",
    "optimus = torch.optim.SGD(model.parameters(), lr = 0.01, momentum=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is the code for training\n",
    "\n",
    "def train(epoch):\n",
    "    model.train()\n",
    "    for _, data in enumerate(train_dataloader, 0):\n",
    "        inputs, labels = data\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # Forward pass\n",
    "        predict = model(inputs)\n",
    "\n",
    "        # loss\n",
    "        loss = criterion(predict, labels)\n",
    "        if _%500 == 0:\n",
    "            print(f'Epoch: {epoch}, Loss:  {loss.item()}')\n",
    "\n",
    "        # zero optimus,back propagation, update optimus\n",
    "        optimus.zero_grad()\n",
    "        loss.backward()\n",
    "        optimus.step()\n",
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This code is for the validation step\n",
    "\n",
    "def valid(test_dataloader):\n",
    "    model.eval()\n",
    "    total=0; n_correct =0 \n",
    "    with torch.no_grad():\n",
    "        for _, data in enumerate(test_dataloader,0):\n",
    "            inputs, labels = data\n",
    "            inputs = inputs.to(device)\n",
    "            labels = labels.to(device)\n",
    "\n",
    "            if _%500 == 0:\n",
    "                print(f'Validation completed for {_} samples')\n",
    "\n",
    "            predict = model(inputs)\n",
    "            total += labels.size(0)\n",
    "            big_val, big_idx = torch.max(predict.data, dim=1)\n",
    "            n_correct += (big_idx==labels).sum().item()\n",
    "\n",
    "    return (n_correct*100)/total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Starting the training\nEpoch: 0, Loss:  2.3154919147491455\nEpoch: 0, Loss:  0.5073910355567932\nEpoch: 0, Loss:  0.13816455006599426\nEpoch: 0, Loss:  0.17782428860664368\nEpoch: 1, Loss:  0.0799398273229599\nEpoch: 1, Loss:  0.021845880895853043\nEpoch: 1, Loss:  0.24345053732395172\nEpoch: 1, Loss:  0.059964992105960846\nTraining Completed\n+++++++++++++++++=================+++++++++++++++++=================++++++++++++++++\nStarting the testing\nValidation completed for 0 samples\nThe accuracy of the model is: 97.76\n"
    }
   ],
   "source": [
    "# Calling the training function\n",
    "\n",
    "print('Starting the training')\n",
    "\n",
    "for epoch in range(0,2):\n",
    "    train(epoch)\n",
    "\n",
    "print('Training Completed')\n",
    "\n",
    "print('+++++++++++++++++=================+++++++++++++++++=================++++++++++++++++')\n",
    "\n",
    "print('Starting the testing')\n",
    "accu = valid(test_dataloader)\n",
    "print(f'The accuracy of the model is: {accu}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}