AICP_M02_C.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 C: Two-Layer Model (Baseline) with Manually Expanded Dataset (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",
        "\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",
        "          \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 a given number of pixels in the x and y directions.\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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OyxjipoN9dfS"
      },
      "source": [
        "\n",
        "## 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": "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",
            "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)\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.4642, Test Loss: 0.4043, Test Accuracy: 0.8551\n",
            "Epoch 2/10, Train Loss: 0.3647, Test Loss: 0.3562, Test Accuracy: 0.8744\n",
            "Epoch 3/10, Train Loss: 0.3355, Test Loss: 0.3524, Test Accuracy: 0.8747\n",
            "Epoch 4/10, Train Loss: 0.3167, Test Loss: 0.3565, Test Accuracy: 0.8729\n",
            "Epoch 5/10, Train Loss: 0.3003, Test Loss: 0.3602, Test Accuracy: 0.8740\n",
            "Epoch 6/10, Train Loss: 0.2885, Test Loss: 0.3791, Test Accuracy: 0.8666\n",
            "Epoch 7/10, Train Loss: 0.2785, Test Loss: 0.3367, Test Accuracy: 0.8876\n",
            "Epoch 8/10, Train Loss: 0.2693, Test Loss: 0.3479, Test Accuracy: 0.8838\n",
            "Epoch 9/10, Train Loss: 0.2605, Test Loss: 0.3402, Test Accuracy: 0.8858\n",
            "Epoch 10/10, Train Loss: 0.2536, Test Loss: 0.3615, Test Accuracy: 0.8792\n"
          ]
        }
      ],
      "source": [
        "import time\n",
        "\n",
        "# Lists to store losses and accuracy for Test C model\n",
        "train_losses_testC = []\n",
        "test_losses_testC = []\n",
        "test_accuracies_testC = []  \n",
        "time_per_epochC = []\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 C model\n",
        "    train_losses_testC.append(train_loss)\n",
        "    test_losses_testC.append(test_loss)\n",
        "\n",
        "     # Store accuracy for TestC model\n",
        "    test_accuracies_testC.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_epochC.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 C model\n",
        "fig, ax = plt.subplots(figsize=(10, 5))\n",
        "ax.plot(range(num_epochs), train_losses_testC, label='Training Loss')\n",
        "ax.plot(range(num_epochs), test_losses_testC, 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 C 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.8792\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: 1\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.8792\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": 24,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Trained model saved as testC_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 = \"testC\"  # 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_testC,\n",
        "    'test_loss': test_losses_testC,\n",
        "    'time_per_epoch': time_per_epochC\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": 25,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Results saved in testC_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_testC,  \n",
        "    'test_losses': test_losses_testC,    \n",
        "    'test_accuracies': test_accuracies_testC, \n",
        "    'final_accuracy': accuracy,  # Store the final accuracy calculated earlier\n",
        "    'time_per_epoch': time_per_epochC\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
}