Copy_of_EVA4_Session_2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of EVA4 - Session 2.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/dhruv369/AI/blob/master/Copy_of_EVA4_Session_2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0m2JWFliFfKT"
      },
      "source": [
        "from __future__ import print_function\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "from torchvision import datasets, transforms"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h_Cx9q2QFgM7"
      },
      "source": [
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(1, 32, 3, padding=1) #1 x 28 x 28 -? 32 x 28 x28 ? 3\n",
        "        self.bnorm1 = nn.BatchNorm2d(32)\n",
        "\n",
        "        self.conv2 = nn.Conv2d(32, 32, 3, padding=1) #32 x 28 x 28 -? 32 x 28 x28 ? 5\n",
        "        self.bnorm2 = nn.BatchNorm2d(32)\n",
        "\n",
        "        self.conv3 = nn.Conv2d(32, 32, 3, padding=1) #32 x 28 x 28 -? 32 x 28 x28 ? 7\n",
        "        self.bnorm3 = nn.BatchNorm2d(32)\n",
        "        self.pool1 = nn.MaxPool2d(2, 2) #32 x 28 x 28 -? 32 x 14 x14 ? 14\n",
        "        self.drop1 = nn.Dropout(0.25)\n",
        "\n",
        "        self.conv4 = nn.Conv2d(32, 64, 3, padding=1) #32 x 14 x 14 ? 64 x 14 x 14 ? 9\n",
        "        self.bnorm4 = nn.BatchNorm2d(64)\n",
        "        self.pool2 = nn.MaxPool2d(2, 2) #64 x 7 x 7 ? 9\n",
        "\n",
        "        self.conv5 = nn.Conv2d(64, 64, 3,padding=1)\n",
        "        self.bnorm5 = nn.BatchNorm2d(64)\n",
        "        self.pool3 = nn.MaxPool2d(2, 2)\n",
        "        self.drop2 = nn.Dropout(0.25)\n",
        "        \n",
        "        # self.conv6 = nn.Conv2d(64, 128, 3,padding=1)\n",
        "        # self.bnorm5 = nn.BatchNorm2d(128)\n",
        "        # self.pool4 = nn.MaxPool2d(2, 2)\n",
        "        # self.drop3 = nn.Dropout(0.25)\n",
        "\n",
        "        self.avgpl1 = nn.AvgPool2d(3, padding=1)\n",
        "\n",
        "        self.fc1   = nn.Linear(64, 32)\n",
        "        self.fc2   = nn.Linear(32, 10)\n",
        "\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.bnorm1(F.relu(self.conv1(x)))\n",
        "        x = self.bnorm2(F.relu(self.conv2(x)))\n",
        "        x = self.bnorm3(F.relu(self.conv3(x)))\n",
        "        x = self.drop1(self.pool1(x))\n",
        "        x = self.bnorm4(F.relu(self.conv4(x)))\n",
        "        x = self.pool2(x)\n",
        "        x = self.bnorm5(F.relu(self.conv5(x)))\n",
        "        x = self.drop2(self.pool3(x))\n",
        "        # x = self.bnorm5(F.relu(self.conv6(x)))\n",
        "        # x = self.drop3(self.pool4(x))\n",
        "        x = self.avgpl1(x)\n",
        "        # x = F.relu(self.conv7(x))\n",
        "        # x = x.view(-1, 10)\n",
        "        x = x.view(x.size(0), -1)\n",
        "        x = self.fc2(self.fc1(x))\n",
        "        return F.log_softmax(x)"
      ],
      "execution_count": 91,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xdydjYTZFyi3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f25990a5-9663-4078-8f0a-c89dff77e7c1"
      },
      "source": [
        "!pip install torchsummary\n",
        "from torchsummary import summary\n",
        "use_cuda = torch.cuda.is_available()\n",
        "device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n",
        "model = Net().to(device)\n",
        "summary(model, input_size=(1, 28, 28))"
      ],
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: torchsummary in /usr/local/lib/python3.7/dist-packages (1.5.1)\n",
            "----------------------------------------------------------------\n",
            "        Layer (type)               Output Shape         Param #\n",
            "================================================================\n",
            "            Conv2d-1           [-1, 32, 28, 28]             320\n",
            "       BatchNorm2d-2           [-1, 32, 28, 28]              64\n",
            "            Conv2d-3           [-1, 32, 28, 28]           9,248\n",
            "       BatchNorm2d-4           [-1, 32, 28, 28]              64\n",
            "            Conv2d-5           [-1, 32, 28, 28]           9,248\n",
            "       BatchNorm2d-6           [-1, 32, 28, 28]              64\n",
            "         MaxPool2d-7           [-1, 32, 14, 14]               0\n",
            "           Dropout-8           [-1, 32, 14, 14]               0\n",
            "            Conv2d-9           [-1, 64, 14, 14]          18,496\n",
            "      BatchNorm2d-10           [-1, 64, 14, 14]             128\n",
            "        MaxPool2d-11             [-1, 64, 7, 7]               0\n",
            "           Conv2d-12             [-1, 64, 7, 7]          36,928\n",
            "      BatchNorm2d-13             [-1, 64, 7, 7]             128\n",
            "        MaxPool2d-14             [-1, 64, 3, 3]               0\n",
            "          Dropout-15             [-1, 64, 3, 3]               0\n",
            "        AvgPool2d-16             [-1, 64, 1, 1]               0\n",
            "           Linear-17                   [-1, 32]           2,080\n",
            "           Linear-18                   [-1, 10]             330\n",
            "================================================================\n",
            "Total params: 77,098\n",
            "Trainable params: 77,098\n",
            "Non-trainable params: 0\n",
            "----------------------------------------------------------------\n",
            "Input size (MB): 0.00\n",
            "Forward/backward pass size (MB): 1.52\n",
            "Params size (MB): 0.29\n",
            "Estimated Total Size (MB): 1.81\n",
            "----------------------------------------------------------------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:51: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DqTWLaM5GHgH"
      },
      "source": [
        "\n",
        "\n",
        "torch.manual_seed(1)\n",
        "batch_size = 128\n",
        "\n",
        "kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}\n",
        "train_loader = torch.utils.data.DataLoader(\n",
        "    datasets.MNIST('../data', train=True, download=True,\n",
        "                    transform=transforms.Compose([\n",
        "                        transforms.ToTensor(),\n",
        "                        transforms.Normalize((0.1307,), (0.3081,))\n",
        "                    ])),\n",
        "    batch_size=batch_size, shuffle=True, **kwargs)\n",
        "test_loader = torch.utils.data.DataLoader(\n",
        "    datasets.MNIST('../data', train=False, transform=transforms.Compose([\n",
        "                        transforms.ToTensor(),\n",
        "                        transforms.Normalize((0.1307,), (0.3081,))\n",
        "                    ])),\n",
        "    batch_size=batch_size, shuffle=True, **kwargs)\n"
      ],
      "execution_count": 93,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8fDefDhaFlwH"
      },
      "source": [
        "from tqdm import tqdm\n",
        "def train(model, device, train_loader, optimizer, epoch):\n",
        "    model.train()\n",
        "    pbar = tqdm(train_loader)\n",
        "    for batch_idx, (data, target) in enumerate(pbar):\n",
        "        data, target = data.to(device), target.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        output = model(data)\n",
        "        loss = F.nll_loss(output, target)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        pbar.set_description(desc= f'loss={loss.item()} batch_id={batch_idx}')\n",
        "\n",
        "\n",
        "def test(model, device, test_loader):\n",
        "    model.eval()\n",
        "    test_loss = 0\n",
        "    correct = 0\n",
        "    with torch.no_grad():\n",
        "        for data, target in test_loader:\n",
        "            data, target = data.to(device), target.to(device)\n",
        "            output = model(data)\n",
        "            test_loss += F.nll_loss(output, target, reduction='sum').item()  # sum up batch loss\n",
        "            pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability\n",
        "            correct += pred.eq(target.view_as(pred)).sum().item()\n",
        "\n",
        "    test_loss /= len(test_loader.dataset)\n",
        "\n",
        "    print('\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
        "        test_loss, correct, len(test_loader.dataset),\n",
        "        100. * correct / len(test_loader.dataset)))"
      ],
      "execution_count": 94,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MMWbLWO6FuHb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c0d7b4ab-929d-41e6-b185-49733567b3ec"
      },
      "source": [
        "\n",
        "model = Net().to(device)\n",
        "optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)\n",
        "\n",
        "for epoch in range(1, 20):\n",
        "    train(model, device, train_loader, optimizer, epoch)\n",
        "    test(model, device, test_loader)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  0%|          | 0/469 [00:00<?, ?it/s]/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:51: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "loss=0.13929612934589386 batch_id=468: 100%|██████████| 469/469 [00:21<00:00, 21.82it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Test set: Average loss: 0.0692, Accuracy: 9791/10000 (98%)\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "loss=0.07430944591760635 batch_id=468: 100%|██████████| 469/469 [00:21<00:00, 21.63it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Test set: Average loss: 0.0488, Accuracy: 9853/10000 (99%)\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "loss=0.021886378526687622 batch_id=468: 100%|██████████| 469/469 [00:21<00:00, 22.06it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Test set: Average loss: 0.0372, Accuracy: 9879/10000 (99%)\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "loss=0.13809806108474731 batch_id=468: 100%|██████████| 469/469 [00:21<00:00, 22.22it/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "So5uk4EkHW6R"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}