AICP_M02_E.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NTK34uxMjMYL"
      },
      "source": [
        "# Assignment based on Tutorial II: Fully connected NNs\n",
        "<p>\n",
        "AICP, 2024<br>\n",
        "Prepared by Mykhailo Vladymyrov.\n",
        "</p>\n",
        "This work is licensed under a <a href=\"http://creativecommons.org/licenses/by-nc-sa/4.0/\">Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License</a>.\n",
        "\n",
        "Test E: Two-Layer Model (Baseline) with Regularization (Drpout and Weight Decay) and Manually Expanded Dataset (shifts up, down, left, right) (corrected)\n",
        "\n",
        "Baseline Model (2-layer NN) 1500 neurons in first hidden layer with ReLU activation, 10 neurons in output layer with softmax activation, learning rate 0.001, 10 epochs, batch size 64.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kmjKrW6WjS3K"
      },
      "source": [
        "## 1. Load necessary libraries\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "f8lKArr6jSgD"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import sys\n",
        "import tarfile\n",
        "import requests\n",
        "\n",
        "import random\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "from torchvision import datasets, transforms\n",
        "import torch.utils.data\n",
        "from torch.utils.data import TensorDataset, DataLoader \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U0I6wPiH8lIn"
      },
      "source": [
        "## 2. Structure of a neural network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "Qo8IDRWI8ohv"
      },
      "outputs": [],
      "source": [
        "#Import nn.functional as F_nn to use neural network operations (e.g., softmax).\n",
        "# Using an alias (F_nn) avoids confusion with image transformation functions from torchvision.\n",
        "\n",
        "import torch.nn.functional as F_nn  # Alias for softmax and other neural network operations\n",
        "\n",
        "#Class Definition and Initialization\n",
        "class MyModel(nn.Module):\n",
        "    def __init__(self, n_input, n_hiddens, n_output): \n",
        "        super(MyModel, self).__init__()\n",
        "   \n",
        "        self.ls = []\n",
        "        n_prev = n_input\n",
        "        for i, n_out in enumerate(n_hiddens):\n",
        "          l = nn.Linear(n_prev, n_out) \n",
        "          n_prev = n_out \n",
        "          self.add_module(f'lin_{i}_{n_out}', l) \n",
        "          self.ls.append(l) \n",
        "\n",
        "        self.lout = nn.Linear(n_prev, n_output)\n",
        "        self.dropout = nn.Dropout(0.5) # Dropout layer with a dropout rate of 0.5  \n",
        "\n",
        "    def forward(self, x):\n",
        "        x = torch.flatten(x, start_dim=1)       \n",
        "        h = x \n",
        "        for li in self.ls:  \n",
        "          h = li(h) \n",
        "          h = torch.relu(h)\n",
        "          h = self.dropout(h)  # apply dropout after ReLU activation  \n",
        "          \n",
        "        logits = self.lout(h)\n",
        "        probs = F.softmax(logits, dim=1) \n",
        "        pred = torch.argmax(probs, dim=1) \n",
        "\n",
        "        return logits, probs, pred\n",
        "     "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Import the required image transformation functions from torchvision.\n",
        "# Alias as F_tv to distinguish from nn.functional used elsewhere in the code.\n",
        "from torchvision.transforms import functional as F_tv  \n",
        "import torch\n",
        "from torchvision import datasets, transforms\n",
        "from torch.utils.data import DataLoader\n",
        "\n",
        "# Define a function to shift an image by specified pixel amounts.\n",
        "# The function applies an affine transformation to shift the image.\n",
        "# Parameters:\n",
        "# - shift_x: Number of pixels to shift the image horizontally.\n",
        "# - shift_y: Number of pixels to shift the image vertically.\n",
        "# Returns a shifted version of the input image without changing its orientation or scale.\n",
        "def shift_image(image, shift_x, shift_y):\n",
        "    return F_tv.affine(image, angle=0, translate=(shift_x, shift_y), scale=1, shear=0)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OyxjipoN9dfS"
      },
      "source": [
        "## 3. Load the data\n",
        "First, we will load the data: originally, there are 60,000 training images and 10,000 images for validation. However, we will expand the training set by adding shifted copies of each image, which will increase the number of training images.\n",
        "\n",
        "Each image is 28x28 pixels. For this model, we will interpret it as a 1D array of 784 elements.\n",
        "\n",
        "Note: The images are initially 28x28 pixels, but since a neural network expects a flat array of features (a 1D vector), they will be transformed into a 1D array of 784 elements (28 × 28 = 784) within the model's forward method."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "O-EivCFK87eQ"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Expanded train dataset shape: 300000\n",
            "Test dataset shape: 10000\n"
          ]
        }
      ],
      "source": [
        "# Define a transform to normalize the data (no flattening here)\n",
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(),  \n",
        "    transforms.Normalize((0.5,), (0.5,))  \n",
        "])\n",
        "\n",
        "# Load the original training dataset\n",
        "trainset = datasets.FashionMNIST('~/.pytorch/FMNIST_data/', download=True, train=True, transform=transform)\n",
        "\n",
        "# Create an expanded dataset by adding shifted copies\n",
        "expanded_dataset = []\n",
        "\n",
        "for img, label in trainset:\n",
        "    # Add the original image\n",
        "    expanded_dataset.append((img, label))\n",
        "\n",
        "    # Shifts to create new copies: up, down, left, right\n",
        "    shifts = [(2, 0), (-2, 0), (0, 2), (0, -2)] \n",
        "\n",
        "    for shift in shifts:\n",
        "        # Apply the shift to the image\n",
        "        shifted_img = shift_image(img, shift_x=shift[0], shift_y=shift[1])\n",
        "        expanded_dataset.append((shifted_img, label))\n",
        "\n",
        "# Convert the expanded dataset to a DataLoader for training\n",
        "expanded_loader = DataLoader(expanded_dataset, batch_size=64, shuffle=True)\n",
        "\n",
        "# Load the test dataset (no augmentation)\n",
        "testset = datasets.FashionMNIST('~/.pytorch/FMNIST_data/', download=True, train=False, transform=transform)\n",
        "testloader = DataLoader(testset, batch_size=64, shuffle=True)\n",
        "\n",
        "# Print the shapes of the datasets\n",
        "print('Expanded train dataset shape:', len(expanded_dataset))\n",
        "print('Test dataset shape:', len(testset))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "bABHqvh_xY60"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "torch.Size([1, 28, 28]) 9\n"
          ]
        }
      ],
      "source": [
        "#Looping Over the Dataset\n",
        "for el in trainset:\n",
        "  x, y = el\n",
        "  print(x.shape, y)\n",
        "  break"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "prPyGDvxxw-d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "torch.Size([64, 1, 28, 28]) torch.Size([64])\n"
          ]
        }
      ],
      "source": [
        "for el in expanded_loader: # Use expanded_loader instead of trainloader\n",
        "  x, y = el \n",
        "  print(x.shape, y.shape) \n",
        "  break"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Adding this function with a Quick Inspection here, with purpose to visually confirm that the manually expanded images are appearing as intended before they are used in training."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "torch.Size([64, 1, 28, 28]) torch.Size([64])\n"
          ]
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxoAAAEMCAYAAABDUMD9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAArkUlEQVR4nO3de3hV9ZX/8RWSkCsJCbmQi9yCgGi4D4K0ClIsVXy8DFMeK4ri1EvVTufBqaVOjYAMap0pUymiloItrTi2FnF0QKHIYxmitAoKVpBruCUEQsiF3PP9/cGQn5Gw1obzBZLwfj2Pf5jPPvvss3P295zljmuFOeecAAAAAIBHHS70AQAAAABofyg0AAAAAHhHoQEAAADAOwoNAAAAAN5RaAAAAADwjkIDAAAAgHcUGgAAAAC8o9AAAAAA4B2FBgAAAADvLupCY/HixRIWFiZ/+ctfvOwvLCxMHnroIS/7+vI+n3jiCS/7WrVqlYSFhUlYWJgcPnw48ONmzpwp/fv3l8bGxmY/Lysrk9mzZ8uwYcMkISFBoqKipEePHjJ16lT56KOPvBxzS44fPy5PPPGEvPfee6dkCxculKysLKmsrDxnz4+LW3tfN/bu3Su33HKL9OrVS+Li4iQxMVEGDx4s8+bNk/r6+sD7aWndOLn+hIWFSXh4uCQlJcnAgQPlvvvuk/z8/LM63vOhrq5OcnJyZO7cuRf6UNAOsIYEwxrSPlzUhcbFpKKiQr773e9KZmbmGT3uwIED8swzz8jMmTOlQ4f//3bZsWOHDB48WJ566ikZM2aMvPLKK/LOO+/IjBkzpKioSIYOHSrHjh3z/TJE5EShMWPGjBYLjSlTpkhcXJw888wz5+S5gfausrJSEhIS5Cc/+YksX75cli5dKl/72tfk4Ycflvvvvz/QPk63boiITJw4UdavXy9//vOfZenSpXLnnXdKfn6+jBw5Uv7pn/7pXLykkEVGRsrjjz8uM2fOlCNHjlzowwFaNdaQU13Ua4i7iC1atMiJiNuwYYOX/YmIe/DBB73s68v7zMvLC3k/Dz74oBs8eLD713/9Vycirri4ONDjfvjDH7qsrCzX0NDQ9LP6+nqXm5vrEhIS3Kefftri495++21XWVkZ8nG3pLi4WD0vzz77rEtMTDxnz4+L28W0bnzZt7/9bRcREeGqq6vNbVtaN04eV0uvtb6+3k2dOtWJiJs/f76679raWldXV3dmB+9BTU2NS05OdrNnzz7vz432hTWENeRiwh0NQ3V1tUybNk0GDRokiYmJkpycLCNHjpQ33njjtI954YUXpE+fPhIVFSX9+/eXpUuXnrJNYWGh3HfffZKdnS0dO3aUnj17yowZM87otmJQ77//vrz44ovyy1/+UsLDwwM/rra2VhYuXCjf+c53mv0XhWXLlsmnn34q06dPlyuuuKLFx37rW9+S2NjYpn//85//LGPHjpVOnTpJbGysXHXVVfLWW281e0xxcbF873vfk/79+0t8fLykpaXJtddeK++//37TNrt375bU1FQREZkxY0bTLdS77rqraZvbb79dysrKWjzvwPnQHtaNr0pNTZUOHTqYa8jp1g1NeHi4zJs3T1JSUuSnP/1p08/fe+89CQsLk9/85jcybdo0ycrKkqioKNm+fbuInPhz0LFjx0pCQoLExsbKqFGjZPXq1c32XVxcLPfee69ccsklEhUVJampqTJq1ChZtWpV0zYff/yxTJgwQdLS0iQqKkoyMzPlhhtukH379jVt07FjR5k0aZK8+OKL4pwL9LqAs8UawhrSXkRc6ANo7WpqaqSkpEQeeeQRycrKktraWlm1apXceuutsmjRIrnzzjubbb98+XJZs2aNzJw5U+Li4mT+/Ply2223SUREhEycOFFETlzow4cPlw4dOsjjjz8uOTk5sn79ennyySdl9+7dsmjRIvWYevToISInvnRbqqqq5J577pEf/OAHMmTIEFm+fHng1/7BBx/IkSNHZMyYMc1+/s4774iIyM033xxoP2vXrpVx48bJgAEDZOHChRIVFSXz58+XG2+8UV555RWZNGmSiIiUlJSIiEheXp507dpVKioq5I9//KOMHj1aVq9eLaNHj5aMjAxZsWKFjB8/Xu655x75x3/8RxGRpuJDRKRr167Sr18/eeutt2Tq1KmBXy/gS1tfN0REnHPS0NAg5eXl8s4778jixYtl2rRpEhGhf2ycbt2wxMTEyDe+8Q1ZunSp7Nu3T7Kzs5uy6dOny8iRI2XBggXSoUMHSUtLkyVLlsidd94pN910k7z88ssSGRkpL7zwgnzzm9+UlStXytixY0VE5I477pCPPvpIZs+eLX369JHS0lL56KOPmv58obKyUsaNGyc9e/aUX/ziF5Keni6FhYWyZs0aKS8vb3aMo0ePlueff142b94subm5Z/T6gDPBGsIa0m5c2BsqF9bZ3L6sr693dXV17p577nGDBw9ulomIi4mJcYWFhc2279evn+vdu3fTz+677z4XHx/v9uzZ0+zxzz77rBMRt2XLlmb7/Orty5ycHJeTkxPoeKdNm+Z69erljh8/7pxzLi8vL/CfTj399NNORJq9HuecGz9+vBORQLc/nXNuxIgRLi0tzZWXlzf9rL6+3l1xxRUuOzvbNTY2tvi4k+d67Nix7pZbbmn6ufWnU845d/vtt7v09PRAxweciYth3XDOuTlz5jgRcSLiwsLC3GOPPRbocadbN04el/YnHo8++qgTEffBBx8455xbs2aNExF39dVXN9uusrLSJScnuxtvvLHZzxsaGtzAgQPd8OHDm34WHx/vfvCDH5z2Of/yl784EXHLli0zX9sXX3zhRMQ9//zz5rbA6bCG6FhD2hf+dCqA1157TUaNGiXx8fESEREhkZGRsnDhQvnb3/52yrZjx46V9PT0pn8PDw+XSZMmyfbt25tuof33f/+3jBkzRjIzM6W+vr7pn29961sicuIOgGb79u1Nt/00H374ocydO1deeOEFiYmJOZOXLCIn/messLAwSUlJOePHnlRZWSkffPCBTJw4UeLj45t+Hh4eLnfccYfs27dPtm7d2vTzBQsWyJAhQyQ6OrrpXK9evbrFc61JS0uTQ4cOnZfbwUBL2uq6cdJdd90lGzZskJUrV8oPf/hD+elPfyoPP/yw+bhQ1g13mj8n+Pu///tm//6///u/UlJSIlOmTGl2LhobG2X8+PGyYcOGps5zw4cPl8WLF8uTTz4p+fn5UldX12xfvXv3lqSkJHn00UdlwYIF8tlnn532+NLS0kREZP/+/Wf82oAzxRrCGtIeUGgYXn/9dfn2t78tWVlZsmTJElm/fr1s2LBBpk6dKtXV1ads37Vr19P+7ORttqKiInnzzTclMjKy2T+XX365iMgZtZ7VTJ06VW699VYZNmyYlJaWSmlpadMxl5WVnXJL76uqqqokMjLylL+n7Natm4iI7Nq1yzyGo0ePinNOMjIyTslOdsA6eV7+4z/+Qx544AG58sor5Q9/+IPk5+fLhg0bZPz48VJVVWW/4C+Jjo4W51yLvyPgXGvL68aXn3/YsGFy3XXXyVNPPSUzZ86UefPmyccff6w+7nTrRhB79uwRETmlO95X14+ioiIROdF95qvn4+mnnxbnXNOfYr766qsyZcoU+eUvfykjR46U5ORkufPOO6WwsFBERBITE2Xt2rUyaNAg+fGPfyyXX365ZGZmSl5e3ilfKKKjo5teI3AusYawhrQX/D8ahiVLlkjPnj3l1VdflbCwsKaf19TUtLj9yTdeSz/r0qWLiIikpKTIgAEDZPbs2S3u40xb0J7Oli1bZMuWLfLaa6+dkuXk5MjAgQNl48aNp318SkqK1NbWSmVlpcTFxTX9/Jvf/Ka8+OKLsmzZMvnRj36kHkNSUpJ06NBBDh48eEp24MCBpucROXGuT/794pdZBVFLSkpKJCoqqtldFOB8acvrxukMHz5cRES2bdsmgwcPPu12p1s3LFVVVbJq1SrJyclp9rfVItLsHJ58DhGR5557TkaMGNHi/k7+192UlBSZO3euzJ07VwoKCmT58uXyox/9SA4dOiQrVqwQEZHc3FxZunSpOOfkk08+kcWLF8vMmTMlJiam2Rp38otHKHd5gSBYQ1hD2gsKDUNYWJh07Nix2Zu0sLDwtJ0fVq9eLUVFRU1v0IaGBnn11VebvfEnTJggb7/9tuTk5EhSUtI5O/Y1a9ac8rPFixfLyy+/LMuWLZOsrCz18f369ROREzMzBgwY0PTzm266SXJzc2XOnDkyYcKEFjtPrVy5Ur7+9a9LXFycXHnllfL666/Ls88+2/QnXI2NjbJkyRLJzs6WPn36iMiJcx0VFdVsP5988omsX79eLrnkkqafndxG+y8CO3fulP79+6uvDzhX2vK6cTon15PevXur251u3dA0NDTIQw89JEeOHJE5c+aY248aNUo6d+4sn3322RkNKuvWrZs89NBDsnr1alm3bt0peVhYmAwcOFB+9rOfyeLFi08ZPLpz504REdYWnHOsIawh7QWFhoj86U9/arGLwvXXXy8TJkyQ119/Xb73ve/JxIkTZe/evTJr1izJyMiQL7744pTHpKSkyLXXXis/+clPmjo/fP75583azM2cOVPeffddueqqq+T73/++9O3bV6qrq2X37t3y9ttvy4IFC06pxr/s5EVq/a3k6NGjT/nZySF3o0aNMivqk4/Pz89vdrGHh4fLH//4R7nuuutk5MiR8sADD8iYMWMkLi5O9uzZI7///e/lzTfflKNHj4qIyJw5c2TcuHEyZswYeeSRR6Rjx44yf/582bx5s7zyyitNC+mECRNk1qxZkpeXJ9dcc41s3bpVZs6cKT179mz2/1p06tRJunfvLm+88YaMHTtWkpOTJSUlpakjRmNjo3z44Ydyzz33qK8PCEV7XTfy8vKkqKhIrr76asnKypLS0lJZsWKFvPTSS/IP//APMnToUPXxp1s3TioqKpL8/Hxxzkl5ebls3rxZfv3rX8umTZvkn//5n+W73/2uun8Rkfj4eHnuuedkypQpUlJSIhMnTpS0tDQpLi6WTZs2SXFxsTz//PNy7NgxGTNmjHznO9+Rfv36SadOnWTDhg2yYsUKufXWW0XkxN+tz58/X26++Wbp1auXOOfk9ddfl9LSUhk3blyz583Pz5fw8HC5+uqrzWMELKwhLWMNaWcuzP+D3jqc7Pxwun927drlnHPuqaeecj169HBRUVHusssucy+99FJT96Yvk//rhjB//nyXk5PjIiMjXb9+/dxvf/vbU567uLjYff/733c9e/Z0kZGRLjk52Q0dOtQ99thjrqKiotk+v9r5oXv37q579+5n9ZrPpOuUc859/etfd9dff32LWWlpqZs1a5YbMmSIi4+Pd5GRka5bt25u8uTJbt26dc22ff/99921117r4uLiXExMjBsxYoR78803m21TU1PjHnnkEZeVleWio6PdkCFD3LJly9yUKVNOeb2rVq1ygwcPdlFRUU5E3JQpU5qy1atXOxFxf/3rXwO9RuBMtPd1Y/ny5e4b3/iGS09PdxERES4+Pt4NHz7c/fznPw885Op068aXz1OHDh1cQkKCy83Ndffee69bv379Kduf7Bjz2muvtfg8a9eudTfccINLTk52kZGRLisry91www1N21dXV7v777/fDRgwwCUkJLiYmBjXt29fl5eX1zTQ8/PPP3e33Xaby8nJcTExMS4xMdENHz7cLV68uMXX9dUuNcCZYg2xsYa0H2HOXURTQ3DG/vCHP8ikSZNkz5495p9atRZ33HGH7Ny5s8XbmgDOvba4blh27Nghl156qaxcufKU/0oJwC/WkPaDQgMq55xcddVVMnToUJk3b96FPhzTjh075LLLLpM//elP8rWvfe1CHw5wUWpr60YQd999t+zbt0/efffdC30oQLvHGtJ+0N4WqrCwMHnppZckMzNTGhsbL/ThmAoKCmTevHkUGcAF1NbWDUt9fb3k5OTIL37xiwt9KMBFgTWk/eCOBgAAAADvuKMBAAAAwDsKDQAAAADeUWgAAAAA8I5CAwAAAIB3gSeDn5zejLN3zTXXmNv07dtXzaurq9W8rq5OzTt37qzmBQUFav7WW2+pOYJ54oknQnp8Xl6enwM5z1hHRHJyctT8wQcfVPNBgwaFfAxVVVVqnpGRoeaHDh1Sc2sd+d3vfqfm7733nprjhItxHZkxY8aFPgQA/yfIGsIdDQAAAADeUWgAAAAA8I5CAwAAAIB3FBoAAAAAvKPQAAAAAOAdhQYAAAAA7yg0AAAAAHgXeI5Ge2D18HfOhbT/pKQkNQ/SG76iokLNGxsb1TwiQv+VhoeHq3lUVJSa+5iDYO3Dyq1zAJxLvXv3VvMXXnhBza+66io1/+yzz9Q8yPu/sLBQzSMjI9W8qKhIzdPS0tS8W7duaj5s2DA179Kli5qLiPzLv/yLmv/Xf/2XuQ9Nhw76f4djHQIAG3c0AAAAAHhHoQEAAADAOwoNAAAAAN5RaAAAAADwjkIDAAAAgHcUGgAAAAC8o9AAAAAA4F2rmaMRZD5DqHMuQn285e2331bzI0eOmPsoKytT89jYWDW35mhYczqs3vG//e1v1fz2229XcxH793Cuf0+AZsiQIWr+n//5n2peWVmp5qtWrVJzaz5DamqqmovYcyysdcKao7Fz507zGEJ5/uLiYnMfeXl5al5QUKDm+fn5as461Do98cQTF/oQIPY8Iev6tL6LLF26VM3Xrl2r5jg/rN+zCHc0AAAAAJwDFBoAAAAAvKPQAAAAAOAdhQYAAAAA7yg0AAAAAHhHoQEAAADAOwoNAAAAAN6dtzka1pyM89GzvG/fvmr+5JNPqvnEiRPVvKSkRM2PHTum5iIikZGRar5r1y5zH5rOnTurufV7GD16tJqXlpaax2DNEXj22WfV3Op/D4Tixz/+sZpb73FrDkZ1dbWa19bWqnmQORpVVVVqbs3L6dKli5pbr9FincOGhgZzH9asj/vvv1/NmaOB1upcf19KT083t7nlllvU3JontHXrVjXPzc1Vc2uN6tmzp5p36tRJzUXsWR1B5vnAxh0NAAAAAN5RaAAAAADwjkIDAAAAgHcUGgAAAAC8o9AAAAAA4B2FBgAAAADvKDQAAAAAeEehAQAAAMC7djWwzxr0dt9996l5XV2dmu/du1fNw8PD1dwaxicikpmZqebWUMCUlBQ1j4mJUfODBw+qeUVFhZpbg8JEREaNGqXm48aNU/MFCxao+aOPPqrmrWF4JC6cnJwcNb/kkkvUfMeOHWreo0cPNbeG0VnXeJBBVNZAPGsYVn19vZpHROgfHZWVlWpurYVB1kprvc7KylJza3hpkOGjwLkQ6mfQM888o+ZTp04192Fdg7t371ZzazDvG2+8oebW9Tlp0iQ1j46OVnMRe2jg9OnT1fzIkSNqbn0nDDKYtD3gjgYAAAAA7yg0AAAAAHhHoQEAAADAOwoNAAAAAN5RaAAAAADwjkIDAAAAgHcUGgAAAAC8O29zNBobG0PeR1xcnJqnpaWpeXl5uZpbMyKsnshWb/nY2Fg1F7HP05o1a9T80ksvVXNrRoU1Q8Dqj3/s2DE1FxE5dOiQmicmJqq5NWfAwpyMi9uwYcPU3OofHxUVpebWLJvq6mo137Ztm5oH6b1uXccJCQlqbs2Q2LNnj5onJyeree/evdU8yOfF1q1b1dxarwcPHqzm1loLnK1zPcvpuuuuU3Nr/oOIvc5Y38cmT56s5tYcjr59+6p5UVGRmq9YsULNRezvSzfffLOaL1y4UM0vljkZFu5oAAAAAPCOQgMAAACAdxQaAAAAALyj0AAAAADgHYUGAAAAAO8oNAAAAAB4R6EBAAAAwLvzNkfDh/vvv1/NrTkZVk9jq7e1paamRs2tGRQiIvX19Wp+2WWXqbk1q6O4uDikvKqqSs27du2q5kFY59HqAd6pUyc1t94naN9GjBih5tZ1al2jv/rVr9T89ttvV/OkpCQ179Wrl5qL2HMy9u3bp+bHjx9X8+joaPMYNJs2bVLzgoICcx/W79Faz0eNGqXmzNFAa3XllVeqeZcuXdTcmpMjYs+hsWbpWHPNLH/961/VfN26dWoeExNjPoe1lt94441qbs3RwAnc0QAAAADgHYUGAAAAAO8oNAAAAAB4R6EBAAAAwDsKDQAAAADeUWgAAAAA8I5CAwAAAIB3bWqOhjUjomfPniHt3+ob3aGDXpc550J6fhGR2tpaNbdmRFivISMjQ83vvfdeNd+4caOaW/35RUQ+//xzNa+urlbzuLg4NU9NTVVz5mhc3LKzs0N6vDWjYuvWrWpeV1en5tY6l5ycrOYiIocOHVJza1aHNYPC6lFvzSwqKSlR87Vr16q5iN3j3pq3E+r7ADhboX5XmDx5sppHRIT+1c46Ruu7xt69e9U8MTFRza1ZPenp6WoeZI6GtY2P86ixzqG1jrYV3NEAAAAA4B2FBgAAAADvKDQAAAAAeEehAQAAAMA7Cg0AAAAA3lFoAAAAAPCOQgMAAACAd61mjkaQfsVWX+f9+/er+YgRI9T82LFjIT2/NWfD6k0fhNVX2eo9bfXXnzt3rpovXLhQzf/nf/5HzUVE+vfvr+bWnIvDhw+reWRkpHkMuHgdPXpUza21qKKiIqTnb2xsVPPi4mI13759u/kc1qyPUGfJWOfQev4ePXqoeUFBgXkM1iyOqqoqNbd62ANny/qsD3WOxjXXXBPS/q0ZFiL2HBprHbRmglnXp3UO09LS1DzIGhcVFaXm1syuUaNGqfm6devU3MfstbaAOxoAAAAAvKPQAAAAAOAdhQYAAAAA7yg0AAAAAHhHoQEAAADAOwoNAAAAAN5RaAAAAADwrtXM0Qgy+yAmJkbNN23apOZTp05V8+rqajW3ZliEOmdDxO7tHmpeWlqq5n369FHzuro6Nf/d736n5iIiv/71r9W8qKhIza15J0lJSeYx4OKVnp6u5tZ1unfvXjW35nB07NgxpOdPTU1VcxGRgwcPqnlGRoaaW2thcnKymlvzfKx1ZsuWLWouIpKVlaXmn3zyiZoHWY+BsxHqHI2BAwequTWDoqamRs1jY2PVXMSeg2GtY9a8ICu3ZlxYs3aCzGarrKw0t9HcdNNNam7N0bDOQXvBSgsAAADAOwoNAAAAAN5RaAAAAADwjkIDAAAAgHcUGgAAAAC8o9AAAAAA4B2FBgAAAADvWs0cjV69epnbdOnSRc03btyo5mVlZWoeFxen5hUVFWpu9US2ZlyI2P23rX1Yj7de49atW9X88ccfV/Mg9uzZo+bWeU5MTFTz8vLyMz4mtA9BZiN06tRJza05LQcOHFDzkpISNc/MzFTzHTt2qPn+/fvVPAhrVo3Vp7++vl7NrWvYmscTxPbt29XcmrsUZJYAcDZCnY/w0EMPqbk158bKrTk3IvYcDeu7iLVGWLN4jh8/rubWWh/k+rZmgVh5bm6umluv0fqsCHUeS2vBHQ0AAAAA3lFoAAAAAPCOQgMAAACAdxQaAAAAALyj0AAAAADgHYUGAAAAAO8oNAAAAAB4R6EBAAAAwLtWM7AvLS3N3MYatGUNiNm7d6+aX3HFFWpuDfwLMpDPcq4H9llDbqzHFxYWqnmQATLW0EBrSI71e7T2j/bLGuopIlJZWanm1jW2ZcsWNbcGSh45ckTNIyL0Zblr165qLmIP7LKuU2vgWE1NjZonJCSoeVJSkpoH8eabb6r55MmT1dw6R9bvwfq8Ac7WiBEj1LygoEDNs7Oz1TzI9Rdk+GkooqKi1Ly0tFTNIyMjQz4G6zXGx8eruTW89aabblLzRYsWqXlbGchn4Y4GAAAAAO8oNAAAAAB4R6EBAAAAwDsKDQAAAADeUWgAAAAA8I5CAwAAAIB3FBoAAAAAvGtTczSsvuVWT+SioiI1t+ZoWKznD9IT2erdbvWetmZQWMdo9aYOtf++iEhMTIyal5SUqLk1K6GiokLNo6Oj1dzqr4/WKzU11dzGmsdjzdE4ePCgmg8aNEjNjx49qubWnI/Dhw+ruYhI586d1fz48eNqnpycrObWNXTs2DE1T0lJUXPrHIqIbN682dxGY32ehDoPBTgd63PWem9Zc2o+/fRTNd+1a5eai4h0795dza1ZHtY6Wltbe07zIHPNrO8r1jpnueGGG9TcmqPRXnBHAwAAAIB3FBoAAAAAvKPQAAAAAOAdhQYAAAAA7yg0AAAAAHhHoQEAAADAOwoNAAAAAN61mjkaVl91EZGwsDA1t3rHW7k1I8KaQeGD9RxWb2jr8dY5tB5v9Z0Oco6sbUpLS9V84sSJav773/9eza1ZI8zRaLsyMjLMbaw5FtacjUOHDqn5wIED1dyaI2O9P+vq6tRcRKShoUHNrTkX1jFY59DqsW/NyQjye9y0aZOaWz3wrd+DdQzM0cDZGjx4sJrHx8erufU94O6771bzWbNmqbmISG5urpqHOoOipqYmpNx6fuv7nojIzp071bxHjx5qbn1WWDO9+vTpo+bbtm1T87aCOxoAAAAAvKPQAAAAAOAdhQYAAAAA7yg0AAAAAHhHoQEAAADAOwoNAAAAAN5RaAAAAADwrtXM0bB6movYPYmt3u+hzsmwetOHOsMiyD6s/tmh5qHO0QjC6q9dX1+v5gkJCWqemJio5lFRUWqOtqtbt27mNtY1UFZWpuYlJSVqbvVvr6qqUvPU1FQ1T05OVnMR+xrq27evmluzOqy1NikpSc2ttbhr165qLiKybt06Nbc+LyzWMWzevDmk/ePilZ6eruaxsbFqbl2f27dvV/Ps7Gw1F7HXEOv7kLUGHDx4UM1ra2vV3PouEuT7VkSE/hV42rRpaj579mw1t+YJ3XjjjWr+7//+72reVnBHAwAAAIB3FBoAAAAAvKPQAAAAAOAdhQYAAAAA7yg0AAAAAHhHoQEAAADAOwoNAAAAAN61mjkaQXrDW32X4+Pj1fz48eNqbvV2t3rHtwZBekdrfMwCsVj9udPS0tS8pqYmpP1bcwqKi4vVHK1Xp06dzG2s/u5Wb3VL9+7d1fyLL75Qc6s/fWlp6Zke0imsuUXWWmr1h7dmkVivIcjv0VrPrbXK6tMfFxdnHgNwNnr06KHm1hyNl156KaTn79Onj7nN4cOH1dz6vhQqa06GtU6Xl5ebzzFixAg1v+uuu9R8zpw5ap6RkaHm1jyV9oI7GgAAAAC8o9AAAAAA4B2FBgAAAADvKDQAAAAAeEehAQAAAMA7Cg0AAAAA3lFoAAAAAPCu1czR6Ny5s7mN1dfc6vts9VWurKxU88jISDW3+t/7YPWWtli9r63e1NbjgxyfNefCei9s377dfI5Q9o+2Kzo62tzGmuFgvccTEhLU3FqnrNyaQWHNuhGx5xJZMyasdSArK0vNrbXQmmUyZMgQNRex15Hq6mo1t85jYmKieQzA2bj00kvV3PouMnfu3JCe35rTISJSVVWl5qHO3Ar1+5S1RgVZJ0OdlXP99der+bvvvqvm1jyV9oI7GgAAAAC8o9AAAAAA4B2FBgAAAADvKDQAAAAAeEehAQAAAMA7Cg0AAAAA3lFoAAAAAPCu1czRCA8PN7c5fvy4mlt9la0ZD6Hu3wer93SovautvDWwXmNxcbGaW++lUHtno/Wy5jOI2PMRCgsL1bxjx45qbvV/r6urU/P4+PiQchG7D3+o64A1a8Sa42E9vkuXLuYxWH34rXk51jH06tXLPAbgbAwaNEjNN27cqObW9e2D9X3J+j5kfQ5b12+Q74Qaaw6IiD13yTrGnTt3qvnnn3+u5pdffrmad+3aVc2tz6rWgjsaAAAAALyj0AAAAADgHYUGAAAAAO8oNAAAAAB4R6EBAAAAwDsKDQAAAADeUWgAAAAA8I5CAwAAAIB3521gnzVkKsgAqdraWjW3hqvs379fzVNTU9W8pKREza1Bc9aAKB+sY7BYv4dQh+gEeY6UlBQ1twbxWOc5NjZWzdF2HThwwNwmJiZGzf/2t7+puTVMrkePHmpuHaM1hKm8vFzNRUQuu+wyNbfWUmsooTXc1Mqt15iQkKDmIvbgw5UrV6q5tZatX7/ePAagJdnZ2WpufddYsmSJz8M5RZDPcWtgn5Vbn8MVFRUhPT7UgYAiIlFRUWpufVZYa9Ddd9+t5itWrFDz2267Tc1/9rOfqXlrwR0NAAAAAN5RaAAAAADwjkIDAAAAgHcUGgAAAAC8o9AAAAAA4B2FBgAAAADvKDQAAAAAeHfe5mh07txZzZOSksx97NmzR82jo6PV3Oq7bM13sPpGB5kFYjnXx2A93mLt38c5sOZoRETob1trzkGQOQRom5577jkv22gGDBig5rt371Zza8aEdY127dpVzUVEampqQsqtYygqKlJzax2w5nR0795dzYOYPn16yPsAzsbYsWPVvKysTM3z8/N9Hs4prM9QEXuORX19vZo3NDSouTVbzZpRYa2jQb6LbNu2Tc2tY7R+j4cOHQopz8zMVPO2gjsaAAAAALyj0AAAAADgHYUGAAAAAO8oNAAAAAB4R6EBAAAAwDsKDQAAAADeUWgAAAAA8O68zdEIdcaFiEiHDnpdZPV1to7Bcj5mSFis3tahPj7U/QeZ01FbW6vm1u+xsLBQzQ8cOKDmsbGxag5orBkQVVVVam69/605L0HmaFizaELtUZ+VlaXmoc7xOB/XqPV5EurMIVy8Xn75ZTXfsGGDmn/22WchPb81J2Pr1q3mPqzPYeu7gnWN+/hOqLHmeATZJjk5Wc2t7xqW8ePHh/T4toI7GgAAAAC8o9AAAAAA4B2FBgAAAADvKDQAAAAAeEehAQAAAMA7Cg0AAAAA3lFoAAAAAPDuvM3RSEhIUPOYmBhzH1ZvaKuvs9U3PVQ+5mhY+7DOwbl+jVZv6yC9q1NTU9X83XffVfPc3Fw1LygoUPO0tDQ1R/tmXUNW//ioqCg179Spk5pb13h8fLyaB5kxYc3J2Lx5s5oHmdWhKS0tVXPrHO7evdt8DmsfVh9/4EIJdU6GxVojgsyosObIWGtMqN8Vqqur1dwSZA6OtRaf69lroc4tayu4owEAAADAOwoNAAAAAN5RaAAAAADwjkIDAAAAgHcUGgAAAAC8o9AAAAAA4B2FBgAAAADvztscjY4dO6p5kJ7HVm9oq//9rFmz1Hzy5MlqbvXftwTpmWzNwbB6U1uPt/pCV1VVqbnV+zoxMVHNRUTWrVun5g8//LCaz58/X8379++v5rt27VJzQGP1j7euocrKSjW31rkgvd2tY+zVq1dIz2HNPbJmiZSVlal5kLWWORporazPYSu3vitYn8ORkZFqHmTml7WN9RqsY7S+81nf56zX6GNWiDUPyGKdoyDfezVtZQ4HdzQAAAAAeEehAQAAAMA7Cg0AAAAA3lFoAAAAAPCOQgMAAACAdxQaAAAAALyj0AAAAADg3Xmbo2H1Vbd6LovYfZHT0tLUfNu2bWr+wQcfqPnf/d3fqfnRo0fVPEjvaqsHv7UPq3++dQ6t3Hp+q7++iMj06dPV3DqPWVlZam6916z3CRAKawZFfHx8SI8P0nvdmmdz7NgxNbdmVBQWFqp5kLVOE6Q/fKg96M91j3tcvKz3jpUHmQGhsa4/H/MXamtr1dyahWPN0rHmCVlzcoKsQdbvoby83NyHJtRZI+0FdzQAAAAAeEehAQAAAMA7Cg0AAAAA3lFoAAAAAPCOQgMAAACAdxQaAAAAALyj0AAAAADg3Xmbo2H1jj98+LC5D6vnsDWDwvJv//Zvav6b3/xGzT/66CM1HzRokHkMqampam71t7fmWFh9nbds2aLme/fuVfPevXuruYjIhx9+qOZxcXFqXlJSouYHDx5U84qKCjUHNNY6ZPWPt65Ra46GlYvY66n1Gqwe9V26dFHz0tJSNa+vr1fzINdoqNexj1kCwLkQ6nvTmkVlXd8i9iwPawaFtQ5GRkaqeceOHdW8urpaza3vOiL2ebbWqVD3f7HgjgYAAAAA7yg0AAAAAHhHoQEAAADAOwoNAAAAAN5RaAAAAADwjkIDAAAAgHcUGgAAAAC8o9AAAAAA4N15G9hnDX+5/vrrQ36OuXPnhvT45cuXq3lKSoqaZ2Zmqnl2drZ5DNbAu9raWjU/fvy4moeFhal5QUGBmlvD8oIMXrReg5Vbw8Yee+wxNd+wYYOaL1q0SM3RtoU6RMkaFFdXV6fm1vvXGlgZ5PitYVixsbFqbg2qsoZlWefIGsZlnUMfGKaF1soahmex1hhrqK2ISHJysppb17D1XcM6Ruv6tIYXBxnYZw0WPXLkiLkPDWvMCdzRAAAAAOAdhQYAAAAA7yg0AAAAAHhHoQEAAADAOwoNAAAAAN5RaAAAAADwjkIDAAAAgHfnbY6GNV9hz5495j6qqqrUfMWKFWd0TGfK6u1uvYYgr3HdunVndEwXo2PHjqn5F198oeYff/yxz8NBG2P1d7dUVlaqeWJiopp36dJFzaOjo9W8X79+ai5i9+G3euBbczDi4+PVfOPGjWqelpam5p988oma+0CPe1ys0tPTzW2sWTzWnAprHbPWIGv/1iyfILNIrJldoQp1Hkp7wR0NAAAAAN5RaAAAAADwjkIDAAAAgHcUGgAAAAC8o9AAAAAA4B2FBgAAAADvKDQAAAAAeHfe5misX79ezZcsWWLuw+p5bPVuD1Wo/fetvtBBtjnXvd+t/ft4/lB7Sz/99NNqPnToUDU/1+8TtG4NDQ0hPX7fvn1qPnfuXDUvLS1V8/r6ejUPcg2WlZWpeUSEvvRb58jqgW/NHLKEutYGwRwNtFXW9WutIdYaJSLywAMPqLk1a2f//v3mc2isNcSaq5aRkWE+xyuvvHJGx/RVof4eLhbc0QAAAADgHYUGAAAAAO8oNAAAAAB4R6EBAAAAwDsKDQAAAADeUWgAAAAA8I5CAwAAAIB3YY5m4gAAAAA8444GAAAAAO8oNAAAAAB4R6EBAAAAwDsKDQAAAADeUWgAAAAA8I5CAwAAAIB3FBoAAAAAvKPQAAAAAOAdhQYAAAAA7/4fOn5MzEEs4toAAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 1000x300 with 3 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Define the class names for FashionMNIST\n",
        "class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
        "\n",
        "# Quick inspection of augmented images\n",
        "def quick_inspect(loader, num_images=3):\n",
        "    dataiter = iter(loader)\n",
        "    images, labels = next(dataiter)\n",
        "    plt.figure(figsize=(10, 3))\n",
        "    for i in range(num_images):\n",
        "        plt.subplot(1, num_images, i+1)\n",
        "        plt.imshow(images[i].numpy().reshape(28, 28), cmap='gray')\n",
        "        # Display both the label index and the corresponding class name\n",
        "        plt.title(f'Label: {labels[i].item()} ({class_names[labels[i].item()]})')\n",
        "        plt.axis('off')\n",
        "    plt.show()\n",
        "\n",
        "# Print the shape of one batch from the expanded dataset\n",
        "for el in expanded_loader:  # Use expanded_loader instead of trainloader\n",
        "    x, y = el\n",
        "    print(x.shape, y.shape)\n",
        "    break\n",
        "\n",
        "# Use the quick inspection function if needed\n",
        "quick_inspect(expanded_loader)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z6jMPCtL_3TR"
      },
      "source": [
        "## 6. Bulding a neural network\n",
        "\n",
        "Number of inputs for neurons will be given by input data, i.e. image dims (flattened), size. Output - by number of classes, 10 in our case."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "EYGX-9RP-6B4"
      },
      "outputs": [],
      "source": [
        "model = MyModel(n_input=784, n_hiddens=[1500], n_output=10)  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The model has 1192510 trainable parameters.\n"
          ]
        }
      ],
      "source": [
        "# Function to get the number of parameters\n",
        "def get_npars(model):\n",
        "    \"\"\"\n",
        "    Returns the total number of trainable parameters in the given PyTorch model.\n",
        "    \"\"\"\n",
        "    n = np.sum([np.prod(list(p.shape)) for p in model.parameters()])\n",
        "    return int(n)\n",
        "\n",
        "# Get and print the number of parameters in the model\n",
        "num_parameters = get_npars(model)\n",
        "print(f'The model has {num_parameters} trainable parameters.')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Loss function\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-5)  # weight decay for regularization\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f5o71gymAA9h"
      },
      "source": [
        "Defining a training function:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "dTrUXsn1_04A"
      },
      "outputs": [],
      "source": [
        "def train(model, expanded_loader, criterion, optimizer):\n",
        "    model.train()\n",
        "    running_loss = 0.0\n",
        "    for images, labels in expanded_loader:\n",
        "        optimizer.zero_grad()  \n",
        "        output, _, _ = model(images) \n",
        "        loss = criterion(output, labels) \n",
        "        loss.backward()  \n",
        "        optimizer.step()  \n",
        "        running_loss += loss.item() \n",
        "    return running_loss / len(expanded_loader) \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bdMh6wDbADtZ"
      },
      "source": [
        "Defining a testing function:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "u7h2JtuFADQA"
      },
      "outputs": [],
      "source": [
        "def test(model, testloader, criterion):\n",
        "    model.eval()\n",
        "    running_loss = 0.0\n",
        "    n_correct = 0\n",
        "    n_samples = 0  \n",
        "\n",
        "    with torch.no_grad(): \n",
        "        for images, labels in testloader:\n",
        "            output, prob, pred = model(images)\n",
        "            loss = criterion(output, labels) \n",
        "            running_loss += loss.item()\n",
        "\n",
        "            correct = torch.sum(pred == labels) \n",
        "            n_correct += correct.item()  \n",
        "            n_samples += labels.size(0) \n",
        "\n",
        "    accuracy = n_correct / n_samples  # Compute overall accuracy\n",
        "    return running_loss / len(testloader), accuracy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "ZFsha_J42uPv"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "64"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "testloader.batch_size"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OGvXGVvaAH_g"
      },
      "source": [
        "Training the model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "B34VjSa2AGsf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/10, Train Loss: 0.5735, Test Loss: 0.4397, Test Accuracy: 0.8389\n",
            "Epoch 2/10, Train Loss: 0.4877, Test Loss: 0.4217, Test Accuracy: 0.8502\n",
            "Epoch 3/10, Train Loss: 0.4655, Test Loss: 0.4020, Test Accuracy: 0.8532\n",
            "Epoch 4/10, Train Loss: 0.4496, Test Loss: 0.3962, Test Accuracy: 0.8605\n",
            "Epoch 5/10, Train Loss: 0.4422, Test Loss: 0.3824, Test Accuracy: 0.8679\n",
            "Epoch 6/10, Train Loss: 0.4339, Test Loss: 0.3786, Test Accuracy: 0.8664\n",
            "Epoch 7/10, Train Loss: 0.4281, Test Loss: 0.3798, Test Accuracy: 0.8687\n",
            "Epoch 8/10, Train Loss: 0.4223, Test Loss: 0.3750, Test Accuracy: 0.8680\n",
            "Epoch 9/10, Train Loss: 0.4176, Test Loss: 0.3732, Test Accuracy: 0.8727\n",
            "Epoch 10/10, Train Loss: 0.4145, Test Loss: 0.3710, Test Accuracy: 0.8693\n"
          ]
        }
      ],
      "source": [
        "import time\n",
        "\n",
        "# Lists to store losses and accuracy for Test E model\n",
        "train_losses_testE = []\n",
        "test_losses_testE = []\n",
        "test_accuracies_testE = []  \n",
        "time_per_epochE = []\n",
        "\n",
        "num_epochs = 10 # Number of epochs for training\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    start_time = time.time()  # Startzeit für die Epoche\n",
        "    train_loss = train(model, expanded_loader, criterion, optimizer)\n",
        "    test_loss, test_accuracy = test(model, testloader, criterion)  # Assuming test returns loss and accuracy\n",
        "\n",
        "   # Store losses for Test E model\n",
        "    train_losses_testE.append(train_loss)\n",
        "    test_losses_testE.append(test_loss)\n",
        "\n",
        "     # Store accuracy for TestE model\n",
        "    test_accuracies_testE.append(test_accuracy)\n",
        "\n",
        "    end_time = time.time()  # Endzeit der Epoche\n",
        "    epoch_time = end_time - start_time  # Berechne die Zeit für diese Epoche\n",
        "    time_per_epochE.append(epoch_time)\n",
        "\n",
        "    print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy:.4f}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XjNpSOZ8BdTA"
      },
      "source": [
        "Visualize the loss curves"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "tQNq_xOGAJc_"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x500 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plotting the loss curves for the Test E model\n",
        "fig, ax = plt.subplots(figsize=(10, 5))\n",
        "ax.plot(range(num_epochs), train_losses_testE, label='Training Loss')\n",
        "ax.plot(range(num_epochs), test_losses_testE, label='Test Loss')\n",
        "ax.set_xlabel('Epoch')\n",
        "ax.set_ylabel('Loss')\n",
        "ax.legend(loc='upper right')\n",
        "ax.set_title('Loss Curves for E Model')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "_z0KQzL9_lOK"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1176000\n",
            "1500\n",
            "15000\n",
            "10\n"
          ]
        }
      ],
      "source": [
        "for p in model.parameters():\n",
        "  print(np.prod(list(p.shape)))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "ogO__Cv9BtYO"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy: 0.8693\n"
          ]
        }
      ],
      "source": [
        "def get_predictions(model, loader):\n",
        "    model.eval()\n",
        "    predictions = []\n",
        "    labels = []\n",
        "    images_list = []\n",
        "    with torch.no_grad():\n",
        "        for images, label in loader:\n",
        "            output, _, _ = model(images)\n",
        "            pred = output.argmax(dim=1)\n",
        "            predictions.extend(pred.tolist())\n",
        "            labels.extend(label.tolist())\n",
        "            images_list.extend(images)\n",
        "    return predictions, labels, images_list\n",
        "\n",
        "def calculate_accuracy(predictions, labels):\n",
        "    correct = sum(pred == label for pred, label in zip(predictions, labels))\n",
        "    total = len(labels)\n",
        "    accuracy = correct / total\n",
        "    return accuracy\n",
        "\n",
        "# Get predictions, labels, and images\n",
        "predictions, labels, images_list = get_predictions(model, testloader)\n",
        "correct = [pred == label for pred, label in zip(predictions, labels)]\n",
        "\n",
        "accuracy = calculate_accuracy(predictions, labels)\n",
        "\n",
        "print(f\"Accuracy: {accuracy}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E43y5wzgEkO6"
      },
      "source": [
        "Aggregate a correct and incorrect example and visualize:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "M_XRml4MB4AG"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "First incorrect digit is at index: 2\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "First correct digit is at index: 0\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Get the class names from the dataset\n",
        "class_names = trainset.classes\n",
        "\n",
        "# Find the index of the first incorrect and correct prediction\n",
        "wrong_idx = next((i for i, correct in enumerate(correct) if not correct), None)\n",
        "correct_idx = next((i for i, correct in enumerate(correct) if correct), None)\n",
        "\n",
        "# Function to display an image\n",
        "def display_image(image, title):\n",
        "    plt.imshow(image.numpy().reshape(28, 28), cmap='gray')\n",
        "    plt.title(title)\n",
        "    plt.show()\n",
        "\n",
        "# Display the first incorrect sample (if any incorrect are found)\n",
        "if wrong_idx is not None:\n",
        "    print(f\"First incorrect digit is at index: {wrong_idx}\")\n",
        "    pred = predictions[wrong_idx]\n",
        "    lbl  = labels[wrong_idx]\n",
        "    display_image(images_list[wrong_idx], f\"Predicted: {pred} ({class_names[pred]}), Actual: {lbl}({class_names[lbl]})\")\n",
        "else:\n",
        "    print(\"No incorrect predictions found\")\n",
        "\n",
        "# Display the first correct sample (if any correct are found)\n",
        "if correct_idx is not None:\n",
        "    print(f\"First correct digit is at index: {correct_idx}\")\n",
        "    pred = predictions[correct_idx]\n",
        "    lbl  = labels[correct_idx]\n",
        "    display_image(images_list[correct_idx], f\"Predicted: {pred} ({class_names[pred]}), Actual: {lbl}({class_names[lbl]})\")\n",
        "else:\n",
        "    print(\"No correct predictions found\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IvrCUICwExDB"
      },
      "source": [
        "## 7. Visualizing the Parameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "kpuGXde1DL1t"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "torch.Size([10, 1500]) torch.Size([10])\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1300x500 with 10 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#inspecting and visualising the weights of the output layer\n",
        "layer = model.lout \n",
        "n_features = layer.out_features \n",
        "w1, b1 = layer.weight.data, layer.bias.data #extract weights and biases from the output layer.\n",
        "print(w1.shape, b1.shape) ## expecting w1 to be [n_features, 1500]\n",
        "\n",
        "w1_reshaped = w1.view(n_features, 30, 50) #Adjust the view dimensions as per layer's configuration of 1500 neurons\n",
        "\n",
        "# Plotting the weights\n",
        "_, axs = plt.subplots(1, n_features, figsize=(13, 5))\n",
        "\n",
        "for i in range(10): # Loop over the number of output features (classes)\n",
        "    axs[i].imshow(w1_reshaped[i].numpy(), cmap='gray', interpolation='nearest')\n",
        "    axs[i].grid(False)\n",
        "    axs[i].axis('off')\n",
        "    axs[i].set_title(f'{trainset.classes[i]}')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "KgZYX8zQh-gb"
      },
      "outputs": [],
      "source": [
        "def get_predictions(model, loader):\n",
        "    model.eval()\n",
        "    predictions = []\n",
        "    labels = []\n",
        "    images_list = []\n",
        "    with torch.no_grad():\n",
        "        for images, label in loader:\n",
        "            output, probs, pred = model(images)\n",
        "            predictions.extend(pred.tolist())\n",
        "            labels.extend(label.tolist())\n",
        "            images_list.extend(images)\n",
        "    return predictions, labels, images_list\n",
        "\n",
        "def calculate_accuracy(predictions, labels):\n",
        "    correct = sum(pred == label for pred, label in zip(predictions, labels))\n",
        "    total = len(labels)\n",
        "    accuracy = correct / total\n",
        "    return accuracy\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "Kk6Y9MM1h-l-"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy: 0.8693\n"
          ]
        }
      ],
      "source": [
        "# Generate predictions and compute the final accuracy after training the model\n",
        "predictions, labels, images_list = get_predictions(model, testloader)  \n",
        "accuracy = calculate_accuracy(predictions, labels)\n",
        "print(f\"Accuracy: {accuracy}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Trained model saved as testE_trained_model.pth\n"
          ]
        }
      ],
      "source": [
        "import datetime\n",
        "\n",
        "# Get the current date and time for unique naming\n",
        "current_time = datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
        "\n",
        "# Define the filename using only the test name (will overwrite with each run)\n",
        "test_name = \"testE\"  # Replace with your test name\n",
        "model_filename = f'{test_name}_trained_model.pth'\n",
        "\n",
        "# Save the model and optimizer state dicts\n",
        "save_dict = {\n",
        "    'model_state_dict': model.state_dict(),\n",
        "    'optimizer_state_dict': optimizer.state_dict(),\n",
        "    'epoch': num_epochs,\n",
        "    'train_loss': train_losses_testE,\n",
        "    'test_loss': test_losses_testE,\n",
        "    'time_per_epoch': time_per_epochE\n",
        "}\n",
        "\n",
        "torch.save(save_dict, model_filename)  # Add this line to actually save the dictionary\n",
        "print(f'Trained model saved as {model_filename}')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Results saved in testE_results.json\n"
          ]
        }
      ],
      "source": [
        "# Code for Storing Results in JSON Files\n",
        "import json\n",
        "\n",
        "# Store the results (losses and accuracy) in a dictionary\n",
        "results = {\n",
        "    'train_losses': train_losses_testE,  \n",
        "    'test_losses': test_losses_testE,    \n",
        "    'test_accuracies': test_accuracies_testE, \n",
        "    'final_accuracy': accuracy,  # Store the final accuracy calculated earlier\n",
        "    'time_per_epoch': time_per_epochE\n",
        "}\n",
        "\n",
        "# Save results to a JSON file, overwrite each time\n",
        "json_filename = f'{test_name}_results.json'  # No timestamp to allow overwriting\n",
        "with open(json_filename, 'w') as f:\n",
        "    json.dump(results, f)\n",
        "print(f'Results saved in {json_filename}')\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "aicp",
      "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.10.14"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}