cnn_training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load MNIST dataset\n",
    "transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])\n",
    "\n",
    "# Load the training dataset\n",
    "train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
    "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)\n",
    "\n",
    "# Load the validation dataset\n",
    "val_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n",
    "val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 10000)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_dataset), len(val_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAB4sAAAFeCAYAAACcpvlUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAlnElEQVR4nO3dfZTWdZ3/8c/AiNw4eAdaM+oiEmurkYAmahFFe7wL8oYsswyCsjJYN1337Oa4G6Z21tZ1VVzROEmkeQJLK9h1sUU4CujS1LqgLKiLCw4uDiswiTA4c/3+6Gz769ee4/uan9+5bj6Pxzn90fg8c97nqnN9mXl5aUOpVColAAAAAAAAALLSr9IHAAAAAAAAAND3jMUAAAAAAAAAGTIWAwAAAAAAAGTIWAwAAAAAAACQIWMxAAAAAAAAQIaMxQAAAAAAAAAZMhYDAAAAAAAAZMhYDAAAAAAAAJAhYzEAAAAAAABAhozFAAAAAAAAABkyFlNRGzZsSB//+MfTyJEj0+DBg9OwYcPSxIkT009+8pNKnwZADdi/f3/60z/909Tc3JwGDRqUTj/99LR8+fJKnwVAlXv88cdTQ0PD//qftWvXVvo8AGrIjTfemBoaGtLJJ59c6VMAqGK2EKpZY6UPIG8vvfRS6uzsTJ/97GdTc3Nz2rt3b3rooYfS1KlT0/z589MXvvCFSp8IQBWbPn16WrJkSbrqqqvSu971rnTfffel8847L61YsSK9//3vr/R5AFS5OXPmpNNOO+23vjZq1KgKXQNArdm2bVu66aab0pAhQyp9CgBVzhZCNWsolUqlSh8B/7fu7u40fvz4tG/fvrRx48ZKnwNAlXr66afT6aefnm655ZZ0zTXXpJRS2rdvXzr55JPTUUcdlVavXl3hCwGoVo8//nj60Ic+lBYvXpymTZtW6XMAqFGf/OQn06uvvpq6u7tTR0dHWr9+faVPAqCG2EKoFv4x1FSd/v37p2OPPTbt2rWr0qcAUMWWLFmS+vfv/1t/5+XAgQPTzJkz05o1a9LWrVsreB0AtaKzszO9+eablT4DgBqzatWqtGTJknTbbbdV+hQAapQthGphLKYqvP7666mjoyO98MIL6W/+5m/S3//936fJkydX+iwAqtgvfvGLNHr06DR06NDf+vr73ve+lFJKv/zlLytwFQC1ZMaMGWno0KFp4MCB6UMf+lBat25dpU8CoAZ0d3en2bNnp1mzZqX3vOc9lT4HgBpiC6Ea+XcWUxWuvvrqNH/+/JRSSv369UsXXXRRuvPOOyt8FQDVbPv27emd73zn73z9v7/W3t7e1ycBUCMGDBiQLr744nTeeeelYcOGpWeffTZ961vfSh/4wAfS6tWr09ixYyt9IgBV7O67704vvfRSeuyxxyp9CgA1xhZCNTIWUxWuuuqqNG3atNTe3p5+8IMfpO7u7tTV1VXpswCoYm+88UY6+OCDf+frAwcO/M1fB4D/zZlnnpnOPPPM3/z3qVOnpmnTpqUxY8akP/uzP0v/8A//UMHrAKhmO3fuTNdff31qbW1Nw4cPr/Q5ANQYWwjVyD+Gmqpw4oknpo985CPp8ssvTz/96U/Tr371qzRlypRUKpUqfRoAVWrQoEFp//79v/P1ffv2/eavA0DUqFGj0sc+9rG0YsWK1N3dXelzAKhS1113XTriiCPS7NmzK30KADXIFkI1MhZTlaZNm5b++Z//OW3atKnSpwBQpd75znem7du3/87X//trzc3NfX0SADXu2GOPTV1dXen111+v9CkAVKHNmzene+65J82ZMye1t7enLVu2pC1btqR9+/alAwcOpC1btqT/+q//qvSZANQQWwjVwFhMVfrvf3To7t27K3wJANXqlFNOSZs2bUp79uz5ra8/9dRTv/nrAFCOF198MQ0cODAdcsghlT4FgCr08ssvp56enjRnzpx0/PHH/+Y/Tz31VNq0aVM6/vjj09y5cyt9JgA1xBZCNWgo+Ww7FbRjx4501FFH/dbXDhw4kCZMmJCee+65tGPHDr+oAeB/9dRTT6UJEyakW265JV1zzTUppZT279+fTj755HTkkUemtWvXVvhCAKrVq6+++jv/nsl/+Zd/Saeddlo699xz0yOPPFKhywCoZh0dHemJJ574na9fd911qbOzM/3t3/5tOuGEE9J73vOeClwHQDWzhVDNjMVU1IUXXpj27NmTJk6cmFpaWtIrr7yS7r///rRx48b013/91+mrX/1qpU8EoIpdcskl6Uc/+lH64z/+4zRq1Ki0cOHC9PTTT6ef/exnaeLEiZU+D4Aq9eEPfzgNGjQonXnmmemoo45Kzz77bLrnnnvSQQcdlNasWZPe/e53V/pEAGrIpEmTUkdHR1q/fn2lTwGgStlCqGbGYirqwQcfTAsWLEj/+q//mnbu3JmamprS+PHj0+zZs9PUqVMrfR4AVW7fvn2ptbU1fe9730uvvfZaGjNmTLrhhhvS2WefXenTAKhit99+e7r//vvT888/n/bs2ZOGDx+eJk+enP7iL/4ijRo1qtLnAVBjjMUAvBVbCNXMWAwAAAAAAACQoX6VPgAAAAAAAACAvmcsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyFBjJOrp6Unt7e2pqakpNTQ0FH0TQGFKpVLq7OxMzc3NqV8/f79MX/AMAeqFZ0jf8wwB6oVnSN/zDAHqhWdI3/L8AOpFOc+P0Fjc3t6ejj322LflOIBqsHXr1nTMMcdU+owseIYA9cYzpO94hgD1xjOk73iGAPXGM6RveH4A9Sby/Aj9rUhNTU1vy0EA1cL7Wt/xWgP1xvta3/FaA/XG+1rf8VoD9cb7Wt/wOgP1JvK+FhqL/eMWgHrjfa3veK2BeuN9re94rYF6432t73itgXrjfa1veJ2BehN5X/MvOQAAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyJCxGAAAAAAAACBDxmIAAAAAAACADBmLAQAAAAAAADJkLAYAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyJCxGAAAAAAAACBDxmIAAAAAAACADBmLAQAAAAAAADJkLAYAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyJCxGAAAAAAAACBDxmIAAAAAAACADBmLAQAAAAAAADJkLAYAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMhQY6UPAAAAIF8HHXRQuH3uuefC7fHHHx9up06dGm5TSmnp0qVl9bWksTH+a4Irr7wy3L7yyivhdvHixeG2p6cn3AIAQEop3XrrreH2qquuKu6QAjQ0NITbO++8M9zOnj27N+dQI3yyGAAAAAAAACBDxmIAAAAAAACADBmLAQAAAAAAADJkLAYAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAw1VvoAqsdhhx0WbpuamsLtJz/5yXD7jne8I9x+8IMfDLdjx44Nt+X49re/HW5/8pOfhNuf/vSnvTkHoO7MmjUr3J5xxhnhdsaMGb055y01NDSE2wcffDDc3njjjeF2/fr14RagGlxwwQXhdsSIEeG2VCqF2+uvvz7cppRSW1tbuN2zZ0+4Peigg8LtoEGDwu0ll1wSbidNmhRup0yZEm7LMWDAgHC7aNGiQm4A3l7lvL+V82ffq6++ujfnvKX+/fsX8n0BKM60adPC7Zw5c8JtOT9XVINy7v3Sl74Ubvv1i3/29Morrwy3VAefLAYAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyJCxGAAAAAAAACBDjZU+gPIdeeSR4fav/uqvwu1ZZ50VbkeNGhVuy9HW1hZu9+/fH25Xr17dm3Pe0mc+85lw+6lPfSrc/uEf/mG4Xbt2bbgFKMqJJ54Ybh999NFw29LSEm4bGhrCbalUCrflKOf7XnLJJeH24osvDrcLFy4Mt5///OfDLUA9Gz9+fFn9tm3bwm05f14v52e9on4mqwbjxo0Lt4sWLSrwEuDtcvXVV4fbr371q+G2qD/XA1B7Wltbw205v0MqSnt7e7hdvHhxuB02bFi4veyyy8Lt2WefHW6pPT5ZDAAAAAAAAJAhYzEAAAAAAABAhozFAAAAAAAAABkyFgMAAAAAAABkyFgMAAAAAAAAkCFjMQAAAAAAAECGjMUAAAAAAAAAGTIWAwAAAAAAAGTIWAwAAAAAAACQIWMxAAAAAAAAQIYaK31APRs8eHC4veuuu8Lt6aefHm7f9a53hdtnnnkm3N5+++3h9gc/+EG4bWtrC7ddXV3htigvvfRSIe3mzZt7cw7A22rGjBnh9utf/3q4bWlp6c05Wevfv3+4Peeccwq8BIBylfPzW63ZtWtXuH3kkUfC7cKFC3txDdDXTjnllHB75ZVXFndIUDm/lwGg9pTzrLn00ksLueHee+8Nt//+7/8ebnfv3h1ux4wZE24vu+yycEt988liAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyJCxGAAAAAAAACBDxmIAAAAAAACADBmLAQAAAAAAADJkLAYAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMtRY6QPqWVdXV7hds2ZNIe3SpUvD7e7du8NtZ2dnuK0Gzc3N4fa6664Lt+94xzvC7eWXXx5ud+7cGW4BitLa2hpuW1paCrwk5tZbbw233/zmNwu5Yfbs2eG2nNe3HEOGDAm3J510UrjdsGFDb84BqAlbt24tq9+2bVu4PeOMM8o9J+S5554Lt+X8fPG9730v3K5bty7c/vKXvwy3QG149NFHw+2RRx5Z4CUxU6dOrfQJABToiSeeKKStBjNmzAi3Rf3O6/DDDw+348aNC7dtbW29OYe3mU8WAwAAAAAAAGTIWAwAAAAAAACQIWMxAAAAAAAAQIaMxQAAAAAAAAAZMhYDAAAAAAAAZMhYDAAAAAAAAJAhYzEAAAAAAABAhozFAAAAAAAAABkyFgMAAAAAAABkyFgMAAAAAAAAkKHGSh9Qz958881wO3/+/AIvqR1NTU3h9rLLLgu38+bNC7d79+4NtyNGjAi327dvD7cARbn00kvD7THHHFPgJTHnnXdeuF2xYkW47erq6s05b+nGG28s5Pu2traG20MPPTTczpkzJ9xeccUV4RZg+PDh4fZLX/pSgZfEzJ07t6z+u9/9brg944wzyj0nZOPGjeG2o6OjkBuA+lPOe/KwYcPCbalU6s05b2nJkiXh9rnnnivkhlpz7rnnhtsFCxaE23J+1ly5cmW4BaglZ599dri99tprw+373ve+cDt48OBwW47XXnst3La1tRVyA8XxyWIAAAAAAACADBmLAQAAAAAAADJkLAYAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAy1FjpA6h/J598cri96667wu1ZZ50Vbv/t3/4t3H7uc58Lt9u3bw+3AEUZPXp0uP3GN74Rbvv379+bc97St771rXD7+OOPh9uurq5eXPP2OnDgQLi95557wu1nPvOZcDtixIhwe+GFF4bbK664ItwCnHrqqeF24sSJhdzw/e9/P9x+97vfLet7d3d3h9snnniirO8NEHHwwQeH2/nz54fbcv7cuXfv3nA7ePDgcFuOn//85+G2oaGhkBuqwaRJk8LtsmXLwm1PT0+4HTBgQLgFqLSWlpZwO3369HD753/+5+F24MCB4RaK5pPFAAAAAAAAABkyFgMAAAAAAABkyFgMAAAAAAAAkCFjMQAAAAAAAECGjMUAAAAAAAAAGTIWAwAAAAAAAGTIWAwAAAAAAACQIWMxAAAAAAAAQIaMxQAAAAAAAAAZMhYDAAAAAAAAZKix0gdQPQYPHhxuZ82aFW7nzp0bbg855JBw+5WvfCXcrlq1Ktxu2LAh3AJUg8mTJ4fbESNGFHLDtm3bwu28efPC7f79+3tzTk1ob28Pt6tXrw635fxvPGDAgHA7atSocPv888+HW6A+jRkzptInpI6OjnDb3d1d4CUAb78PfvCD4fbTn/50uC3ndy2XXHJJuP3ABz4Qbstx8803h9t169aF23J+N7Rjx45wW5RTTz013Pb09ITbUqnUm3MAql45z8Zy9o1q8PTTT4fbY445Jty2tLSE2wsuuCDcPvzww+GW4vhkMQAAAAAAAECGjMUAAAAAAAAAGTIWAwAAAAAAAGTIWAwAAAAAAACQIWMxAAAAAAAAQIaMxQAAAAAAAAAZMhYDAAAAAAAAZMhYDAAAAAAAAJAhYzEAAAAAAABAhozFAAAAAAAAABlqrPQBFGv8+PHh9i//8i/D7bnnnhtuN23aFG4vuuiicLtx48ZwW87rAFBrTjzxxEqfkNasWRNu/+M//qPASyhHd3d3uN21a1dxhwA1oaWlJdzOnDmzwEti3vve94bb2bNnl/W977jjjnLPAXhb7dy5M9xu3rw53H7/+98Pt21tbeH2ySefDLdFWb58ebh95plnwu2Xv/zlcLt27dpwW46LL764kO8LUK8+9alPVfqEsjzyyCPh9nOf+1y4HTt2bLh97LHHwu3hhx8ebqkOPlkMAAAAAAAAkCFjMQAAAAAAAECGjMUAAAAAAAAAGTIWAwAAAAAAAGTIWAwAAAAAAACQIWMxAAAAAAAAQIaMxQAAAAAAAAAZMhYDAAAAAAAAZMhYDAAAAAAAAJAhYzEAAAAAAABAhhorfQDlO+WUU8LtP/3TP4XboUOHhtuenp5w+/u///vhdtGiReH21FNPDbfl3FuOtra2cHvNNdeE25UrV/bmHKCOjBgxItx+9rOfLe6QoM2bN1f6BHqhu7s73HZ0dBR4CVAL5s2bF25HjhxZ4CUxEydOLKRNKaUbb7wx3P7jP/5juJ07d264feaZZ8ItUH9+/vOfh9ty3uN27doVbsv5ncjSpUvD7fnnnx9ui/Le97433C5fvjzcXnXVVeF2xYoV4bac370BkNLNN98cbq+99tpwW87vWW677bZwu2zZsnBbzrN8+/bt4bYcs2bNCrff+c53CrmB8vhkMQAAAAAAAECGjMUAAAAAAAAAGTIWAwAAAAAAAGTIWAwAAAAAAACQIWMxAAAAAAAAQIaMxQAAAAAAAAAZMhYDAAAAAAAAZMhYDAAAAAAAAJAhYzEAAAAAAABAhozFAAAAAAAAABlqrPQBlK+joyPc7t+/P9z29PSE21KpFG7LUc73vfnmm8Pt9u3bw+2Xv/zlcDt27Nhwe/7554fblStXhlugPl1wwQXhtqmpqbhDghYtWlTpE2rOkCFDwu3RRx9dyA0vvvhiId8XqE8DBgwItw0NDQVeUnnlPHsvvPDCcDtp0qRwO3fu3HB71113hds333wz3AK14dVXXy3k+x44cCDcXn755eH205/+dLhtbW0Nt8OGDQu35Rg0aFC4veOOO8Ltvn37wu3QoUPDbTmeffbZcOt3WUAtefDBB8Pt8uXLw205f5bevXt3uC3KcccdV1Pfl+L4ZDEAAAAAAABAhozFAAAAAAAAABkyFgMAAAAAAABkyFgMAAAAAAAAkCFjMQAAAAAAAECGjMUAAAAAAAAAGTIWAwAAAAAAAGTIWAwAAAAAAACQIWMxAAAAAAAAQIaMxQAAAAAAAAAZaqz0AZRv27Zt4facc84JtwMGDOjNOW+rtra2cNvV1VXIDQ888EC4Xb9+fbidMWNGuL399tvDbTn/fwBqx/Tp0yt9QlqwYEG49V5UvrPOOivcTp48uZAb7rvvvkK+L1Cf7r777nC7bNmyQm4444wzwu2aNWvC7dVXX13WHeX87NTU1BRuDzvssHB76623htuXX3453D700EPhFiBq9+7d4XbevHnh9vHHHw+3jzzySLg94YQTwm1PT0+4Pfjggwtpy9GvX/yzQ4cffni4bW5uDrdbtmwJtwCVtnPnzkqfUJiZM2cW8n3L+fmD6uCTxQAAAAAAAAAZMhYDAAAAAAAAZMhYDAAAAAAAAJAhYzEAAAAAAABAhozFAAAAAAAAABkyFgMAAAAAAABkyFgMAAAAAAAAkCFjMQAAAAAAAECGjMUAAAAAAAAAGTIWAwAAAAAAAGSosdIHUKy2trZKn1Bzdu7cGW7Xrl0bbqdOnRpuJ0yYEG6XLFkSboHacfzxx1f6hHTTTTeF27179xZ4Se0YOXJkuL3vvvsKuaGc59jSpUsLuQGoTz/+8Y8rfUK68847a+r7ppTS5MmTw+3ixYvD7dChQ8Ptn/zJn4TbZcuWhds33ngj3AIUYcOGDeF21KhR4faKK64It3/0R38UbkePHh1ui7Jr165w+8UvfjHcbtmypfxjAHjbDRo0KNwedthhhdwwf/78Qr4vxfHJYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyJCxGAAAAAAAACBDxmIAAAAAAACADBmLAQAAAAAAADLUWOkDoJb94he/CLcf/ehHw+0bb7zRm3MAqLBRo0aF26OPPrqQG/bv3x9ut27dWsgNAPyPVatWhduVK1eG2ylTpoTbU089NdyOHz8+3D7xxBPhFqCWzJ8/P9w+8MAD4fZnP/tZuB03bly4LcfGjRvD7dKlSwu5AchbOb872bt3b7htb2/vzTl1Z8KECeH2Ix/5SLjdsWNHuF2xYkW4pTr4ZDEAAAAAAABAhozFAAAAAAAAABkyFgMAAAAAAABkyFgMAAAAAAAAkCFjMQAAAAAAAECGjMUAAAAAAAAAGTIWAwAAAAAAAGTIWAwAAAAAAACQIWMxAAAAAAAAQIaMxQAAAAAAAAAZaqz0Afza6NGjw+327dvDbWdnZ2/OIWjmzJnhtr29PdwuXbq0N+cAUIAJEyaE2wULFhRyw4EDB8LtPffcU8gNAPTO2LFjw+2UKVMKvASAIjQ2xn+9evDBBxd4ScxDDz1U6ROAzK1YsSLcdnV1hdtPfOIT4faZZ54p5IZyHH744eF25MiR4XbhwoW9Oectvf766+F2y5YthdxAcXyyGAAAAAAAACBDxmIAAAAAAACADBmLAQAAAAAAADJkLAYAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAw1VvqAWjN69OhwO3v27HB70kknhduPfexj4ZbyHXvsseF20KBB4fY73/lOb84BqJjDDjus0ieUpZz35NNPPz3cLlq0KNw2NzeH23Lcdttt4faGG24o5AagdowZMybc7tixI9y+8sorvTmnLpXzM9mdd95Z4CUxr732WiEtACkdd9xx4bac3/8V5e/+7u8qfQJA2IgRI8LtU089FW4ffvjhcFvUn4/HjRsXbocNGxZuW1paenPOW2poaCjk+1IdfLIYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyJCxGAAAAAAAACBDxmIAAAAAAACADDVW+oBa86Mf/Sjc/ud//me4bW1tDbednZ3hll9rbm4Ot0uXLg23RxxxRLhdtmxZuAXYs2dPuD3kkEMKueFrX/tauL300kvD7Ztvvhluhw8fHm4nTZoUbh988MFwW5RNmzaF23vvvbfAS4Ba8P73vz/c/vCHPwy35fxscdNNN4XbBQsWhNuiTJkyJdyW88xLKaXTTjst3JZKpbK+d9SuXbvC7WWXXRZuN2zY0ItrAIhoaGio9Anp9ddfr/QJABV3wQUXVPqEqlDOz4OLFy8u8BIqzSeLAQAAAAAAADJkLAYAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyFBjpQ+oBnfccUe4PfHEE8Ptt7/97XD75JNPhlt+7Ytf/GK4nTdvXiE3XHjhheF25cqVhdwA1KdvfOMb4faWW24Jt0OGDAm3F110UbgdP358uD3ooIPC7ZIlS8Lt8OHDw21RXn755XD70Y9+NNy+8MILvTkHqCMf//jHw+0RRxxRSHvbbbeF22uvvTbcFmXEiBHhtn///sUdUoY9e/aE20svvTTcLl++vDfnABBw7rnnhttSqVTgJQC14cc//nG4veKKK8JtQ0NDb86pO3v37g2306dPD7cPP/xw+cdQM3yyGAAAAAAAACBDxmIAAAAAAACADBmLAQAAAAAAADJkLAYAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAw1VvqAatDe3h5uS6VSuP293/u9cDthwoRwu2HDhnDb2dkZbsvR1NQUbk866aRw+/nPfz7cTp8+PdyW8zq0traG2+XLl4dbgHLMnz8/3HZ3d4fbu+++O9w2NDSE29WrV4fbWrN169Zw+7WvfS3cvvDCC705B8jUunXrKn1CGjRoULg94YQTCryktqxatSrc3nDDDeF2xYoVvTkHgLfZu9/97kqfAFBTrrzyykK+76xZs8JtY2Plp7FytqYtW7aE23POOSfcPv/88+GW+uaTxQAAAAAAAAAZMhYDAAAAAAAAZMhYDAAAAAAAAJAhYzEAAAAAAABAhozFAAAAAAAAABkyFgMAAAAAAABkyFgMAAAAAAAAkCFjMQAAAAAAAECGjMUAAAAAAAAAGTIWAwAAAAAAAGSooVQqld4q2rNnTzr00EP74p6KOPLII8Pt+vXrw+1RRx0VbgP/M/zGhg0bwu2vfvWrcNvQ0BBuhwwZEm5POumkcLtp06Zwe8cdd4TbVatWhdtyXl9q1+7du9PQoUMrfUYW6v0ZUmtefPHFcHvccceF23KeIdXghRdeCLc33HBDuF20aFFvzqHGeIb0Hc+Q/9GvX/zv821paQm3X/jCF8LtJz7xiXA7cuTIcFuUdevWhdvly5eX9b2/+c1vhtuurq5we+DAgbLuoPZ4hvQdzxD6yuTJk8Pto48+WsgNCxcuDLczZ84s5AaK5xnSNzw/atcf/MEfhNvHHnss3B599NHh9t577w23a9asCbflvM/D/yvy/PDJYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyJCxGAAAAAAAACBDxmIAAAAAAACADBmLAQAAAAAAADLUWOkDqsHOnTvD7bhx48Lthz/84XB7yimnhNvRo0eH2/PPPz/crlq1Ktw++eST4XbmzJnhdvPmzeF29+7d4RaAXxs5cmS4/cpXvhJur7/++nD76quvhtsHHngg3Jbj/vvvD7dbtmwp5AaAcvT09ITbrVu3htvW1tZCWgDIRUdHRyHf99lnnw23P/zhDwu5AaCWlPO+2dzcXOAlUHt8shgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyJCxGAAAAAAAACBDxmIAAAAAAACADBmLAQAAAAAAADJkLAYAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMNZRKpdJbRXv27EmHHnpoX9wD0Cd2796dhg4dWukzsuAZAtQbz5C+4xkC1BvPkL7jGQLUG8+QvuH5AdSbyPPDJ4sBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyJCxGAAAAAAAACBDxmIAAAAAAACADBmLAQAAAAAAADJkLAYAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyJCxGAAAAAAAACBDxmIAAAAAAACADBmLAQAAAAAAADJkLAYAAAAAAADIkLEYAAAAAAAAIEPGYgAAAAAAAIAMGYsBAAAAAAAAMmQsBgAAAAAAAMiQsRgAAAAAAAAgQ8ZiAAAAAAAAgAwZiwEAAAAAAAAyZCwGAAAAAAAAyJCxGAAAAAAAACBDobG4VCoVfQdAn/K+1ne81kC98b7Wd7zWQL3xvtZ3vNZAvfG+1je8zkC9ibyvhcbizs7O/+9jAKqJ97W+47UG6o33tb7jtQbqjfe1vuO1BuqN97W+4XUG6k3kfa2hFJiUe3p6Unt7e2pqakoNDQ1vy3EAlVAqlVJnZ2dqbm5O/fr5J/H3Bc8QoF54hvQ9zxCgXniG9D3PEKBeeIb0Lc8PoF6U8/wIjcUAAAAAAAAA1Bd/KxIAAAAAAABAhozFAAAAAAAAABkyFgMAAAAAAABkyFgMAAAAAAAAkCFjMQAAAAAAAECGjMUAAAAAAAAAGTIWAwAAAAAAAGTo/wBLrNfbS2X4TgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 2500x400 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Show the first 5 images with their labels\n",
    "images, labels = next(iter(train_loader))\n",
    "\n",
    "fig = plt.figure(figsize=(25, 4))\n",
    "for idx in range(5):\n",
    "    ax = fig.add_subplot(1, 5, idx+1, xticks=[], yticks=[])\n",
    "    ax.imshow(images[idx].squeeze(), cmap='gray')\n",
    "    ax.set_title(str(labels[idx].item()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the CNN model\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        # First conv layer\n",
    "        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)\n",
    "        # Second conv layer\n",
    "        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)\n",
    "        # Max pooling\n",
    "        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        # Flatten layer\n",
    "        self.flatten = nn.Flatten()\n",
    "        # Linear layers\n",
    "        self.fc1 = nn.Linear(64 * 7 * 7, 128)\n",
    "        self.fc2 = nn.Linear(128, 64)\n",
    "        self.fc3 = nn.Linear(64, 10)\n",
    "        # Dropout\n",
    "        self.dropout = nn.Dropout(0.3)\n",
    "        # ReLU\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.pool(self.relu(self.conv1(x))) # Convolution 1 and pooling\n",
    "        x = self.pool(self.relu(self.conv2(x))) # Convolution 2 and pooling\n",
    "        x = self.flatten(x) # Flatten the output for the linear layers\n",
    "        x = self.relu(self.fc1(x))\n",
    "        x = self.dropout(x)\n",
    "        x = self.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "    \n",
    "model = Net()\n",
    "\n",
    "# Initialize the optimizer\n",
    "optimizer = optim.AdamW(model.parameters(), lr=1e-3)\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/20], Loss: 0.2269, Accuracy: 92.81%\n",
      "Epoch [2/20], Loss: 0.0670, Accuracy: 97.97%\n",
      "Epoch [3/20], Loss: 0.0507, Accuracy: 98.47%\n",
      "Epoch [4/20], Loss: 0.0400, Accuracy: 98.82%\n",
      "Epoch [5/20], Loss: 0.0331, Accuracy: 98.92%\n",
      "Epoch [6/20], Loss: 0.0292, Accuracy: 99.09%\n",
      "Epoch [7/20], Loss: 0.0252, Accuracy: 99.25%\n",
      "Epoch [8/20], Loss: 0.0223, Accuracy: 99.28%\n",
      "Epoch [9/20], Loss: 0.0201, Accuracy: 99.36%\n",
      "Epoch [10/20], Loss: 0.0186, Accuracy: 99.39%\n",
      "Epoch [11/20], Loss: 0.0151, Accuracy: 99.50%\n",
      "Epoch [12/20], Loss: 0.0142, Accuracy: 99.54%\n",
      "Epoch [13/20], Loss: 0.0132, Accuracy: 99.59%\n",
      "Epoch [14/20], Loss: 0.0121, Accuracy: 99.59%\n",
      "Epoch [15/20], Loss: 0.0110, Accuracy: 99.64%\n",
      "Epoch [16/20], Loss: 0.0113, Accuracy: 99.65%\n",
      "Epoch [17/20], Loss: 0.0101, Accuracy: 99.68%\n",
      "Epoch [18/20], Loss: 0.0107, Accuracy: 99.65%\n",
      "Epoch [19/20], Loss: 0.0115, Accuracy: 99.64%\n",
      "Epoch [20/20], Loss: 0.0087, Accuracy: 99.74%\n"
     ]
    }
   ],
   "source": [
    "# Train the network\n",
    "num_epochs = 20\n",
    "for epoch in range(num_epochs):\n",
    "    running_loss = 0.0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    \n",
    "    for batch_idx, (data, target) in enumerate(train_loader):\n",
    "        # Forward pass, backward pass, optimize\n",
    "        optimizer.zero_grad()\n",
    "        output = model(data)\n",
    "        loss = criterion(output, target)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        # Calculate metrics\n",
    "        running_loss += loss.item()\n",
    "        _, predicted = torch.max(output.data, 1)\n",
    "        total += target.size(0)\n",
    "        correct += (predicted == target).sum().item()\n",
    "        \n",
    "    # Print metrics for each epoch\n",
    "    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}, Accuracy: {(100*correct/total):.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the model\n",
    "torch.save(model.state_dict(), './models/mnist_cnn.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on validation data: 99.24%\n"
     ]
    }
   ],
   "source": [
    "# Evaluate the model on the validation dataset\n",
    "model.eval()\n",
    "correct = 0\n",
    "total = 0\n",
    "\n",
    "with torch.no_grad():\n",
    "    for data, target in val_loader:\n",
    "        output = model(data)\n",
    "        _, predicted = torch.max(output.data, 1)\n",
    "        total += target.size(0)\n",
    "        correct += (predicted == target).sum().item()\n",
    "\n",
    "accuracy = 100 * correct / total\n",
    "print(f'Accuracy on validation data: {accuracy:.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2500x400 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get a batch of images from the validation dataset\n",
    "images, labels = next(iter(val_loader))\n",
    "\n",
    "# Make predictions on the batch of images\n",
    "with torch.no_grad():\n",
    "    outputs = model(images)\n",
    "    _, predicted = torch.max(outputs, 1)\n",
    "\n",
    "# Plot the images with their predicted labels\n",
    "fig = plt.figure(figsize=(25, 4))\n",
    "for idx in range(5):\n",
    "    ax = fig.add_subplot(1, 5, idx+1, xticks=[], yticks=[])\n",
    "    ax.imshow(images[idx].squeeze(), cmap='gray')\n",
    "    ax.set_title(f'Predicted: {predicted[idx].item()}')"
   ]
  },
  {
   "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.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}