AICP_M02_A.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",
        "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."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kmjKrW6WjS3K"
      },
      "source": [
        "## 1. Load necessary libraries\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "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": [
        "#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",
        "        # Creating the Hidden Layers      \n",
        "        self.ls = []#list to store the hidden layers\n",
        "        n_prev = n_input\n",
        "        for i, n_out in enumerate(n_hiddens):\n",
        "          l = nn.Linear(n_prev, n_out)  #Create a linear layer from n_prev to n_out neurons.\n",
        "          n_prev = n_out # Update n_prev to the current layer's output size\n",
        "          self.add_module(f'lin_{i}_{n_out}', l) # registers the layer with the model\n",
        "          self.ls.append(l) # Add the layer to the list of layers\n",
        "\n",
        "        #Creating the Output Layer\n",
        "        self.lout = nn.Linear(n_prev, n_output) # final layer to match the output classes n_outtput in dataset\n",
        "  \n",
        "#Forward Pass Definition\n",
        "    def forward(self, x):\n",
        "        # Flatten the input image to 1D before passing to linear layers\n",
        "        x = torch.flatten(x, start_dim=1)  # Flatten to (batch_size, 784), pushed it from loading data to here to keep images in their original 2D form (28x28) throughout the data loading process giving more flexibility in data augmentation and preprocessing.\n",
        "        \n",
        "        h = x # The initial hidden state is the input x\n",
        "        for li in self.ls:  \n",
        "          h = li(h) \n",
        "          h = torch.relu(h) # each hidden layer is followed by ReLU activation\n",
        "\n",
        "        # Output Layer and Softmax Activation\n",
        "        logits = self.lout(h) # Output layer (logits)\n",
        "        probs = F.softmax(logits, dim=1) # apply softmax activation to logits to convert them into class probabilities\n",
        "        pred = torch.argmax(probs, dim=1) # gets the predicted class\n",
        "\n",
        "        return logits, probs, pred\n",
        "        "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OyxjipoN9dfS"
      },
      "source": [
        "## 3. Load the data\n",
        "\n",
        "First we will load the data: 60000 training images and 10000 images for validation with some included data transformations.Each image is a 28x28 pixels. For this model we will interpret it as a 1D array of 784 elements.Note: The images are originally 28x28 pixels. Since a neural network expects a flat array of features (a 1D vector), each 28x28 image needs to be transformed into a 1D array of 784 elements (since 28×28=784)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "O-EivCFK87eQ"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Train dataset shape: 60000 total images and labels\n",
            "Test dataset shape: 10000 total images and labels\n"
          ]
        }
      ],
      "source": [
        "# Define the transformation to normalize the data\n",
        "transform = transforms.Compose([transforms.ToTensor(), # Converts the PIL Image to a tensor. This also converts the pixel values from 0-255 to 0-1.\n",
        "                                transforms.Normalize((0.5,), (0.5,))]) # Normalizes the tensor with mean 0 and standard deviation 1.\n",
        "                                \n",
        "\n",
        "# Download and load the training data\n",
        "trainset = datasets.FashionMNIST('~/.pytorch/FMNIST_data/', download=True, train=True, transform=transform)\n",
        "trainloader = DataLoader(trainset, batch_size=64, shuffle=True)\n",
        "\n",
        "# Download and load the test data\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 shapes of the datasets\n",
        "print('Train dataset shape:', len(trainset), 'total images and labels')\n",
        "print('Test dataset shape:', len(testset), 'total images and labels')\n",
        "#The len() function returns the total number of items in the dataset. For FashionMNIST, len(trainset) will return 60,000, and len(testset) will return 10,000."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "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": 5,
      "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 trainloader:\n",
        "  x, y = el \n",
        "  print(x.shape, y.shape) \n",
        "  break"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "wIgya80r9ABY"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x1000 with 5 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x1000 with 5 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "class_names = trainset.classes\n",
        "def show_images(images, labels, num_images=5):\n",
        "    plt.figure(figsize=(10, 10))\n",
        "    for i in range(num_images):\n",
        "        plt.subplot(1, num_images, i+1)\n",
        "        plt.xticks([])\n",
        "        plt.yticks([])\n",
        "        plt.grid(False)\n",
        "        # Reshape the flattened images back to 28x28 for display\n",
        "        plt.imshow(images[i].numpy().reshape(28, 28), cmap='gray')\n",
        "        lbl = labels[i].item()\n",
        "        plt.xlabel(f'Label: {lbl} ({class_names[lbl]})')\n",
        "    plt.show()\n",
        "\n",
        "# Function to get random images and labels from a dataset\n",
        "def get_random_images(loader, num_images=5):\n",
        "    dataiter = iter(loader)\n",
        "    images, labels = next(dataiter)\n",
        "    indices = list(range(len(images)))\n",
        "    random_indices = random.sample(indices, num_images)\n",
        "    random_images = images[random_indices]\n",
        "    random_labels = labels[random_indices]\n",
        "    return random_images, random_labels\n",
        "\n",
        "# Get random images and labels from the training set\n",
        "random_images, random_labels = get_random_images(trainloader, num_images=5) \n",
        "# Show images\n",
        "show_images(random_images, random_labels, num_images=5)\n",
        "\n",
        "# and for the test set:\n",
        "random_images, random_labels = get_random_images(testloader, num_images=5)\n",
        "show_images(random_images, random_labels, num_images=5)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZM0bbfI4-4Ii"
      },
      "source": [
        "Check out the dimensions of the data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "1L2cggGn948g"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Shape of the images: torch.Size([5, 1, 28, 28])\n",
            "Shape of the labels: torch.Size([5])\n",
            "tensor([9, 5, 1, 9, 1])\n"
          ]
        }
      ],
      "source": [
        "# Inspect the dimensions of the sample elements\n",
        "print(\"Shape of the images:\", random_images.shape)#Tells you the dimensions of the batch of images (e.g., how many images and how they are represented).\n",
        "print(\"Shape of the labels:\", random_labels.shape) #Tells you the dimensions of the batch of labels (e.g., how many labels correspond to the images).\n",
        "print(random_labels)#Displays the actual label values for the batch, allowing you to see what classes each image in the batch belongs to."
      ]
    },
    {
      "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",
        "\n",
        "# Optimizer (Adam) without regularization\n",
        "optimizer = optim.Adam(model.parameters(), lr=0.001)  # No 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, trainloader, criterion, optimizer):\n",
        "    model.train()\n",
        "    running_loss = 0.0\n",
        "    for images, labels in trainloader:\n",
        "        optimizer.zero_grad()  # reset gradients\n",
        "        output, _, _ = model(images) # passes images through model to get raw outputs (logits), probabilities and predicted labels\n",
        "        loss = criterion(output, labels) # computes loss between predicted and true labels using cross entropy loss (criterion)\n",
        "        loss.backward()  # computes gradients of the loss with respect to the model's parameters using backpropagation   \n",
        "        optimizer.step()  # updates model parameters using the computed gradients and the optimizer's learning rate\n",
        "        running_loss += loss.item() # adds the current batch's loss to the total loss for this epoch\n",
        "    return running_loss / len(trainloader) # computes average loss over all batches in the epoch to track training progress\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  # To keep track of the total number of samples\n",
        "\n",
        "    with torch.no_grad(): # Disables gradient computation for testing\n",
        "        for images, labels in testloader:\n",
        "            output, prob, pred = model(images)\n",
        "            loss = criterion(output, labels) # calculate the loss\n",
        "            running_loss += loss.item()\n",
        "\n",
        "            correct = torch.sum(pred == labels) # number of correct predictions in the batch\n",
        "            n_correct += correct.item()  # Accumulate the correct predictions\n",
        "            n_samples += labels.size(0)  # Accumulate the total number of samples\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": 16,
      "metadata": {
        "id": "B34VjSa2AGsf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/10, Train Loss: 0.1392, Test Loss: 0.4061, Test Accuracy: 0.8909\n",
            "Epoch 2/10, Train Loss: 0.1351, Test Loss: 0.4091, Test Accuracy: 0.8907\n",
            "Epoch 3/10, Train Loss: 0.1316, Test Loss: 0.4131, Test Accuracy: 0.8897\n",
            "Epoch 4/10, Train Loss: 0.1254, Test Loss: 0.4035, Test Accuracy: 0.8921\n",
            "Epoch 5/10, Train Loss: 0.1217, Test Loss: 0.4637, Test Accuracy: 0.8839\n",
            "Epoch 6/10, Train Loss: 0.1224, Test Loss: 0.4533, Test Accuracy: 0.8881\n",
            "Epoch 7/10, Train Loss: 0.1139, Test Loss: 0.4326, Test Accuracy: 0.8921\n",
            "Epoch 8/10, Train Loss: 0.1122, Test Loss: 0.4623, Test Accuracy: 0.8833\n",
            "Epoch 9/10, Train Loss: 0.1074, Test Loss: 0.4945, Test Accuracy: 0.8834\n",
            "Epoch 10/10, Train Loss: 0.1053, Test Loss: 0.4587, Test Accuracy: 0.8920\n"
          ]
        }
      ],
      "source": [
        "import time\n",
        "\n",
        "# Lists to store losses and accuracy for Baseline model\n",
        "train_losses_baseline = []\n",
        "test_losses_baseline = []\n",
        "test_accuracies_baseline = []  \n",
        "time_per_epoch_baseline = []\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, trainloader, criterion, optimizer)\n",
        "    test_loss, test_accuracy = test(model, testloader, criterion)  # Assuming test returns loss and accuracy\n",
        "\n",
        "   # Store losses for Baseline model\n",
        "    train_losses_baseline.append(train_loss)\n",
        "    test_losses_baseline.append(test_loss)\n",
        "\n",
        "     # Store accuracy for TestB model\n",
        "    test_accuracies_baseline.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_epoch_baseline.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": 17,
      "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\n",
        "fig, ax = plt.subplots(figsize=(10, 5))\n",
        "ax.plot(range(num_epochs), train_losses_baseline, label='Training Loss')\n",
        "ax.plot(range(num_epochs), test_losses_baseline, label='Test Loss')\n",
        "ax.set_xlabel('Epoch')\n",
        "ax.set_ylabel('Loss')\n",
        "ax.legend(loc='upper right')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "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": 19,
      "metadata": {
        "id": "zPUM_HJ6Hw1L"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1192510"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "get_npars(model)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "ogO__Cv9BtYO"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy: 0.892\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": 21,
      "metadata": {
        "id": "M_XRml4MB4AG"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "First incorrect digit is at index: 15\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": [
        "\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": "markdown",
      "metadata": {},
      "source": [
        "The model's layers are stored in model.ls and model.lout - for the output layer.\n",
        "In out case this is the only layer.\n",
        "\n",
        "The learned model parameters W1 are a matrix of weights that show importance of each input pixel (784) for each of the 10 outputs."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "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": [
        "layer = model.lout #The code is accessing the output layer\n",
        "n_features = layer.out_features # number of output features (classes) should be 10 for 10 classes.\n",
        "#n_features is the number of output classes (10), and 1500 is the number of neurons in the hidden layer\n",
        "#For example, if w1.shape is (10, 1500), it means each output neuron (class) connects to all 1500 neurons in the hidden layer.\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",
        "#Choose a reshape that fits the number of neurons in the hidden layer (1500),  # Adjust the view dimensions as per your layer's configuration\n",
        "# Let's reshape each weight vector to a 2D grid that fits: for example, (30, 50)\n",
        "w1_reshaped = w1.view(n_features, 30, 50) #Adjust the view dimensions as per your layer's configuration\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": "markdown",
      "metadata": {
        "id": "zH6SLtqXLSwg"
      },
      "source": [
        "Here we classify images into 10 classes. But think of it: does the network know, or need to know that those were images? For the network each image is just a 784 values. And it finds that there is a patten.\n",
        "\n",
        "Same way one can feed any other bunch of numbers, and the network will try it's best to fugure out a relation pattern between those.\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "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": 24,
      "metadata": {
        "id": "Kk6Y9MM1h-l-"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy: 0.892\n"
          ]
        }
      ],
      "source": [
        "predictions, labels, images_list = get_predictions(model, testloader)  # TEST\n",
        "\n",
        "accuracy = calculate_accuracy(predictions, labels)\n",
        "\n",
        "print(f\"Accuracy: {accuracy}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Trained model saved as baseline_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 = \"baseline\"  # 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_baseline,\n",
        "    'test_loss': test_losses_baseline,\n",
        "    'time_per_epoch': time_per_epoch_baseline\n",
        "    \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}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Results saved in baseline_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_baseline,  \n",
        "    'test_losses': test_losses_baseline,    \n",
        "    'test_accuracies': test_accuracies_baseline, \n",
        "    'final_accuracy': accuracy,  # Store the final accuracy as a separate key\n",
        "    'time_per_epoch': time_per_epoch_baseline\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"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    }
  ],
  "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
}