MNIST_Classification_Model_[GPU].ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "MNIST Classification Model [GPU].ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMKaL/axmTjpGUONvte5r/I",
      "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/jelegend/ANN-MLsummerproject/blob/master/MNIST_Classification_Model_%5BGPU%5D.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0dFDbjdQtLD0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torchvision.transforms as transforms\n",
        "from torchvision import datasets\n",
        "from torch.nn import functional\n",
        "import torchvision\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.pyplot as plt\n",
        "import time\n",
        "from IPython import display"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GRPe6xBlm0Cj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "43b7e4b4-bcb6-438a-8a9e-3edea503a77e"
      },
      "source": [
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(device)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "cuda:0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N-blJng0tSdI",
        "colab_type": "code",
        "outputId": "5a89c266-9854-4a00-8a07-ccb9506083a5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,), (0.5,))])\n",
        "\n",
        "\n",
        "trainset = datasets.MNIST('PATH_TO_STORE_TRAINSET', download=True, train=True, transform=transform)\n",
        "testset = datasets.MNIST('PATH_TO_STORE_TESTSET', download=True, train=False, transform=transform)\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=16, shuffle=True)\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=16, shuffle=True)\n",
        "\n",
        "dataiter = iter(trainloader)\n",
        "images, labels = dataiter.next()[0].to(device), dataiter.next()[1].to(device)\n",
        "\n",
        "print(images.shape)\n",
        "print(labels.shape)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([16, 1, 28, 28])\n",
            "torch.Size([16])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4CukjLVtx5CA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 154
        },
        "outputId": "10278ad0-3995-4d1a-dc8b-38eff409d475"
      },
      "source": [
        "def imshow(img):\n",
        "  img = img/2+0.5\n",
        "  npimg = img.numpy()\n",
        "  plt.imshow(np.transpose(img,(1,2,0)))\n",
        "  plt.show()\n",
        "dataiter = iter(trainloader)\n",
        "image ,labels = dataiter.next()\n",
        "imshow(torchvision.utils.make_grid(image))\n",
        "print(labels.shape,image.shape)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "torch.Size([16]) torch.Size([16, 1, 28, 28])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KnYtckBNtvXQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Network(nn.Module):\n",
        "    \n",
        "    def __init__(self):\n",
        "        super(Network, self).__init__()\n",
        "        # convolutional layer\n",
        "        self.conv1 = nn.Conv2d(in_channels=1,out_channels=32, kernel_size=(3,3), stride=1)\n",
        "        # convolutional layer\n",
        "        self.conv2 = nn.Conv2d(in_channels=32,out_channels=64, kernel_size=(3,3), stride=1)\n",
        "        # max pooling layer\n",
        "        self.pool = nn.MaxPool2d(kernel_size = (2,2),stride=2)\n",
        "        # dropout layer 1 (p=0.25)\n",
        "        self.dropout1 = nn.Dropout(0.25)\n",
        "        # linear layer (9216 -> 128)\n",
        "        self.fc1 = nn.Linear(9216, 128)\n",
        "        # dropout layer 2 (p=0.5)\n",
        "        self.dropout2 = nn.Dropout(0.5)\n",
        "        # linear layer (500 -> 10)\n",
        "        self.fc2 = nn.Linear(128, 10)\n",
        "\n",
        "        \n",
        "    def forward(self, x):\n",
        "       # add sequence of convolutional and max pooling layers\n",
        "        x = torch.relu(self.conv1(x))\n",
        "        x = torch.relu(self.conv2(x))\n",
        "        x = self.pool(x)\n",
        "        #Flattening the output for the Linear layers\n",
        "        x = x.view(x.size(0),-1) \n",
        "        #Dropout Layer\n",
        "        x = self.dropout1(x)\n",
        "        #Linear fully-connected layer and ReLU\n",
        "        x = torch.relu(self.fc1(x))\n",
        "        #Dropout Layer\n",
        "        x = self.dropout2(x)\n",
        "        #Linear fully-connected layer and Softmax\n",
        "        x = torch.softmax(self.fc2(x), dim=1)\n",
        "        \n",
        "        return x\n",
        "\n",
        "net = Network().cuda()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qTTJzenusTN0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OkXvZ6cMzEdh",
        "colab_type": "code",
        "outputId": "251fc148-ec89-4679-dc24-3f7e7b30206d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "for epoch in range(5):  # loop over the dataset multiple times\n",
        "\n",
        "    running_loss = 0.0\n",
        "    for i, data in enumerate(trainloader, 0):\n",
        "        # get the inputs; data is a list of [inputs, labels]\n",
        "        inputs, labels = data[0].to(device), data[1].to(device)\n",
        "\n",
        "        # zero the parameter gradients\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        # forward + backward + optimize\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # print statistics\n",
        "        running_loss += loss.item()\n",
        "        if i % 134 == 133:    # print every 500 mini-batches\n",
        "            print('[%d, %5d] loss: %.3f' %\n",
        "                  (epoch + 1, i + 1, running_loss / 133))\n",
        "            running_loss = 0.0\n",
        "\n",
        "print('Finished Training')"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1,   134] loss: 2.319\n",
            "[1,   268] loss: 2.315\n",
            "[1,   402] loss: 2.309\n",
            "[1,   536] loss: 2.300\n",
            "[1,   670] loss: 2.279\n",
            "[1,   804] loss: 2.200\n",
            "[1,   938] loss: 2.020\n",
            "[1,  1072] loss: 1.902\n",
            "[1,  1206] loss: 1.844\n",
            "[1,  1340] loss: 1.777\n",
            "[1,  1474] loss: 1.749\n",
            "[1,  1608] loss: 1.731\n",
            "[1,  1742] loss: 1.688\n",
            "[1,  1876] loss: 1.686\n",
            "[1,  2010] loss: 1.669\n",
            "[1,  2144] loss: 1.653\n",
            "[1,  2278] loss: 1.650\n",
            "[1,  2412] loss: 1.630\n",
            "[1,  2546] loss: 1.633\n",
            "[1,  2680] loss: 1.633\n",
            "[1,  2814] loss: 1.624\n",
            "[1,  2948] loss: 1.624\n",
            "[1,  3082] loss: 1.621\n",
            "[1,  3216] loss: 1.617\n",
            "[1,  3350] loss: 1.608\n",
            "[1,  3484] loss: 1.611\n",
            "[1,  3618] loss: 1.613\n",
            "[2,   134] loss: 1.602\n",
            "[2,   268] loss: 1.598\n",
            "[2,   402] loss: 1.608\n",
            "[2,   536] loss: 1.590\n",
            "[2,   670] loss: 1.595\n",
            "[2,   804] loss: 1.586\n",
            "[2,   938] loss: 1.593\n",
            "[2,  1072] loss: 1.594\n",
            "[2,  1206] loss: 1.587\n",
            "[2,  1340] loss: 1.587\n",
            "[2,  1474] loss: 1.590\n",
            "[2,  1608] loss: 1.587\n",
            "[2,  1742] loss: 1.573\n",
            "[2,  1876] loss: 1.576\n",
            "[2,  2010] loss: 1.572\n",
            "[2,  2144] loss: 1.575\n",
            "[2,  2278] loss: 1.574\n",
            "[2,  2412] loss: 1.576\n",
            "[2,  2546] loss: 1.580\n",
            "[2,  2680] loss: 1.572\n",
            "[2,  2814] loss: 1.569\n",
            "[2,  2948] loss: 1.569\n",
            "[2,  3082] loss: 1.570\n",
            "[2,  3216] loss: 1.573\n",
            "[2,  3350] loss: 1.561\n",
            "[2,  3484] loss: 1.565\n",
            "[2,  3618] loss: 1.568\n",
            "[3,   134] loss: 1.566\n",
            "[3,   268] loss: 1.568\n",
            "[3,   402] loss: 1.556\n",
            "[3,   536] loss: 1.547\n",
            "[3,   670] loss: 1.557\n",
            "[3,   804] loss: 1.566\n",
            "[3,   938] loss: 1.563\n",
            "[3,  1072] loss: 1.561\n",
            "[3,  1206] loss: 1.557\n",
            "[3,  1340] loss: 1.550\n",
            "[3,  1474] loss: 1.558\n",
            "[3,  1608] loss: 1.559\n",
            "[3,  1742] loss: 1.564\n",
            "[3,  1876] loss: 1.545\n",
            "[3,  2010] loss: 1.559\n",
            "[3,  2144] loss: 1.553\n",
            "[3,  2278] loss: 1.556\n",
            "[3,  2412] loss: 1.552\n",
            "[3,  2546] loss: 1.549\n",
            "[3,  2680] loss: 1.556\n",
            "[3,  2814] loss: 1.554\n",
            "[3,  2948] loss: 1.548\n",
            "[3,  3082] loss: 1.540\n",
            "[3,  3216] loss: 1.543\n",
            "[3,  3350] loss: 1.547\n",
            "[3,  3484] loss: 1.541\n",
            "[3,  3618] loss: 1.550\n",
            "[4,   134] loss: 1.551\n",
            "[4,   268] loss: 1.541\n",
            "[4,   402] loss: 1.543\n",
            "[4,   536] loss: 1.543\n",
            "[4,   670] loss: 1.551\n",
            "[4,   804] loss: 1.539\n",
            "[4,   938] loss: 1.532\n",
            "[4,  1072] loss: 1.545\n",
            "[4,  1206] loss: 1.530\n",
            "[4,  1340] loss: 1.533\n",
            "[4,  1474] loss: 1.537\n",
            "[4,  1608] loss: 1.547\n",
            "[4,  1742] loss: 1.535\n",
            "[4,  1876] loss: 1.541\n",
            "[4,  2010] loss: 1.538\n",
            "[4,  2144] loss: 1.540\n",
            "[4,  2278] loss: 1.538\n",
            "[4,  2412] loss: 1.538\n",
            "[4,  2546] loss: 1.537\n",
            "[4,  2680] loss: 1.535\n",
            "[4,  2814] loss: 1.536\n",
            "[4,  2948] loss: 1.528\n",
            "[4,  3082] loss: 1.531\n",
            "[4,  3216] loss: 1.535\n",
            "[4,  3350] loss: 1.527\n",
            "[4,  3484] loss: 1.530\n",
            "[4,  3618] loss: 1.535\n",
            "[5,   134] loss: 1.534\n",
            "[5,   268] loss: 1.529\n",
            "[5,   402] loss: 1.526\n",
            "[5,   536] loss: 1.524\n",
            "[5,   670] loss: 1.526\n",
            "[5,   804] loss: 1.526\n",
            "[5,   938] loss: 1.526\n",
            "[5,  1072] loss: 1.523\n",
            "[5,  1206] loss: 1.530\n",
            "[5,  1340] loss: 1.528\n",
            "[5,  1474] loss: 1.529\n",
            "[5,  1608] loss: 1.525\n",
            "[5,  1742] loss: 1.533\n",
            "[5,  1876] loss: 1.530\n",
            "[5,  2010] loss: 1.526\n",
            "[5,  2144] loss: 1.527\n",
            "[5,  2278] loss: 1.517\n",
            "[5,  2412] loss: 1.523\n",
            "[5,  2546] loss: 1.520\n",
            "[5,  2680] loss: 1.529\n",
            "[5,  2814] loss: 1.528\n",
            "[5,  2948] loss: 1.526\n",
            "[5,  3082] loss: 1.523\n",
            "[5,  3216] loss: 1.524\n",
            "[5,  3350] loss: 1.526\n",
            "[5,  3484] loss: 1.528\n",
            "[5,  3618] loss: 1.525\n",
            "Finished Training\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zOaUw6rnnTTl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d070d404-3500-48e7-a54e-ac133b50078e"
      },
      "source": [
        "for i, data in enumerate(testloader, 0):\n",
        "  images = data[0].to(device)\n",
        "  labels = data[1].to(device)\n",
        "print(labels)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([9, 1, 4, 1, 2, 1, 6, 3, 5, 4, 8, 5, 3, 6, 3, 1], device='cuda:0')\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UIkQw37lv-n2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "c3f75e89-e8d4-4f64-e334-043cdf893580"
      },
      "source": [
        "outputs = net(images)\n",
        "_, predicted = torch.max(outputs, 1)\n",
        "\n",
        "classes = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9')\n",
        "\n",
        "print('Ground Truth: ', ' '.join('%1s' % classes[labels[j]] for j in range(16)))\n",
        "print('Predicted:    ', ' '.join('%1s' % classes[predicted[j]] for j in range(16)))\n",
        "# print images\n",
        "imshow(torchvision.utils.make_grid(images.cpu()))\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ground Truth:  9 1 4 1 2 1 6 3 5 4 8 5 3 6 3 1\n",
            "Predicted:     9 1 4 1 2 1 4 3 5 4 8 5 3 6 7 1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wepY0fGOteMk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f080a514-4693-4d25-e5ba-4abe5efee247"
      },
      "source": [
        "correct = 0\n",
        "total = 0\n",
        "with torch.no_grad():\n",
        "    for i, data in enumerate(testloader, 0):\n",
        "        inputs, labels = data[0].to(device), data[1].to(device)\n",
        "        outputs = net(inputs)\n",
        "        _, predicted = torch.max(outputs, 1)\n",
        "        total += labels.size(0)\n",
        "        correct += (predicted == labels).sum().item()\n",
        "\n",
        "print('Accuracy of the network on the 20000 test images: %d %%' % (\n",
        "    100 * correct / total))"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy of the network on the 20000 test images: 95 %\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kfoo6Xjnv1GZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 185
        },
        "outputId": "bf1d28d9-1c0a-49ec-cb5d-861c6b4b3be3"
      },
      "source": [
        "class_correct = list(0. for i in range(10))\n",
        "class_total = list(0. for i in range(10))\n",
        "with torch.no_grad():\n",
        "    for i, data in enumerate(testloader, 0):\n",
        "        inputs, labels = data[0].to(device), data[1].to(device)\n",
        "        outputs = net(inputs)\n",
        "        _, predicted = torch.max(outputs, 1)\n",
        "        c = (predicted == labels).squeeze()\n",
        "        for i in range(4):\n",
        "            label = labels[i]\n",
        "            class_correct[label] += c[i].item()\n",
        "            class_total[label] += 1\n",
        "\n",
        "\n",
        "for i in range(10):\n",
        "    print('Accuracy of %5s : %2d %%' % (\n",
        "        classes[i], 100 * class_correct[i] / class_total[i]))"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy of     0 : 98 %\n",
            "Accuracy of     1 : 98 %\n",
            "Accuracy of     2 : 94 %\n",
            "Accuracy of     3 : 95 %\n",
            "Accuracy of     4 : 96 %\n",
            "Accuracy of     5 : 96 %\n",
            "Accuracy of     6 : 97 %\n",
            "Accuracy of     7 : 96 %\n",
            "Accuracy of     8 : 94 %\n",
            "Accuracy of     9 : 91 %\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}