classifier-MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mlxtend.data import loadlocal_mnist\n",
    "import platform\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data import sampler\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import torchvision.datasets as dset\n",
    "import torchvision.transforms as T\n",
    "import torchvision\n",
    "\n",
    "# from process_classifier_data import *\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "using device: cuda\n"
     ]
    }
   ],
   "source": [
    "USE_GPU = True\n",
    "\n",
    "dtype = torch.float32 # we will be using float throughout this tutorial\n",
    "\n",
    "if USE_GPU and torch.cuda.is_available():\n",
    "    device = torch.device('cuda')\n",
    "else:\n",
    "    device = torch.device('cpu')\n",
    "\n",
    "# Constant to control how frequently we print train loss\n",
    "print_every = 100\n",
    "\n",
    "print('using device:', device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#classifier for MNIST\n",
    "\n",
    "# X, y = loadlocal_mnist(\n",
    "#         images_path='train-images-idx3-ubyte', \n",
    "#         labels_path='train-labels-idx1-ubyte')\n",
    "# test_X, test_y = loadlocal_mnist(\n",
    "#         images_path='t10k-images-idx3-ubyte', \n",
    "#         labels_path='t10k-labels-idx1-ubyte')\n",
    "# X = X.reshape((X.shape[0], 28, 28))\n",
    "# test_X = test_X.reshape((test_X.shape[0], 28, 28))\n",
    "\n",
    "# print('X Dimensions: %s x %s x %s' % (X.shape[0], X.shape[1], X.shape[2]))\n",
    "# print('y Dimensions: %s' % (y.shape[0]))\n",
    "#load dataset from numpy\n",
    "\n",
    "#load directly https://pytorch.org/docs/stable/torchvision/datasets.html#id37\n",
    "batch_size_train = 64\n",
    "batch_size_test = 1000\n",
    "NUM_TRAIN = 59000\n",
    "\n",
    "MNIST_train = torchvision.datasets.MNIST('/files/', train=True, download=True,\n",
    "                             transform=torchvision.transforms.Compose([\n",
    "                               torchvision.transforms.ToTensor(),\n",
    "                               torchvision.transforms.Normalize(\n",
    "                                 (0.1307,), (0.3081,))\n",
    "                             ]))\n",
    "MNIST_test = torchvision.datasets.MNIST('/files/', train=False, download=True,\n",
    "                             transform=torchvision.transforms.Compose([\n",
    "                               torchvision.transforms.ToTensor(),\n",
    "                               torchvision.transforms.Normalize(\n",
    "                                 (0.1307,), (0.3081,))\n",
    "                             ]))\n",
    "\n",
    "loader_train = torch.utils.data.DataLoader(MNIST_train, batch_size=batch_size_train, \n",
    "                                           sampler=sampler.SubsetRandomSampler(range(NUM_TRAIN)))\n",
    "\n",
    "loader_val = torch.utils.data.DataLoader(MNIST_train, batch_size=batch_size_train, \n",
    "                                           sampler=sampler.SubsetRandomSampler(range(NUM_TRAIN, 60000)))\n",
    "\n",
    "loader_test = torch.utils.data.DataLoader( MNIST_test, batch_size=batch_size_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1000, 1, 28, 28])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "examples = enumerate(loader_test)\n",
    "batch_idx, (example_data, example_targets) = next(examples)\n",
    "example_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "for i in range(6):\n",
    "    plt.subplot(2,3,i+1)\n",
    "    plt.tight_layout()\n",
    "    plt.imshow(example_data[i][0], cmap='gray', interpolation='none')\n",
    "    plt.title(\"Ground Truth: {}\".format(example_targets[i]))\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_accuracy_part34(loader, model):\n",
    "    if loader.dataset.train:\n",
    "        print('Checking accuracy on validation set')\n",
    "    else:\n",
    "        print('Checking accuracy on test set')   \n",
    "    num_correct = 0\n",
    "    num_samples = 0\n",
    "    model.eval()  # set model to evaluation mode\n",
    "    with torch.no_grad():\n",
    "        for x, y in loader:\n",
    "            x = x.to(device=device, dtype=dtype)  # move to device, e.g. GPU\n",
    "            y = y.to(device=device, dtype=torch.long)\n",
    "            scores = model(x)\n",
    "            _, preds = scores.max(1)\n",
    "            num_correct += (preds == y).sum()\n",
    "            num_samples += preds.size(0)\n",
    "        acc = float(num_correct) / num_samples\n",
    "        print('Got %d / %d correct (%.2f)' % (num_correct, num_samples, 100 * acc))\n",
    "        return acc\n",
    "        \n",
    "def train_part34(model, optimizer, epochs=1):\n",
    "    \"\"\"\n",
    "    Train a model on CIFAR-10 using the PyTorch Module API.\n",
    "    \n",
    "    Inputs:\n",
    "    - model: A PyTorch Module giving the model to train.\n",
    "    - optimizer: An Optimizer object we will use to train the model\n",
    "    - epochs: (Optional) A Python integer giving the number of epochs to train for\n",
    "    \n",
    "    Returns: Nothing, but prints model accuracies during training.\n",
    "    \"\"\"\n",
    "    train_acc = []\n",
    "    val_acc = []\n",
    "    model = model.to(device=device)  # move the model parameters to CPU/GPU\n",
    "    for e in range(epochs):\n",
    "        for t, (x, y) in enumerate(loader_train):\n",
    "            model.train()  # put model to training mode\n",
    "            x = x.to(device=device, dtype=dtype)  # move to device, e.g. GPU\n",
    "            y = y.to(device=device, dtype=torch.long)\n",
    "\n",
    "            scores = model(x)\n",
    "            loss = F.cross_entropy(scores, y)\n",
    "            #loss = F.nll_loss(scores, y)\n",
    "\n",
    "            # Zero out all of the gradients for the variables which the optimizer\n",
    "            # will update.\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            # This is the backwards pass: compute the gradient of the loss with\n",
    "            # respect to each  parameter of the model.\n",
    "            loss.backward()\n",
    "\n",
    "            # Actually update the parameters of the model using the gradients\n",
    "            # computed by the backwards pass.\n",
    "            optimizer.step()\n",
    "\n",
    "            if t % print_every == 0:\n",
    "                print('Iteration %d, loss = %.4f' % (t, loss.item()))\n",
    "                train_acc.append(check_accuracy_part34(loader_train, model))\n",
    "                print()\n",
    "                print('Iteration %d, loss = %.4f' % (t, loss.item()))\n",
    "                val_acc.append(check_accuracy_part34(loader_val, model))\n",
    "                print()\n",
    "    return train_acc, val_acc\n",
    "                \n",
    "def flatten(x):\n",
    "    N = x.shape[0] # read in N, C, H, W\n",
    "    return x.view(N, -1)  # \"flatten\" the C * H * W values into a single vector per image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 0, loss = 2.3086\n",
      "Checking accuracy on validation set\n",
      "Got 6028 / 59000 correct (10.22)\n",
      "\n",
      "Iteration 0, loss = 2.3086\n",
      "Checking accuracy on validation set\n",
      "Got 103 / 1000 correct (10.30)\n",
      "\n",
      "Iteration 100, loss = 1.6063\n",
      "Checking accuracy on validation set\n",
      "Got 54475 / 59000 correct (92.33)\n",
      "\n",
      "Iteration 100, loss = 1.6063\n",
      "Checking accuracy on validation set\n",
      "Got 948 / 1000 correct (94.80)\n",
      "\n",
      "Iteration 200, loss = 1.5295\n",
      "Checking accuracy on validation set\n",
      "Got 56553 / 59000 correct (95.85)\n",
      "\n",
      "Iteration 200, loss = 1.5295\n",
      "Checking accuracy on validation set\n",
      "Got 967 / 1000 correct (96.70)\n",
      "\n",
      "Iteration 300, loss = 1.4782\n",
      "Checking accuracy on validation set\n",
      "Got 57311 / 59000 correct (97.14)\n",
      "\n",
      "Iteration 300, loss = 1.4782\n",
      "Checking accuracy on validation set\n",
      "Got 982 / 1000 correct (98.20)\n",
      "\n",
      "Iteration 400, loss = 1.4939\n",
      "Checking accuracy on validation set\n",
      "Got 57407 / 59000 correct (97.30)\n",
      "\n",
      "Iteration 400, loss = 1.4939\n",
      "Checking accuracy on validation set\n",
      "Got 972 / 1000 correct (97.20)\n",
      "\n",
      "Iteration 500, loss = 1.4967\n",
      "Checking accuracy on validation set\n",
      "Got 57542 / 59000 correct (97.53)\n",
      "\n",
      "Iteration 500, loss = 1.4967\n",
      "Checking accuracy on validation set\n",
      "Got 976 / 1000 correct (97.60)\n",
      "\n",
      "Iteration 600, loss = 1.4774\n",
      "Checking accuracy on validation set\n",
      "Got 57654 / 59000 correct (97.72)\n",
      "\n",
      "Iteration 600, loss = 1.4774\n",
      "Checking accuracy on validation set\n",
      "Got 975 / 1000 correct (97.50)\n",
      "\n",
      "Iteration 700, loss = 1.4875\n",
      "Checking accuracy on validation set\n",
      "Got 57850 / 59000 correct (98.05)\n",
      "\n",
      "Iteration 700, loss = 1.4875\n",
      "Checking accuracy on validation set\n",
      "Got 990 / 1000 correct (99.00)\n",
      "\n",
      "Iteration 800, loss = 1.4889\n",
      "Checking accuracy on validation set\n",
      "Got 57902 / 59000 correct (98.14)\n",
      "\n",
      "Iteration 800, loss = 1.4889\n",
      "Checking accuracy on validation set\n",
      "Got 979 / 1000 correct (97.90)\n",
      "\n",
      "Iteration 900, loss = 1.4967\n",
      "Checking accuracy on validation set\n",
      "Got 58033 / 59000 correct (98.36)\n",
      "\n",
      "Iteration 900, loss = 1.4967\n",
      "Checking accuracy on validation set\n",
      "Got 991 / 1000 correct (99.10)\n",
      "\n",
      "Iteration 0, loss = 1.4977\n",
      "Checking accuracy on validation set\n",
      "Got 58109 / 59000 correct (98.49)\n",
      "\n",
      "Iteration 0, loss = 1.4977\n",
      "Checking accuracy on validation set\n",
      "Got 987 / 1000 correct (98.70)\n",
      "\n",
      "Iteration 100, loss = 1.4942\n",
      "Checking accuracy on validation set\n",
      "Got 58103 / 59000 correct (98.48)\n",
      "\n",
      "Iteration 100, loss = 1.4942\n",
      "Checking accuracy on validation set\n",
      "Got 986 / 1000 correct (98.60)\n",
      "\n",
      "Iteration 200, loss = 1.5141\n",
      "Checking accuracy on validation set\n",
      "Got 58062 / 59000 correct (98.41)\n",
      "\n",
      "Iteration 200, loss = 1.5141\n",
      "Checking accuracy on validation set\n",
      "Got 979 / 1000 correct (97.90)\n",
      "\n",
      "Iteration 300, loss = 1.4888\n",
      "Checking accuracy on validation set\n",
      "Got 58268 / 59000 correct (98.76)\n",
      "\n",
      "Iteration 300, loss = 1.4888\n",
      "Checking accuracy on validation set\n",
      "Got 988 / 1000 correct (98.80)\n",
      "\n",
      "Iteration 400, loss = 1.4768\n",
      "Checking accuracy on validation set\n",
      "Got 58091 / 59000 correct (98.46)\n",
      "\n",
      "Iteration 400, loss = 1.4768\n",
      "Checking accuracy on validation set\n",
      "Got 980 / 1000 correct (98.00)\n",
      "\n",
      "Iteration 500, loss = 1.5116\n",
      "Checking accuracy on validation set\n",
      "Got 58268 / 59000 correct (98.76)\n",
      "\n",
      "Iteration 500, loss = 1.5116\n",
      "Checking accuracy on validation set\n",
      "Got 991 / 1000 correct (99.10)\n",
      "\n",
      "Iteration 600, loss = 1.4761\n",
      "Checking accuracy on validation set\n",
      "Got 58213 / 59000 correct (98.67)\n",
      "\n",
      "Iteration 600, loss = 1.4761\n",
      "Checking accuracy on validation set\n",
      "Got 989 / 1000 correct (98.90)\n",
      "\n",
      "Iteration 700, loss = 1.4902\n",
      "Checking accuracy on validation set\n",
      "Got 58053 / 59000 correct (98.39)\n",
      "\n",
      "Iteration 700, loss = 1.4902\n",
      "Checking accuracy on validation set\n",
      "Got 985 / 1000 correct (98.50)\n",
      "\n",
      "Iteration 800, loss = 1.4847\n",
      "Checking accuracy on validation set\n",
      "Got 58190 / 59000 correct (98.63)\n",
      "\n",
      "Iteration 800, loss = 1.4847\n",
      "Checking accuracy on validation set\n",
      "Got 990 / 1000 correct (99.00)\n",
      "\n",
      "Iteration 900, loss = 1.4658\n",
      "Checking accuracy on validation set\n",
      "Got 58287 / 59000 correct (98.79)\n",
      "\n",
      "Iteration 900, loss = 1.4658\n",
      "Checking accuracy on validation set\n",
      "Got 990 / 1000 correct (99.00)\n",
      "\n",
      "Iteration 0, loss = 1.4638\n",
      "Checking accuracy on validation set\n",
      "Got 58343 / 59000 correct (98.89)\n",
      "\n",
      "Iteration 0, loss = 1.4638\n",
      "Checking accuracy on validation set\n",
      "Got 987 / 1000 correct (98.70)\n",
      "\n",
      "Iteration 100, loss = 1.4824\n",
      "Checking accuracy on validation set\n",
      "Got 58423 / 59000 correct (99.02)\n",
      "\n",
      "Iteration 100, loss = 1.4824\n",
      "Checking accuracy on validation set\n",
      "Got 990 / 1000 correct (99.00)\n",
      "\n",
      "Iteration 200, loss = 1.4645\n",
      "Checking accuracy on validation set\n",
      "Got 58391 / 59000 correct (98.97)\n",
      "\n",
      "Iteration 200, loss = 1.4645\n",
      "Checking accuracy on validation set\n",
      "Got 987 / 1000 correct (98.70)\n",
      "\n",
      "Iteration 300, loss = 1.4959\n",
      "Checking accuracy on validation set\n",
      "Got 58372 / 59000 correct (98.94)\n",
      "\n",
      "Iteration 300, loss = 1.4959\n",
      "Checking accuracy on validation set\n",
      "Got 991 / 1000 correct (99.10)\n",
      "\n",
      "Iteration 400, loss = 1.4675\n",
      "Checking accuracy on validation set\n",
      "Got 57917 / 59000 correct (98.16)\n",
      "\n",
      "Iteration 400, loss = 1.4675\n",
      "Checking accuracy on validation set\n",
      "Got 987 / 1000 correct (98.70)\n",
      "\n",
      "Iteration 500, loss = 1.4629\n",
      "Checking accuracy on validation set\n",
      "Got 58478 / 59000 correct (99.12)\n",
      "\n",
      "Iteration 500, loss = 1.4629\n",
      "Checking accuracy on validation set\n",
      "Got 990 / 1000 correct (99.00)\n",
      "\n",
      "Iteration 600, loss = 1.4962\n",
      "Checking accuracy on validation set\n",
      "Got 58473 / 59000 correct (99.11)\n",
      "\n",
      "Iteration 600, loss = 1.4962\n",
      "Checking accuracy on validation set\n",
      "Got 986 / 1000 correct (98.60)\n",
      "\n",
      "Iteration 700, loss = 1.4936\n",
      "Checking accuracy on validation set\n",
      "Got 58321 / 59000 correct (98.85)\n",
      "\n",
      "Iteration 700, loss = 1.4936\n",
      "Checking accuracy on validation set\n",
      "Got 987 / 1000 correct (98.70)\n",
      "\n",
      "Iteration 800, loss = 1.4620\n",
      "Checking accuracy on validation set\n",
      "Got 58388 / 59000 correct (98.96)\n",
      "\n",
      "Iteration 800, loss = 1.4620\n",
      "Checking accuracy on validation set\n",
      "Got 987 / 1000 correct (98.70)\n",
      "\n",
      "Iteration 900, loss = 1.4888\n",
      "Checking accuracy on validation set\n",
      "Got 58489 / 59000 correct (99.13)\n",
      "\n",
      "Iteration 900, loss = 1.4888\n",
      "Checking accuracy on validation set\n",
      "Got 991 / 1000 correct (99.10)\n",
      "\n",
      "Iteration 0, loss = 1.4646\n",
      "Checking accuracy on validation set\n",
      "Got 58525 / 59000 correct (99.19)\n",
      "\n",
      "Iteration 0, loss = 1.4646\n",
      "Checking accuracy on validation set\n",
      "Got 987 / 1000 correct (98.70)\n",
      "\n",
      "Iteration 100, loss = 1.4668\n",
      "Checking accuracy on validation set\n",
      "Got 58501 / 59000 correct (99.15)\n",
      "\n",
      "Iteration 100, loss = 1.4668\n",
      "Checking accuracy on validation set\n",
      "Got 988 / 1000 correct (98.80)\n",
      "\n",
      "Iteration 200, loss = 1.4622\n",
      "Checking accuracy on validation set\n",
      "Got 58499 / 59000 correct (99.15)\n",
      "\n",
      "Iteration 200, loss = 1.4622\n",
      "Checking accuracy on validation set\n",
      "Got 987 / 1000 correct (98.70)\n",
      "\n",
      "Iteration 300, loss = 1.4636\n",
      "Checking accuracy on validation set\n",
      "Got 58527 / 59000 correct (99.20)\n",
      "\n",
      "Iteration 300, loss = 1.4636\n",
      "Checking accuracy on validation set\n",
      "Got 990 / 1000 correct (99.00)\n",
      "\n",
      "Iteration 400, loss = 1.4967\n",
      "Checking accuracy on validation set\n",
      "Got 58508 / 59000 correct (99.17)\n",
      "\n",
      "Iteration 400, loss = 1.4967\n",
      "Checking accuracy on validation set\n",
      "Got 989 / 1000 correct (98.90)\n",
      "\n",
      "Iteration 500, loss = 1.4655\n",
      "Checking accuracy on validation set\n",
      "Got 58570 / 59000 correct (99.27)\n",
      "\n",
      "Iteration 500, loss = 1.4655\n",
      "Checking accuracy on validation set\n",
      "Got 989 / 1000 correct (98.90)\n",
      "\n",
      "Iteration 600, loss = 1.4773\n",
      "Checking accuracy on validation set\n",
      "Got 58567 / 59000 correct (99.27)\n",
      "\n",
      "Iteration 600, loss = 1.4773\n",
      "Checking accuracy on validation set\n",
      "Got 989 / 1000 correct (98.90)\n",
      "\n",
      "Iteration 700, loss = 1.4679\n",
      "Checking accuracy on validation set\n",
      "Got 58608 / 59000 correct (99.34)\n",
      "\n",
      "Iteration 700, loss = 1.4679\n",
      "Checking accuracy on validation set\n",
      "Got 990 / 1000 correct (99.00)\n",
      "\n",
      "Iteration 800, loss = 1.4725\n",
      "Checking accuracy on validation set\n",
      "Got 58390 / 59000 correct (98.97)\n",
      "\n",
      "Iteration 800, loss = 1.4725\n",
      "Checking accuracy on validation set\n",
      "Got 987 / 1000 correct (98.70)\n",
      "\n",
      "Iteration 900, loss = 1.4693\n",
      "Checking accuracy on validation set\n",
      "Got 58425 / 59000 correct (99.03)\n",
      "\n",
      "Iteration 900, loss = 1.4693\n",
      "Checking accuracy on validation set\n",
      "Got 988 / 1000 correct (98.80)\n",
      "\n",
      "Iteration 0, loss = 1.4942\n",
      "Checking accuracy on validation set\n",
      "Got 58573 / 59000 correct (99.28)\n",
      "\n",
      "Iteration 0, loss = 1.4942\n",
      "Checking accuracy on validation set\n",
      "Got 991 / 1000 correct (99.10)\n",
      "\n",
      "Iteration 100, loss = 1.4916\n",
      "Checking accuracy on validation set\n",
      "Got 58520 / 59000 correct (99.19)\n",
      "\n",
      "Iteration 100, loss = 1.4916\n",
      "Checking accuracy on validation set\n",
      "Got 986 / 1000 correct (98.60)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 200, loss = 1.4939\n",
      "Checking accuracy on validation set\n",
      "Got 58624 / 59000 correct (99.36)\n",
      "\n",
      "Iteration 200, loss = 1.4939\n",
      "Checking accuracy on validation set\n",
      "Got 991 / 1000 correct (99.10)\n",
      "\n",
      "Iteration 300, loss = 1.4634\n",
      "Checking accuracy on validation set\n",
      "Got 58623 / 59000 correct (99.36)\n",
      "\n",
      "Iteration 300, loss = 1.4634\n",
      "Checking accuracy on validation set\n",
      "Got 990 / 1000 correct (99.00)\n",
      "\n",
      "Iteration 400, loss = 1.4777\n",
      "Checking accuracy on validation set\n",
      "Got 58574 / 59000 correct (99.28)\n",
      "\n",
      "Iteration 400, loss = 1.4777\n",
      "Checking accuracy on validation set\n",
      "Got 990 / 1000 correct (99.00)\n",
      "\n",
      "Iteration 500, loss = 1.4775\n",
      "Checking accuracy on validation set\n",
      "Got 58613 / 59000 correct (99.34)\n",
      "\n",
      "Iteration 500, loss = 1.4775\n",
      "Checking accuracy on validation set\n",
      "Got 990 / 1000 correct (99.00)\n",
      "\n",
      "Iteration 600, loss = 1.4820\n",
      "Checking accuracy on validation set\n",
      "Got 58657 / 59000 correct (99.42)\n",
      "\n",
      "Iteration 600, loss = 1.4820\n",
      "Checking accuracy on validation set\n",
      "Got 992 / 1000 correct (99.20)\n",
      "\n",
      "Iteration 700, loss = 1.4633\n",
      "Checking accuracy on validation set\n",
      "Got 58629 / 59000 correct (99.37)\n",
      "\n",
      "Iteration 700, loss = 1.4633\n",
      "Checking accuracy on validation set\n",
      "Got 991 / 1000 correct (99.10)\n",
      "\n",
      "Iteration 800, loss = 1.4755\n",
      "Checking accuracy on validation set\n",
      "Got 58628 / 59000 correct (99.37)\n",
      "\n",
      "Iteration 800, loss = 1.4755\n",
      "Checking accuracy on validation set\n",
      "Got 992 / 1000 correct (99.20)\n",
      "\n",
      "Iteration 900, loss = 1.4678\n",
      "Checking accuracy on validation set\n",
      "Got 58616 / 59000 correct (99.35)\n",
      "\n",
      "Iteration 900, loss = 1.4678\n",
      "Checking accuracy on validation set\n",
      "Got 986 / 1000 correct (98.60)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "n_epochs = 3\n",
    "learning_rate = 0.01\n",
    "momentum = 0.5\n",
    "log_interval = 10\n",
    "\n",
    "class Flatten(nn.Module):\n",
    "    def forward(self, x):\n",
    "        return flatten(x)\n",
    "\n",
    "model = nn.Sequential(\n",
    "    nn.Conv2d(1, 8, kernel_size=3, padding=0, stride=1, bias = True), #26x26\n",
    "    nn.BatchNorm2d(8),\n",
    "    nn.ReLU(),\n",
    "    nn.Conv2d(8, 8, kernel_size=3, padding=1, stride=1, bias = True), #26x26\n",
    "    nn.BatchNorm2d(8),\n",
    "    nn.ReLU(),\n",
    "    nn.Conv2d(8, 16, kernel_size=3, padding=1, stride=2, bias = True), #13x13\n",
    "    nn.BatchNorm2d(16),\n",
    "    nn.ReLU(),\n",
    "    nn.Conv2d(16, 16, kernel_size=3, padding=1, stride=1, bias = True), #13x13\n",
    "    nn.BatchNorm2d(16),\n",
    "    nn.ReLU(),\n",
    "    nn.Conv2d(16, 16, kernel_size=3, padding=1, stride=1, bias = True), #13x13\n",
    "    nn.BatchNorm2d(16),\n",
    "    nn.ReLU(),\n",
    "    nn.Conv2d(16, 32, kernel_size=3, padding=1, stride=2, bias = True), #7x7\n",
    "    nn.BatchNorm2d(32),\n",
    "    nn.Tanh(),\n",
    "    nn.Conv2d(32, 32, kernel_size=3, padding=1, stride=1, bias = True), #7x7\n",
    "    nn.BatchNorm2d(32),\n",
    "    nn.Tanh(),\n",
    "    nn.Conv2d(32, 32, kernel_size=3, padding=1, stride=1, bias = True), #7x7\n",
    "    nn.BatchNorm2d(32),\n",
    "    nn.Tanh(),\n",
    "    nn.Conv2d(32, 8, kernel_size=3, padding=1, stride=1, bias = True), #7x7\n",
    "    nn.BatchNorm2d(8),\n",
    "    nn.Tanh(),\n",
    "    Flatten(),\n",
    "    nn.Linear(8*7*7, 10, bias = True),\n",
    "    nn.Softmax(dim=1),\n",
    ")\n",
    "\n",
    "optimizer = optim.SGD(model.parameters(), lr=learning_rate,\n",
    "                     momentum=0.9, nesterov=True)\n",
    "\n",
    "train_acc, val_acc = train_part34(model, optimizer, epochs=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Checking accuracy on test set\n",
      "Got 9915 / 10000 correct (99.15)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9915"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_accuracy_part34(loader_test, model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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": [
    "plt.figure()\n",
    "plt.plot(np.arange(len(train_acc)), train_acc, c='r', label='train acc.')\n",
    "plt.plot(np.arange(len(val_acc)), val_acc, c='b', label='val acc.')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.suptitle('Training and Validation Accuracy')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}