pytorch-vision/linear-mnist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multi-layer perceptron for classifying handwritten digits\n",
    "\n",
    "In this notebook I will be using one of MNIST datasets to train a linear multi-layer perceptron to classify handwritten digits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch, torchvision\n",
    "from torch import nn\n",
    "from torchvision import datasets\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fetch all the data\n",
    "\n",
    "Yummy yummy data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = datasets.MNIST(\n",
    "    root=\".datasets\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=torchvision.transforms.ToTensor(),\n",
    "    target_transform=None\n",
    ")\n",
    "\n",
    "test_data = datasets.MNIST(\n",
    "    root=\".datasets\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=torchvision.transforms.ToTensor(),\n",
    "    target_transform=None\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lemmie show you all the data\n",
    "\n",
    "Come with me, and you will see... A WORLD OF DATA ANALYTICS!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image shape: torch.Size([1, 28, 28])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image, label = train_data[0]\n",
    "\n",
    "print(\"Image shape:\", image.shape)\n",
    "\n",
    "for i in range(0, 4):\n",
    "    image, label = train_data[i]\n",
    "    plt.subplot(2, 2, i+1)\n",
    "    plt.axis(\"off\")\n",
    "    plt.title(f\"Label: {label}\")\n",
    "    plt.imshow(image.squeeze())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we turn all that data into a Python iterable. This just makes it possible to train it in a training loop, in batches too!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<torch.utils.data.dataloader.DataLoader at 0x79abb099adb0>,\n",
       " <torch.utils.data.dataloader.DataLoader at 0x79ac1ff251c0>)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_dataloader = torch.utils.data.DataLoader(\n",
    "    dataset=train_data,\n",
    "    batch_size=32,\n",
    "    shuffle=True\n",
    ")\n",
    "\n",
    "test_dataloader = torch.utils.data.DataLoader(\n",
    "    dataset=test_data,\n",
    "    batch_size=32,\n",
    "    shuffle=False\n",
    ")\n",
    "\n",
    "train_dataloader, test_dataloader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The model\n",
    "\n",
    "The crown jewel of this notebook.\n",
    "\n",
    "Might as well clarify one thing. The reason why I am more communicative in these notebooks is because computer vision is a lot more interesting than fitting data points or fitting SciKit-learn's toy datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPModelV0(nn.Module):\n",
    "    def __init__(self, in_shape, hidden_units, out_shape):\n",
    "        super().__init__()\n",
    "        self.layer_stack = nn.Sequential(\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(in_features=in_shape, out_features=hidden_units),\n",
    "            nn.Linear(in_features=hidden_units, out_features=hidden_units),\n",
    "            nn.Linear(in_features=hidden_units, out_features=hidden_units),\n",
    "            nn.Linear(in_features=hidden_units, out_features=out_shape)\n",
    "        )\n",
    "    \n",
    "    def forward(self, X):\n",
    "        return self.layer_stack.forward(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another, rather cute thing you might notice (or not notice) is my naming scheme. It is from the course I learned all this. Here's the link to that course: https://www.udemy.com/course/pytorch-for-deep-learning/\n",
    "\n",
    "Not sponsored haha."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(64)\n",
    "\n",
    "# Now the in_shape value would be however much pixels we have\n",
    "# So that is 28 x 28 which is equal to 784\n",
    "# And 28 x 28 comes from image.shape\n",
    "\n",
    "model = MLPModelV0(\n",
    "    in_shape=28*28,\n",
    "    hidden_units=10,\n",
    "    out_shape=len(train_data.classes)\n",
    ")\n",
    "\n",
    "# model.state_dict()\n",
    "# I am not showing all that! You can run that yourself. Otherwise my notebook will be pretty large due to the output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do a dummy forward pass. Just to make sure everything is going in there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted: 4\n",
      "True label: 1\n"
     ]
    }
   ],
   "source": [
    "train_features_batch, train_labels_batch = next(iter(train_dataloader))\n",
    "\n",
    "y_logits = model.forward(train_features_batch[0])\n",
    "y_true = train_labels_batch[0]\n",
    "\n",
    "y_pred = y_logits.argmax(dim=1)\n",
    "\n",
    "print(\"Predicted:\", y_pred.item())\n",
    "print(\"True label:\", y_true.item())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So that was... completly wrong. Which is expected because our model has randomized weights and biases. Let's set those up then."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 87.50% | Loss: 0.24748378992080688\n",
      "Accuracy: 93.75% | Loss: 0.19348226487636566\n",
      "Accuracy: 93.75% | Loss: 0.11859528720378876\n",
      "Accuracy: 93.75% | Loss: 0.2476232796907425\n",
      "Accuracy: 93.75% | Loss: 0.1640956699848175\n",
      "Accuracy: 93.75% | Loss: 0.10577325522899628\n",
      "Accuracy: 87.50% | Loss: 0.2908984422683716\n",
      "Accuracy: 93.75% | Loss: 0.29814496636390686\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "loss_fn = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(params=model.parameters(), lr=0.1)\n",
    "epochs = 8\n",
    "\n",
    "# Look at the way I am writing the training and testing loop\n",
    "# That is not the usual stuff! This is batches!\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    for batch, (X, y) in enumerate(train_dataloader):\n",
    "        model.train()\n",
    "        y_logits = model.forward(X)\n",
    "        loss = loss_fn(y_logits, y)\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "    \n",
    "    for batch, (X, y) in enumerate(test_dataloader):\n",
    "        model.eval()\n",
    "        with torch.inference_mode():\n",
    "            y_logits = model.forward(X)\n",
    "            y_pred = y_logits.argmax(dim=1)\n",
    "            loss = loss_fn(y_logits, y)\n",
    "        accuracy = accuracy_score(y, y_pred)\n",
    "    \n",
    "    print(f\"Accuracy: {accuracy*100:.2f}% | Loss: {loss}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that is pretty good. It is reasonable to believe something is up! So let's test it!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing our model visually"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample label: 7\n",
      "Predicted label: 7\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGzCAYAAABpdMNsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAl3klEQVR4nO3de1xVdb7/8fcGdXuDTcg90RDNSyr+snQYb5ikUpmmTdffSbpoKjSh3YYzk2ZzobBTncq0OdORmsmcbFSq09HUBLNRU8vUqUgJL6loWgKiosL394c/98wO0DbuzRfw9Xw81uPBXvv7WevDcsmbtffiux3GGCMAAOpZgO0GAAAXJwIIAGAFAQQAsIIAAgBYQQABAKwggAAAVhBAAAArCCAAgBUEEADACgIIkJSamqrLLrvMdhuNXlJSkpKSkmy3gUaCAEK9ysnJkcPhcC/NmjXTpZdeqtTUVO3du9d2ewDqUTPbDeDi9OSTTyouLk4nTpzQunXrlJOTozVr1mjbtm1q2bKl7fYA1AMCCFakpKToqquukiTdd999CgsL09NPP6133nlHt9xyi+XuANQHXoJDgzBo0CBJUmFhoXvdyZMnNX36dPXt21cul0tt2rTRoEGDtGrVKo/anTt3yuFw6JlnntEf//hHxcfHy+l06uqrr9aGDRuq7WvJkiXq2bOnWrZsqZ49e2rx4sU19lReXq6HHnpIsbGxcjqd6tq1q5555hn9eAJ5h8Oh9PR0LVy4UD169FCrVq2UmJiorVu3SpJeeeUVde7cWS1btlRSUpJ27tx53uNRVlamjIwMXXbZZXI6nYqIiNC1116rTz/91D3mo48+0i9+8Qt16NBBTqdTsbGxmjp1qo4fP+6xrdTUVLVt21a7d+/WDTfcoLZt2+rSSy/V7NmzJUlbt27VNddcozZt2qhjx46aP3++R/3Zl01Xr16t+++/X+3atVNwcLDuuusu/fDDD+f9XioqKjRjxgx17tzZ3eejjz6qioqK89aiaeMKCA3C2R/Kl1xyiXtdaWmp/vSnP+n222/XhAkTVFZWpldffVUjRozQJ598oj59+nhsY/78+SorK9P9998vh8Oh7OxsjR07Vt98842aN28uSfrggw80btw49ejRQ1lZWTp8+LDuvvtutW/f3mNbxhjdeOONWrVqle6991716dNHy5Yt0yOPPKK9e/fqueee8xj/0Ucf6Z133lFaWpokKSsrSzfccIMeffRRvfzyy5oyZYp++OEHZWdn65577tGHH354zuMxadIkvf3220pPT1ePHj10+PBhrVmzRl9++aWuvPJKSdLChQt17NgxTZ48We3atdMnn3yiF198Ud9++60WLlzosb3KykqlpKRo8ODBys7O1htvvKH09HS1adNGv/71r3XnnXdq7Nixmjt3ru666y4lJiYqLi7OYxvp6ekKCQnRE088oYKCAs2ZM0e7du1SXl6eHA5Hjd9HVVWVbrzxRq1Zs0YTJ05U9+7dtXXrVj333HP6+uuvtWTJknMeBzRxBqhH8+bNM5LMihUrzHfffWf27Nlj3n77bRMeHm6cTqfZs2ePe+zp06dNRUWFR/0PP/xgIiMjzT333ONeV1RUZCSZdu3ame+//969Pjc310gy7777rntdnz59THR0tDly5Ih73QcffGAkmY4dO7rXLVmyxEgyv/vd7zz2f/PNNxuHw2F27NjhXifJOJ1OU1RU5F73yiuvGEkmKirKlJaWutdnZmYaSR5ja+JyuUxaWto5xxw7dqzauqysLONwOMyuXbvc68aPH28kmT/84Q/udT/88INp1aqVcTgcZsGCBe71X331lZFkZsyY4V539t+sb9++5uTJk+712dnZRpLJzc11rxsyZIgZMmSI+/Gf//xnExAQYD766COPPufOnWskmY8//vic3yOaNl6CgxXJyckKDw9XbGysbr75ZrVp00bvvPOOx5VIYGCgWrRoIenMb9Lff/+9Tp8+rauuusrjpaizbr31Vo8rqLMv633zzTeSpP3792vz5s0aP368XC6Xe9y1116rHj16eGzr/fffV2BgoH75y196rH/ooYdkjNH//u//eqwfNmyYx23c/fv3lySNGzdOQUFB1daf7ak2ISEhWr9+vfbt21frmFatWrm/Li8v16FDh/Tzn/9cxhh99tln1cbfd999Htvv2rWr2rRp4/GeW9euXRUSElJjfxMnTnRfSUrS5MmT1axZM73//vu19rhw4UJ1795d3bp106FDh9zLNddcI0nVXk7FxYUAghWzZ8/W8uXL9fbbb+u6667ToUOH5HQ6q4177bXX1Lt3b7Vs2VLt2rVTeHi4/ud//kclJSXVxnbo0MHj8dkwOvs+xa5duyRJXbp0qVbbtWtXj8e7du1STEyMR3hIUvfu3T22Vdu+zwZcbGxsjevP995Jdna2tm3bptjYWPXr109PPPFEtVDYvXu3UlNTFRoaqrZt2yo8PFxDhgyRpGrHp2XLlgoPD6/WS/v27au9fOZyuWrs78fHrW3btoqOjj7ne1rbt2/XP/7xD4WHh3ssl19+uSTp4MGD5zwOaNp4DwhW9OvXz30X3JgxYzRw4EDdcccdKigoUNu2bSVJf/nLX5SamqoxY8bokUceUUREhAIDA5WVleVxs8JZgYGBNe7L1MOnzte277r2dMstt2jQoEFavHixPvjgA82aNUtPP/20Fi1apJSUFFVWVuraa6/V999/r8cee0zdunVTmzZttHfvXqWmpqqqqsqv/f1UVVVV6tWrl5599tkan/9xQOPiQgDBurOhMnToUL300kv61a9+JUl6++231alTJy1atMjjt/QZM2bUaT8dO3aUdOa38h8rKCioNnbFihUqKyvzuAr66quvPLblT9HR0ZoyZYqmTJmigwcP6sorr9Tvf/97paSkaOvWrfr666/12muv6a677nLXLF++3G/9bN++XUOHDnU/Pnr0qPbv36/rrruu1pr4+Hh9/vnnGjZsWK03KuDixUtwaBCSkpLUr18/Pf/88zpx4oSkf/52/q+/ja9fv15r166t0z6io6PVp08fvfbaax4vUS1fvlxffPGFx9jrrrtOlZWVeumllzzWP/fcc3I4HEpJSalTDz9FZWVltZfQIiIiFBMT4751uaZjY4zRf/7nf/qtrz/+8Y86deqU+/GcOXN0+vTpcx6LW265RXv37tV//dd/VXvu+PHjKi8v90uvaBy4AkKD8cgjj+gXv/iFcnJyNGnSJN1www1atGiRbrrpJl1//fUqKirS3Llz1aNHDx09erRO+8jKytL111+vgQMH6p577tH333+vF198UVdccYXHNkeNGqWhQ4fq17/+tXbu3KmEhAR98MEHys3NVUZGhuLj4331bVdTVlam9u3b6+abb1ZCQoLatm2rFStWaMOGDfqP//gPSVK3bt0UHx+vhx9+WHv37lVwcLD+9re//aS/y6mrkydPatiwYbrllltUUFCgl19+WQMHDtSNN95Ya82//du/6a233tKkSZO0atUqDRgwQJWVlfrqq6/01ltvadmyZe6XYnHx4QoIDcbYsWMVHx+vZ555RpWVlUpNTdUf/vAHff755/rlL3+pZcuW6S9/+csF/cAaOXKkFi5cqMrKSmVmZmrRokWaN29etW0GBATonXfeUUZGht577z1lZGToiy++0KxZs2p9P8NXWrdurSlTpmjz5s2aMWOGpk6d6v6BP23aNElS8+bN9e6776pPnz7KysrSzJkz1aVLF73++ut+6+ull15S9+7dNX36dOXk5Oj2229Xbm7uOV9aCwgI0JIlS/TUU09p69atevjhhzVz5kxt2LBBDz74oPtmBFycHKY+3qEF0Gjl5OTo7rvv1oYNG7hagU9xBQQAsIIAAgBYQQABAKzgPSAAgBVcAQEArCCAAABWNLg/RK2qqtK+ffsUFBTE1B0A0AgZY1RWVqaYmBgFBNR+ndPgAmjfvn1MUAgATcCePXuqfdjjv2pwAXR24seBuk7N1Pw8owEADc1pndIavV/t40x+zG8BNHv2bM2aNUvFxcVKSEjQiy++qH79+p237uzLbs3UXM0cBBAANDr//97q872N4pebEP76179q2rRpmjFjhj799FMlJCRoxIgRfPgUAMDNLwH07LPPasKECbr77rvVo0cPzZ07V61bt9Z///d/+2N3AIBGyOcBdPLkSW3atEnJycn/3ElAgJKTk2v8HJeKigqVlpZ6LACAps/nAXTo0CFVVlYqMjLSY31kZKSKi4urjc/KypLL5XIv3AEHABcH63+ImpmZqZKSEveyZ88e2y0BAOqBz++CCwsLU2BgoA4cOOCx/sCBA4qKiqo23ul0yul0+roNAEAD5/MroBYtWqhv375auXKle11VVZVWrlypxMREX+8OANBI+eXvgKZNm6bx48frqquuUr9+/fT888+rvLxcd999tz92BwBohPwSQLfeequ+++47TZ8+XcXFxerTp4+WLl1a7cYEAMDFq8F9HlBpaalcLpeSNJqZEACgETptTilPuSopKVFwcHCt46zfBQcAuDgRQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWOHzAHriiSfkcDg8lm7duvl6NwCARq6ZPzZ6xRVXaMWKFf/cSTO/7AYA0Ij5JRmaNWumqKgof2waANBE+OU9oO3btysmJkadOnXSnXfeqd27d9c6tqKiQqWlpR4LAKDp83kA9e/fXzk5OVq6dKnmzJmjoqIiDRo0SGVlZTWOz8rKksvlci+xsbG+bgkA0AA5jDHGnzs4cuSIOnbsqGeffVb33ntvtecrKipUUVHhflxaWqrY2FglabSaOZr7szUAgB+cNqeUp1yVlJQoODi41nF+vzsgJCREl19+uXbs2FHj806nU06n099tAAAaGL//HdDRo0dVWFio6Ohof+8KANCI+DyAHn74YeXn52vnzp36+9//rptuukmBgYG6/fbbfb0rAEAj5vOX4L799lvdfvvtOnz4sMLDwzVw4ECtW7dO4eHhvt4VAKAR83kALViwwNebBAA0QcwFBwCwggACAFhBAAEArCCAAABWEEAAACsIIACAFQQQAMAKAggAYAUBBACwggACAFhBAAEArCCAAABW+P0D6XBGyZ0/87pm2dPPeV3T1tGwP9zvYOUxr2tu+PweP3RSs++/DfG6psesg17XHBzi/edjtf6u0uualu994nUNUF+4AgIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVzIZdT8o6eJ/1DX1m67qICGztdc0nVy7wQye1uNL7kqOjKryuqcu/7Wl5Pxv2Q/sGel0jSSve7+t1TeiXVV7XBO846nWN2bjN6xo0TFwBAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVDmOMsd3EvyotLZXL5VKSRquZo7ntdnzG4fR+8sm9D3g/IeTRTqe9rmm9p/7mpK1s5f3plji8YU8+eX9Entc1Vzsdvm+kETpcddzrmsS/PeR1TeeMdV7XoO5Om1PKU65KSkoUHBxc6ziugAAAVhBAAAArCCAAgBUEEADACgIIAGAFAQQAsIIAAgBYQQABAKwggAAAVhBAAAArCCAAgBUEEADACiYjBS6QGdDH65rdI1r5vpEajB31cZ3qfhux2beN+FDhae8nMM24akyd9lX53Xd1qrvYMRkpAKBBI4AAAFZ4HUCrV6/WqFGjFBMTI4fDoSVLlng8b4zR9OnTFR0drVatWik5OVnbt2/3Vb8AgCbC6wAqLy9XQkKCZs+eXePz2dnZeuGFFzR37lytX79ebdq00YgRI3TixIkLbhYA0HR4/VGYKSkpSklJqfE5Y4yef/55/eY3v9Ho0aMlSa+//roiIyO1ZMkS3XbbbRfWLQCgyfDpe0BFRUUqLi5WcnKye53L5VL//v21du3aGmsqKipUWlrqsQAAmj6fBlBxcbEkKTIy0mN9ZGSk+7kfy8rKksvlci+xsbG+bAkA0EBZvwsuMzNTJSUl7mXPnj22WwIA1AOfBlBUVJQk6cCBAx7rDxw44H7ux5xOp4KDgz0WAEDT59MAiouLU1RUlFauXOleV1paqvXr1ysxMdGXuwIANHJe3wV39OhR7dixw/24qKhImzdvVmhoqDp06KCMjAz97ne/U5cuXRQXF6fHH39cMTExGjNmjC/7BgA0cl4H0MaNGzV06FD342nTpkmSxo8fr5ycHD366KMqLy/XxIkTdeTIEQ0cOFBLly5Vy5Ytfdc1AKDRYzJSoAkLaNOmboWdO3hdUpjp/f/XLwfleF1TF13enlK3ugfX+biTiwOTkQIAGjQCCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCs8PrjGAA0HlXl5XUr/PxLr0vin+rh/X4GeV+y8/Qxr2u6vnrE+x1JqqpTFX4qroAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAomIwXgE9+Mc9XLfi5r1trrmsLbLqnTvuK21KkMPxFXQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBZORAqgmoHc3r2uWj59Vhz3VYWLR08e9runywjde10jS6TpV4afiCggAYAUBBACwggACAFhBAAEArCCAAABWEEAAACsIIACAFQQQAMAKAggAYAUBBACwggACAFhBAAEArGAyUgDV7Lwp1OuaSwO9n1i0LkYszfC65vLiDb5vBBeMKyAAgBUEEADACq8DaPXq1Ro1apRiYmLkcDi0ZMkSj+dTU1PlcDg8lpEjR/qqXwBAE+F1AJWXlyshIUGzZ8+udczIkSO1f/9+9/Lmm29eUJMAgKbH65sQUlJSlJKScs4xTqdTUVFRdW4KAND0+eU9oLy8PEVERKhr166aPHmyDh8+XOvYiooKlZaWeiwAgKbP5wE0cuRIvf7661q5cqWefvpp5efnKyUlRZWVlTWOz8rKksvlci+xsbG+bgkA0AD5/O+AbrvtNvfXvXr1Uu/evRUfH6+8vDwNGzas2vjMzExNmzbN/bi0tJQQAoCLgN9vw+7UqZPCwsK0Y8eOGp93Op0KDg72WAAATZ/fA+jbb7/V4cOHFR0d7e9dAQAaEa9fgjt69KjH1UxRUZE2b96s0NBQhYaGaubMmRo3bpyioqJUWFioRx99VJ07d9aIESN82jgAoHHzOoA2btyooUOHuh+fff9m/PjxmjNnjrZs2aLXXntNR44cUUxMjIYPH67f/va3cjqdvusaANDoeR1ASUlJMsbU+vyyZcsuqCEAvuP4P1fUqW7Zvdl1qPJ+MtL9lce8run6pxNe19T+Ews2MRccAMAKAggAYAUBBACwggACAFhBAAEArCCAAABWEEAAACsIIACAFQQQAMAKAggAYAUBBACwggACAFhBAAEArPD5R3ID8I9m7S/1uuZY9tE67evSQO9ntq6L5HmPel3TccPf/dAJbOAKCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsYDJSoJH4YnqM1zU7erzih05qtuBouNc1HWeu90MnaCy4AgIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAK5iMFLDgu8mJXtd8ff1LddiTow410t7KY17XvHbPKK9rHFWbva5B08EVEADACgIIAGAFAQQAsIIAAgBYQQABAKwggAAAVhBAAAArCCAAgBUEEADACgIIAGAFAQQAsIIAAgBYwWSkwAU6Pqaf1zULfzXL65oAtfa6pq7GPvmI1zXtPl7rh07QlHEFBACwggACAFjhVQBlZWXp6quvVlBQkCIiIjRmzBgVFBR4jDlx4oTS0tLUrl07tW3bVuPGjdOBAwd82jQAoPHzKoDy8/OVlpamdevWafny5Tp16pSGDx+u8vJy95ipU6fq3Xff1cKFC5Wfn699+/Zp7NixPm8cANC4eXUTwtKlSz0e5+TkKCIiQps2bdLgwYNVUlKiV199VfPnz9c111wjSZo3b566d++udevW6Wc/+5nvOgcANGoX9B5QSUmJJCk0NFSStGnTJp06dUrJycnuMd26dVOHDh20dm3Nd8hUVFSotLTUYwEANH11DqCqqiplZGRowIAB6tmzpySpuLhYLVq0UEhIiMfYyMhIFRcX17idrKwsuVwu9xIbG1vXlgAAjUidAygtLU3btm3TggULLqiBzMxMlZSUuJc9e/Zc0PYAAI1Dnf4QNT09Xe+9955Wr16t9u3bu9dHRUXp5MmTOnLkiMdV0IEDBxQVFVXjtpxOp5xOZ13aAAA0Yl5dARljlJ6ersWLF+vDDz9UXFycx/N9+/ZV8+bNtXLlSve6goIC7d69W4mJib7pGADQJHh1BZSWlqb58+crNzdXQUFB7vd1XC6XWrVqJZfLpXvvvVfTpk1TaGiogoOD9cADDygxMZE74AAAHrwKoDlz5kiSkpKSPNbPmzdPqampkqTnnntOAQEBGjdunCoqKjRixAi9/PLLPmkWANB0OIwxxnYT/6q0tFQul0tJGq1mjua228FFJjAywuuauRsWeV1zaWD9TCzaZcV9daq7fOI/vK4xFRV12heantPmlPKUq5KSEgUHB9c6jrngAABWEEAAACsIIACAFQQQAMAKAggAYAUBBACwggACAFhBAAEArCCAAABWEEAAACsIIACAFQQQAMAKAggAYEWdPhEVaPACAutUVjSps9c19TWz9eMH+3hdU5dZrSVmtkb94AoIAGAFAQQAsIIAAgBYQQABAKwggAAAVhBAAAArCCAAgBUEEADACgIIAGAFAQQAsIIAAgBYQQABAKxgMlI0SRUjr6xT3baJL/m4E9/54OUBXte0q1jrh04A3+AKCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsYDJSNHiBYe28rnnh5RfruLcWXlcEOrz/PW7CHu8nFg3L2eR1jfG6Aqg/XAEBAKwggAAAVhBAAAArCCAAgBUEEADACgIIAGAFAQQAsIIAAgBYQQABAKwggAAAVhBAAAArCCAAgBVMRooG7+Doy72uuaL5cj90UrO6TCy69/9Gel1jTn3jdQ3QkHEFBACwggACAFjhVQBlZWXp6quvVlBQkCIiIjRmzBgVFBR4jElKSpLD4fBYJk2a5NOmAQCNn1cBlJ+fr7S0NK1bt07Lly/XqVOnNHz4cJWXl3uMmzBhgvbv3+9esrOzfdo0AKDx8+omhKVLl3o8zsnJUUREhDZt2qTBgwe717du3VpRUVG+6RAA0CRd0HtAJSUlkqTQ0FCP9W+88YbCwsLUs2dPZWZm6tixY7Vuo6KiQqWlpR4LAKDpq/Nt2FVVVcrIyNCAAQPUs2dP9/o77rhDHTt2VExMjLZs2aLHHntMBQUFWrRoUY3bycrK0syZM+vaBgCgkapzAKWlpWnbtm1as2aNx/qJEye6v+7Vq5eio6M1bNgwFRYWKj4+vtp2MjMzNW3aNPfj0tJSxcbG1rUtAEAjUacASk9P13vvvafVq1erffv25xzbv39/SdKOHTtqDCCn0ymn01mXNgAAjZhXAWSM0QMPPKDFixcrLy9PcXFx563ZvHmzJCk6OrpODQIAmiavAigtLU3z589Xbm6ugoKCVFxcLElyuVxq1aqVCgsLNX/+fF133XVq166dtmzZoqlTp2rw4MHq3bu3X74BAEDj5FUAzZkzR9KZPzb9V/PmzVNqaqpatGihFStW6Pnnn1d5ebliY2M1btw4/eY3v/FZwwCApsHrl+DOJTY2Vvn5+RfUEADg4sBs2Gjwwj4v87rmoxN1O7X//N3Pva7Zf5f3M1tXbi/0ugZoapiMFABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALCCAAIAWEEAAQCsYDJSNHhm4zava7Li6/r5U0frqQYAV0AAACsIIACAFQQQAMAKAggAYAUBBACwggACAFhBAAEArCCAAABWEEAAACsIIACAFQQQAMCKBjcXnDFGknRapyRjuRkAgNdO65Skf/48r02DC6CysjJJ0hq9b7kTAMCFKCsrk8vlqvV5hzlfRNWzqqoq7du3T0FBQXI4HB7PlZaWKjY2Vnv27FFwcLClDu3jOJzBcTiD43AGx+GMhnAcjDEqKytTTEyMAgJqf6enwV0BBQQEqH379uccExwcfFGfYGdxHM7gOJzBcTiD43CG7eNwriufs7gJAQBgBQEEALCiUQWQ0+nUjBkz5HQ6bbdiFcfhDI7DGRyHMzgOZzSm49DgbkIAAFwcGtUVEACg6SCAAABWEEAAACsIIACAFQQQAMCKRhNAs2fP1mWXXaaWLVuqf//++uSTT2y3VO+eeOIJORwOj6Vbt2622/K71atXa9SoUYqJiZHD4dCSJUs8njfGaPr06YqOjlarVq2UnJys7du322nWj853HFJTU6udHyNHjrTTrJ9kZWXp6quvVlBQkCIiIjRmzBgVFBR4jDlx4oTS0tLUrl07tW3bVuPGjdOBAwcsdewfP+U4JCUlVTsfJk2aZKnjmjWKAPrrX/+qadOmacaMGfr000+VkJCgESNG6ODBg7Zbq3dXXHGF9u/f717WrFljuyW/Ky8vV0JCgmbPnl3j89nZ2XrhhRc0d+5crV+/Xm3atNGIESN04sSJeu7Uv853HCRp5MiRHufHm2++WY8d+l9+fr7S0tK0bt06LV++XKdOndLw4cNVXl7uHjN16lS9++67WrhwofLz87Vv3z6NHTvWYte+91OOgyRNmDDB43zIzs621HEtTCPQr18/k5aW5n5cWVlpYmJiTFZWlsWu6t+MGTNMQkKC7TaskmQWL17sflxVVWWioqLMrFmz3OuOHDlinE6nefPNNy10WD9+fByMMWb8+PFm9OjRVvqx5eDBg0aSyc/PN8ac+bdv3ry5WbhwoXvMl19+aSSZtWvX2mrT7358HIwxZsiQIebBBx+019RP0OCvgE6ePKlNmzYpOTnZvS4gIEDJyclau3atxc7s2L59u2JiYtSpUyfdeeed2r17t+2WrCoqKlJxcbHH+eFyudS/f/+L8vzIy8tTRESEunbtqsmTJ+vw4cO2W/KrkpISSVJoaKgkadOmTTp16pTH+dCtWzd16NChSZ8PPz4OZ73xxhsKCwtTz549lZmZqWPHjtlor1YNbjbsHzt06JAqKysVGRnpsT4yMlJfffWVpa7s6N+/v3JyctS1a1ft379fM2fO1KBBg7Rt2zYFBQXZbs+K4uJiSarx/Dj73MVi5MiRGjt2rOLi4lRYWKh///d/V0pKitauXavAwEDb7flcVVWVMjIyNGDAAPXs2VPSmfOhRYsWCgkJ8RjblM+Hmo6DJN1xxx3q2LGjYmJitGXLFj322GMqKCjQokWLLHbrqcEHEP4pJSXF/XXv3r3Vv39/dezYUW+99Zbuvfdei52hIbjtttvcX/fq1Uu9e/dWfHy88vLyNGzYMIud+UdaWpq2bdt2UbwPei61HYeJEye6v+7Vq5eio6M1bNgwFRYWKj4+vr7brFGDfwkuLCxMgYGB1e5iOXDggKKioix11TCEhITo8ssv144dO2y3Ys3Zc4Dzo7pOnTopLCysSZ4f6enpeu+997Rq1SqPzw+LiorSyZMndeTIEY/xTfV8qO041KR///6S1KDOhwYfQC1atFDfvn21cuVK97qqqiqtXLlSiYmJFjuz7+jRoyosLFR0dLTtVqyJi4tTVFSUx/lRWlqq9evXX/Tnx7fffqvDhw83qfPDGKP09HQtXrxYH374oeLi4jye79u3r5o3b+5xPhQUFGj37t1N6nw433GoyebNmyWpYZ0Ptu+C+CkWLFhgnE6nycnJMV988YWZOHGiCQkJMcXFxbZbq1cPPfSQycvLM0VFRebjjz82ycnJJiwszBw8eNB2a35VVlZmPvvsM/PZZ58ZSebZZ581n332mdm1a5cxxpinnnrKhISEmNzcXLNlyxYzevRoExcXZ44fP265c98613EoKyszDz/8sFm7dq0pKioyK1asMFdeeaXp0qWLOXHihO3WfWby5MnG5XKZvLw8s3//fvdy7Ngx95hJkyaZDh06mA8//NBs3LjRJCYmmsTERItd+975jsOOHTvMk08+aTZu3GiKiopMbm6u6dSpkxk8eLDlzj01igAyxpgXX3zRdOjQwbRo0cL069fPrFu3znZL9e7WW2810dHRpkWLFubSSy81t956q9mxY4fttvxu1apVRlK1Zfz48caYM7diP/744yYyMtI4nU4zbNgwU1BQYLdpPzjXcTh27JgZPny4CQ8PN82bNzcdO3Y0EyZMaHK/pNX0/Usy8+bNc485fvy4mTJlirnkkktM69atzU033WT2799vr2k/ON9x2L17txk8eLAJDQ01TqfTdO7c2TzyyCOmpKTEbuM/wucBAQCsaPDvAQEAmiYCCABgBQEEALCCAAIAWEEAAQCsIIAAAFYQQAAAKwggAIAVBBAAwAoCCABgBQEEALDi/wHY28Jfvji3ZgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_features_batch, test_labels_batch = next(iter(test_dataloader))\n",
    "\n",
    "randi = torch.randint(0, len(test_labels_batch), (1,)).item()\n",
    "image, label = test_features_batch[randi], test_labels_batch[randi]\n",
    "\n",
    "model.eval()\n",
    "with torch.inference_mode():\n",
    "    y_logits = model.forward(image)\n",
    "    y_pred = y_logits.argmax(dim=1)\n",
    "\n",
    "print(\"Sample label:\", label.item())\n",
    "print(\"Predicted label:\", y_pred.item())\n",
    "\n",
    "plt.title(\"Random sample\")\n",
    "plt.imshow(image.squeeze())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And it is working splendidly! At `93.75%` accuracy. Although it still makes mistakes. The digits it makes mistakes at, I can't even recognise them, so we can caught it some slack.\n",
    "\n",
    "It was fun!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}