lesson05-ConvNets/05_ConvNets_mnist.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "05_ConvNets_mnist.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "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/Alro10/PyTorch1.xTutorials/blob/master/lesson05-ConvNets/05_ConvNets_mnist.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oXdn6KjmUN2n",
        "colab_type": "text"
      },
      "source": [
        "# Convolutional Neural Networks\n",
        "\n",
        "We test a ConvNet on mnist dataset to show the impressive power of this type of neural network. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DNHWEqZxUVwC",
        "colab_type": "text"
      },
      "source": [
        "## Get dataset "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2MaN8flkqPHO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 270
        },
        "outputId": "a129c937-0795-4e19-bed7-692b31427fc8"
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "\n",
        "# Device configuration (use GPU or CPU)\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "# Hyper-parameters\n",
        "num_epochs = 5\n",
        "num_classes = 10\n",
        "batch_size = 100\n",
        "learning_rate = 0.001\n",
        "\n",
        "# MNIST dataset \n",
        "train_dataset = torchvision.datasets.MNIST(root='../../data', \n",
        "                                           train=True, \n",
        "                                           transform=transforms.ToTensor(),  \n",
        "                                           download=True)\n",
        "\n",
        "test_dataset = torchvision.datasets.MNIST(root='../../data', \n",
        "                                          train=False, \n",
        "                                          transform=transforms.ToTensor())\n",
        "\n",
        "# Data loader\n",
        "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, \n",
        "                                           batch_size=batch_size, \n",
        "                                           shuffle=True)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, \n",
        "                                          batch_size=batch_size, \n",
        "                                          shuffle=False)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 0/9912422 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ../../data/MNIST/raw/train-images-idx3-ubyte.gz\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "9920512it [00:00, 21821747.76it/s]                            \n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Extracting ../../data/MNIST/raw/train-images-idx3-ubyte.gz\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "32768it [00:00, 329849.27it/s]\n",
            "0it [00:00, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ../../data/MNIST/raw/train-labels-idx1-ubyte.gz\n",
            "Extracting ../../data/MNIST/raw/train-labels-idx1-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ../../data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "1654784it [00:00, 5722015.23it/s]                           \n",
            "8192it [00:00, 128067.01it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Extracting ../../data/MNIST/raw/t10k-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ../../data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n",
            "Extracting ../../data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n",
            "Processing...\n",
            "Done!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g5IOyG-AUhQS",
        "colab_type": "text"
      },
      "source": [
        "## Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aDETL55SUrvh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Convolutional neural network (two convolutional layers)\n",
        "class ConvNet(nn.Module):\n",
        "    def __init__(self, num_classes):\n",
        "        super(ConvNet, self).__init__()\n",
        "        self.layer1 = nn.Sequential(\n",
        "            nn.Conv2d(1, 16, kernel_size=5, stride=1, padding=2),\n",
        "            nn.BatchNorm2d(16),\n",
        "            nn.ReLU(),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2))\n",
        "        self.layer2 = nn.Sequential(\n",
        "            nn.Conv2d(16, 32, kernel_size=5, stride=1, padding=2),\n",
        "            nn.BatchNorm2d(32),\n",
        "            nn.ReLU(),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2))\n",
        "        self.fc = nn.Linear(7*7*32, num_classes)\n",
        "        \n",
        "    def forward(self, x):\n",
        "        out = self.layer1(x)\n",
        "        out = self.layer2(out)\n",
        "        out = out.reshape(out.size(0), -1)\n",
        "        out = self.fc(out)\n",
        "        return out"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8crPS3poVDRR",
        "colab_type": "text"
      },
      "source": [
        "## Training step"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VvFpofy8VC3S",
        "colab_type": "code",
        "outputId": "bc9ef999-21b1-469b-d5f2-590ab461c075",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        }
      },
      "source": [
        "model = ConvNet(num_classes).to(device)\n",
        "\n",
        "# Loss and optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)  \n",
        "\n",
        "# Train the model\n",
        "total_step = len(train_loader)\n",
        "for epoch in range(num_epochs):\n",
        "    for i, (images, labels) in enumerate(train_loader):\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        \n",
        "        # Forward pass\n",
        "        outputs = model(images)\n",
        "        loss = criterion(outputs, labels)\n",
        "        \n",
        "        # Backward and optimize\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        \n",
        "        if (i+1) % 100 == 0:\n",
        "            print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' \n",
        "                   .format(epoch+1, num_epochs, i+1, total_step, loss.item()))\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch [1/5], Step [100/600], Loss: 0.1284\n",
            "Epoch [1/5], Step [200/600], Loss: 0.1610\n",
            "Epoch [1/5], Step [300/600], Loss: 0.0267\n",
            "Epoch [1/5], Step [400/600], Loss: 0.0465\n",
            "Epoch [1/5], Step [500/600], Loss: 0.0190\n",
            "Epoch [1/5], Step [600/600], Loss: 0.0498\n",
            "Epoch [2/5], Step [100/600], Loss: 0.0293\n",
            "Epoch [2/5], Step [200/600], Loss: 0.0777\n",
            "Epoch [2/5], Step [300/600], Loss: 0.0684\n",
            "Epoch [2/5], Step [400/600], Loss: 0.0168\n",
            "Epoch [2/5], Step [500/600], Loss: 0.0724\n",
            "Epoch [2/5], Step [600/600], Loss: 0.0167\n",
            "Epoch [3/5], Step [100/600], Loss: 0.0467\n",
            "Epoch [3/5], Step [200/600], Loss: 0.0122\n",
            "Epoch [3/5], Step [300/600], Loss: 0.0590\n",
            "Epoch [3/5], Step [400/600], Loss: 0.0660\n",
            "Epoch [3/5], Step [500/600], Loss: 0.0553\n",
            "Epoch [3/5], Step [600/600], Loss: 0.0337\n",
            "Epoch [4/5], Step [100/600], Loss: 0.0249\n",
            "Epoch [4/5], Step [200/600], Loss: 0.0158\n",
            "Epoch [4/5], Step [300/600], Loss: 0.0282\n",
            "Epoch [4/5], Step [400/600], Loss: 0.0113\n",
            "Epoch [4/5], Step [500/600], Loss: 0.0148\n",
            "Epoch [4/5], Step [600/600], Loss: 0.0132\n",
            "Epoch [5/5], Step [100/600], Loss: 0.0047\n",
            "Epoch [5/5], Step [200/600], Loss: 0.0066\n",
            "Epoch [5/5], Step [300/600], Loss: 0.0340\n",
            "Epoch [5/5], Step [400/600], Loss: 0.0547\n",
            "Epoch [5/5], Step [500/600], Loss: 0.0132\n",
            "Epoch [5/5], Step [600/600], Loss: 0.0155\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0EOfxK13VXZX",
        "colab_type": "text"
      },
      "source": [
        "## Accuracy "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PVmup4K8Vc3c",
        "colab_type": "code",
        "outputId": "4800aea8-cbb5-45dd-bcf4-b2ed42e1b192",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        }
      },
      "source": [
        "# Test the model\n",
        "model.eval()  # eval mode (batchnorm uses moving mean/variance instead of mini-batch mean/variance)\n",
        "with torch.no_grad():\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    for images, labels in test_loader:\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        outputs = model(images)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        total += labels.size(0)\n",
        "        correct += (predicted == labels).sum().item()\n",
        "\n",
        "    print('Test Accuracy of the model on the 10000 test images: {} %'.format(100 * correct / total))"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Test Accuracy of the model on the 10000 test images: 99.06 %\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L1aXKY_SVgQ1",
        "colab_type": "text"
      },
      "source": [
        "## Save model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1gTusF_zVhsU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Save the model checkpoint\n",
        "torch.save(model.state_dict(), 'model_conv_net.ckpt')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HvARF24eVjXP",
        "colab_type": "code",
        "outputId": "00f39eda-6cbc-44ca-94cd-6c0af497be4f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        }
      },
      "source": [
        "!ls"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "model_conv_net.ckpt  sample_data\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}