cnn_number_recognition.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CNN for Number Recognition \n",
    "Author: Tom Schubert\n",
    "\n",
    "### Quellen:\n",
    "1. https://nextjournal.com/gkoehler/pytorch-mnist\n",
    "2. https://ravivaishnav20.medium.com/handwritten-digit-recognition-using-pytorch-get-99-5-accuracy-in-20-k-parameters-bcb0a2bdfa09\n",
    "3. pytorch docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import torch\n",
    "import torchvision\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x10939f610>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "momentum = 0.9    # https://towardsdatascience.com/stochastic-gradient-descent-with-momentum-a84097641a5d\n",
    "epochs = 8           # Wie oft alle Images durch den Trainingsprozess laufen müssen\n",
    "learning_rate = 0.01   # Linearer Faktor in Gradient Decent zum skaliern der Gradientenänderung\n",
    "# Defines how many pictures are getting processed parallel (before backpropagation)\n",
    "batch_size_train = 128   # batch size for Training\n",
    "batch_size_test = 1000  # batch size for testing    https://stats.stackexchange.com/questions/164876/what-is-the-trade-off-between-batch-size-and-number-of-iterations-to-train-a-neu\n",
    "\n",
    "log_interval = 5\n",
    "\n",
    "# for random functions generate seed\n",
    "random_seed = 1\n",
    "torch.backends.cudnn.enabled = False\n",
    "torch.manual_seed(random_seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Download Dataset with specified Downloader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MNIST data Set comes in PILLOW Images with (28,28) and Intensity between 0-255\n",
    "# First gets downloaded\n",
    "# Second gets converted to FloatTensor with values between 0-1\n",
    "# Third gets Normalized with mean=0, stdev=1\n",
    "# Output is a Dataloader which is an iterable --° enumerate for tensers\n",
    "\n",
    "# If no transformation to a tensor is made the data can get read over the dataloader object \n",
    "'''\n",
    "import numpy as np\n",
    "print(train_loader.dataset[0][0])\n",
    "x=np.array(train_loader.dataset[0][0])\n",
    "print(x.shape)\n",
    "'''\n",
    "\n",
    "#https://pytorch.org/docs/stable/data.html\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "  # Download MNIST Dataset\n",
    "    # location\n",
    "    #for Training\n",
    "    # Download if not already downloaded\n",
    "    # Process Data:\n",
    "      #Transform to Tensor\n",
    "      # Normalize Data\n",
    "  # batch size\n",
    "  # Shuffle the training data to make it independent of the order\n",
    "  torchvision.datasets.MNIST('./data/', train=True, download=True,\n",
    "                              # Transdormation Pipeline  https://pytorch.org/vision/stable/transforms.html\n",
    "                             transform=torchvision.transforms.Compose([\n",
    "                               # Scale Image from 0-255 to 0-1  https://discuss.pytorch.org/t/how-does-transforms-totensor-work-and-computation-of-mean-and-std-values/9085\n",
    "                               torchvision.transforms.ToTensor(),\n",
    "                               # the mean=0, stdev=1 scaling, (Normalizing)  https://www.youtube.com/watch?v=dXB-KQYkzNU&ab_channel=deeplizard\n",
    "                               torchvision.transforms.Normalize(\n",
    "                                 (0.13195264339447021,), (0.30903369188308716,))\n",
    "                             ])),\n",
    "  batch_size=batch_size_train, shuffle=True)\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    # Download MNIST Dataset\n",
    "    # location\n",
    "    #for Testing\n",
    "    # Download if not already downloaded\n",
    "    # Process Data:\n",
    "      #Transform to Tensor\n",
    "      # Normalize Data\n",
    "  # batch size\n",
    "  # Shuffle the training data to make it independent of the order\n",
    "  torchvision.datasets.MNIST('./data/', train=False, download=True,\n",
    "                             transform=torchvision.transforms.Compose([\n",
    "                               torchvision.transforms.ToTensor(),\n",
    "                               torchvision.transforms.Normalize(\n",
    "                                 (0.13195264339447021,), (0.30903369188308716,))\n",
    "                             ])),\n",
    "  batch_size=batch_size_test, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Print some examples from dataset (Training Part)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "torch.Size([128, 1, 28, 28])\n",
      "tensor([4, 8, 8, 6, 7, 1, 0, 7, 1, 8, 7, 6, 4, 9, 1, 5, 3, 2, 6, 8, 8, 6, 9, 4,\n",
      "        6, 0, 4, 2, 6, 7, 0, 5, 8, 6, 0, 3, 5, 7, 4, 7, 5, 1, 6, 7, 3, 6, 0, 3,\n",
      "        1, 1, 2, 6, 7, 9, 8, 0, 7, 2, 4, 3, 6, 5, 9, 5, 2, 3, 5, 3, 5, 8, 9, 2,\n",
      "        7, 1, 2, 4, 0, 2, 0, 6, 7, 2, 9, 5, 7, 1, 2, 2, 3, 3, 8, 8, 1, 0, 5, 7,\n",
      "        5, 9, 6, 7, 2, 5, 9, 7, 5, 7, 1, 7, 8, 7, 8, 8, 8, 2, 1, 4, 1, 1, 3, 2,\n",
      "        9, 5, 1, 9, 0, 3, 0, 3])\n",
      "2.8089085\n"
     ]
    }
   ],
   "source": [
    "# iterate over the batches loaded by the loader\n",
    "#TENSORS: https://pytorch.org/tutorials/beginner/basics/tensorqs_tutorial.htm\n",
    "examples_train = enumerate(train_loader)\n",
    "#print(train_loader.dataset[0])--> get first dataset\n",
    "#next(examples_train)\n",
    "# batch_idx gives index of batch\n",
    "# train_data img data\n",
    "# targets labels\n",
    "batch_idx_training, (train_data, targets_training) = next(examples_train)\n",
    "# Index des batches\n",
    "print(batch_idx_training)\n",
    "#torch.Size([64, 1, 28, 28])\n",
    "# 64 Beispiele mit 28x28 Pixeln\n",
    "print(train_data.shape)\n",
    "print(targets_training)\n",
    "\n",
    "# GET std and mean from dataset based on the tensor vector which already got scaled down to 0-1\n",
    "#print(f\"Mean: {train_data.data.float().mean()}\") #on normal Dataset without normalize the value would be --> 0.13195264339447021\n",
    "#print(f\"Std: {train_data.data.float().std()}\") #on normal Dataset without normalize the value would be --> 0.30903369188308716\n",
    "\n",
    "# These Values are also taken for normalizing all data points --> (datapoint - mean) /std\n",
    "\n",
    "# Print numpy array of data\n",
    "nparray=np.array(train_data.data[0][0])\n",
    "#print(nparray)\n",
    "# GEt max value from array\n",
    "from numpy.lib.index_tricks import unravel_index\n",
    "x1,y1=unravel_index(nparray.argmax(), nparray.shape)\n",
    "print(nparray[x1,y1])\n",
    "# Plot data\n",
    "#plt.imshow(nparray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "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(train_data[i].squeeze(), cmap='gray')\n",
    "  plt.title(\"Label: {}\".format(targets_training[i]),color='green')\n",
    "  plt.xticks([])\n",
    "  plt.yticks([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Print some examples from dataset (Test Part)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "torch.Size([128, 1, 28, 28])\n",
      "tensor([9, 2, 9, 3, 0, 0, 2, 0, 5, 1, 9, 7, 4, 8, 8, 7, 5, 7, 2, 3, 1, 2, 7, 2,\n",
      "        6, 8, 3, 3, 0, 8, 3, 1, 0, 7, 3, 0, 7, 7, 8, 5, 6, 7, 9, 7, 0, 0, 6, 7,\n",
      "        3, 9, 5, 7, 1, 5, 7, 1, 4, 1, 8, 3, 8, 8, 0, 3, 9, 7, 5, 0, 2, 9, 1, 3,\n",
      "        0, 3, 3, 8, 0, 7, 9, 8, 5, 2, 2, 5, 2, 3, 7, 4, 6, 4, 5, 6, 8, 6, 8, 9,\n",
      "        3, 8, 8, 2, 9, 4, 3, 1, 8, 3, 4, 4, 9, 3, 6, 7, 5, 0, 8, 8, 1, 3, 8, 3,\n",
      "        3, 6, 3, 4, 1, 4, 1, 9])\n"
     ]
    }
   ],
   "source": [
    "# iterate over the batches loaded by the loader\n",
    "#TENSORS: https://pytorch.org/tutorials/beginner/basics/tensorqs_tutorial.htm\n",
    "examples_test = enumerate(train_loader)\n",
    "#next(examples_test)\n",
    "batch_idx_test, (test_data, targets_test) = next(examples_test)\n",
    "# Index des batches\n",
    "print(batch_idx_test)\n",
    "#torch.Size([64, 1, 28, 28])\n",
    "# 64 Beispiele 1 Channel mit 28x28 Pixeln\n",
    "print(train_data.shape)\n",
    "print(targets_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "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(test_data[i].squeeze(), cmap='gray')\n",
    "  plt.title(\"Label: {}\".format(targets_test[i]),color='green')\n",
    "  plt.xticks([])\n",
    "  plt.yticks([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torchsummary import summary\n",
    "from tqdm import tqdm\n",
    "from CNN import CNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#           Definition of CNN-Modell\n",
    "<center><img src=\"img/CNN_Architecture.png\"/></center>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CNN Klasse\n",
    "cnn = CNN()\n",
    "# Stochastic gradient descent\n",
    "# USe  network.cuda() to transport params to gpu\n",
    "optimizer = optim.SGD(cnn.parameters(), lr=learning_rate,momentum=momentum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#summary(cnn, input_size=(1, 28, 28))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training Definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store the losses calculated while training \n",
    "train_losses = []\n",
    "# Store how many images got trained (make a list for plotting)\n",
    "train_counter = []\n",
    "# Store the losses calculated while testing \n",
    "test_losses = []\n",
    "# Store how many images got testes (make a list for plotting)\n",
    "test_counter = [i*len(train_loader.dataset) for i in range(epochs + 1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(epoch, model, train_loader, optimizer):\n",
    "  model.train()\n",
    "  progress_bar=tqdm(train_loader)\n",
    "  for batch_idx, (data, target) in enumerate(progress_bar):\n",
    "    # gradient auf 0 zurücksetzten\n",
    "    optimizer.zero_grad()\n",
    "    output = model(data)\n",
    "    #The negative log likelihood loss.\n",
    "    loss = F.nll_loss(output, target)\n",
    "    # BAckpropagation\n",
    "    loss.backward()\n",
    "    # Performs a single optimization step.\n",
    "    optimizer.step()\n",
    "    # Log every log_interval\n",
    "    if batch_idx % log_interval == 0:\n",
    "      progress_bar.set_description('Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f}'.format(\n",
    "      epoch, batch_idx * len(data), len(train_loader.dataset),\n",
    "      100. * batch_idx / len(train_loader), loss.item()))\n",
    "      train_losses.append(loss.item())\n",
    "      train_counter.append(\n",
    "        (batch_idx*batch_size_train) + ((epoch-1)*len(train_loader.dataset)))\n",
    "      #torch.save(train_loader.state_dict(), '/results/model.pth')\n",
    "      #torch.save(optimizer.state_dict(), '/results/optimizer.pth')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(model,test_loader):\n",
    "  model.eval()\n",
    "  test_loss = 0\n",
    "  correct = 0\n",
    "  # Do not compute a gradient\n",
    "  with torch.no_grad():\n",
    "    for data, target in test_loader:\n",
    "      # label data: Put the test dataset into the model and let it get labeled\n",
    "      output = model(data)\n",
    "      test_loss += F.nll_loss(output, target, reduction='sum').item()\n",
    "      # Get prediction from labeld data\n",
    "      pred = output.data.max(1, keepdim=True)[1]\n",
    "      # count how many were correct\n",
    "      correct += pred.eq(target.data.view_as(pred)).sum()\n",
    "  # log test_loss\n",
    "  test_loss /= len(test_loader.dataset)\n",
    "  test_losses.append(test_loss)\n",
    "  print('\\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
    "    test_loss, correct, len(test_loader.dataset),\n",
    "    100. * correct / len(test_loader.dataset)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test an empty untrained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Test set: Avg. loss: 2.3040, Accuracy: 980/10000 (10%)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "test(model=cnn,test_loader=test_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train Epoch: 1 [59520/60000 (99%)]\tLoss: 0.187539: 100%|██████████| 469/469 [03:16<00:00,  2.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Test set: Avg. loss: 0.1378, Accuracy: 9605/10000 (96%)\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train Epoch: 2 [59520/60000 (99%)]\tLoss: 0.159172: 100%|██████████| 469/469 [03:31<00:00,  2.21it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Test set: Avg. loss: 0.0715, Accuracy: 9783/10000 (98%)\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train Epoch: 3 [59520/60000 (99%)]\tLoss: 0.057393: 100%|██████████| 469/469 [03:34<00:00,  2.18it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Test set: Avg. loss: 0.0483, Accuracy: 9863/10000 (99%)\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train Epoch: 4 [59520/60000 (99%)]\tLoss: 0.082413: 100%|██████████| 469/469 [03:20<00:00,  2.34it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Test set: Avg. loss: 0.0382, Accuracy: 9885/10000 (99%)\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train Epoch: 5 [59520/60000 (99%)]\tLoss: 0.050822: 100%|██████████| 469/469 [03:14<00:00,  2.42it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Test set: Avg. loss: 0.0383, Accuracy: 9885/10000 (99%)\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train Epoch: 6 [59520/60000 (99%)]\tLoss: 0.099834: 100%|██████████| 469/469 [03:18<00:00,  2.36it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Test set: Avg. loss: 0.0326, Accuracy: 9899/10000 (99%)\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train Epoch: 7 [59520/60000 (99%)]\tLoss: 0.040009: 100%|██████████| 469/469 [03:13<00:00,  2.43it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Test set: Avg. loss: 0.0309, Accuracy: 9910/10000 (99%)\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train Epoch: 8 [59520/60000 (99%)]\tLoss: 0.036155: 100%|██████████| 469/469 [03:08<00:00,  2.48it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Test set: Avg. loss: 0.0251, Accuracy: 9924/10000 (99%)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(1, epochs + 1):\n",
    "  train(epoch,cnn, train_loader, optimizer)\n",
    "  test(cnn,test_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "752\n",
      "752\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'negative log likelihood loss')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "plt.plot(train_counter, train_losses, color='blue')\n",
    "print(len(train_counter))\n",
    "print(len(train_losses))\n",
    "plt.scatter(test_counter, test_losses, color='red')\n",
    "plt.legend(['Train Loss', 'Test Loss'], loc='upper right')\n",
    "plt.xlabel('number of training examples seen')\n",
    "plt.ylabel('negative log likelihood loss')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test the model and make some Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_model(model,test_loader):\n",
    "  model.eval()\n",
    "  test_loss = 0\n",
    "  correct = 0\n",
    "  # Do not compute a gradient\n",
    "  with torch.no_grad():\n",
    "    for data, target in test_loader:\n",
    "      # label data: Put the test dataset into the model and let it get labeled\n",
    "      output = model(data)\n",
    "      test_loss += F.nll_loss(output, target, reduction='sum').item()\n",
    "      # Get prediction from labeld data\n",
    "      pred = output.data.max(1, keepdim=True)[1]\n",
    "      # count how many were correct\n",
    "      correct += pred.eq(target.data.view_as(pred)).sum()\n",
    "  # log test_loss\n",
    "  print('\\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
    "    test_loss, correct, len(test_loader.dataset),\n",
    "    100. * correct / len(test_loader.dataset)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Test set: Avg. loss: 251.2332, Accuracy: 9924/10000 (99%)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "test_model(model=cnn,test_loader=test_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Label the test_data set \n",
    "with torch.no_grad():\n",
    "  output = cnn(test_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot some predictions from the test dataset\n",
    "# First 6 predictions from actual example_test iteration step\n",
    "fig = plt.figure()\n",
    "k=30\n",
    "#print(test_data[4+k][0].numpy()) # Get numpy array for data\n",
    "for i in range(6):\n",
    "  plt.subplot(2,3,i+1)\n",
    "  plt.tight_layout()\n",
    "  plt.imshow(test_data[i+k][0], cmap='gray', interpolation='none')\n",
    "  plt.title(\"Prediction: {} Label: {}\".format(\n",
    "    output.data.max(1, keepdim=True)[1][i+k].item(),targets_test[i+k]),color=\"green\")\n",
    "  plt.xticks([])\n",
    "  plt.yticks([])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#torch.save(cnn, './data/model.pth')\n",
    "torch.save(cnn.state_dict(), './data/cnn_model.pth')"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "92681fa9cabcd1408344435c15ff30a437254e4e0181f64dbbd14167cc33d8b6"
  },
  "kernelspec": {
   "display_name": "Python 3.9.8 64-bit ('CNN_Number_Recognition-siYzgVKK': pipenv)",
   "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.9.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}