fashion_MNIST_classifier.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MojTabaa4/MNIST-classifier/blob/main/fashion_MNIST_classifier.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Loading the Fashion-MNIST dataset into memory\n",
        "\n",
        "The code above imports the TensorFlow library and uses its built-in function `tf.keras.datasets.fashion_mnist.load_data()` to download and load the Fashion-MNIST dataset into memory.\n",
        "\n",
        "The Fashion-MNIST dataset is a collection of images that is often used for image classification tasks. It consists of 60,000 training images and 10,000 testing images, with each image being a grayscale 28x28 pixel image of a clothing item from one of 10 different classes.\n",
        "\n",
        "The `load_data()` function returns two tuples, `train_images` and `train_labels`, and `test_images` and `test_labels`, which contain the training and testing data respectively.\n",
        "\n",
        "# Normalizing the pixel values\n",
        "\n",
        "The pixel values in the images are typically represented as integers between 0 and 255, where 0 represents black and 255 represents white. In order to prepare the data for training a machine learning model, it is common to normalize the pixel values to be between 0 and 1. This is done in the code above by dividing the pixel values in both the training and testing images by 255.0.\n",
        "\n",
        "This normalization step can improve the performance of machine learning models by making it easier for them to learn from the data."
      ],
      "metadata": {
        "collapsed": false,
        "id": "nPNryA7FhEFl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "from numpy import ndarray\n",
        "\n",
        "# Load the Fashion-MNIST dataset into memory\n",
        "(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.fashion_mnist.load_data()\n",
        "\n",
        "train_images = train_images / 255.0\n",
        "test_images = test_images / 255.0"
      ],
      "metadata": {
        "id": "yoyWPUXAsLsy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fbb109e9-f273-462c-d331-8e50d947bc29",
        "ExecuteTime": {
          "end_time": "2023-06-03T13:45:09.964252628Z",
          "start_time": "2023-06-03T13:44:16.296051039Z"
        }
      },
      "execution_count": 1,
      "outputs": [
        {
          "metadata": {
            "tags": null
          },
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz\n",
            "29515/29515 [==============================] - 0s 0us/step\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz\n",
            "26421880/26421880 [==============================] - 1s 0us/step\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz\n",
            "5148/5148 [==============================] - 0s 0us/step\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz\n",
            "4422102/4422102 [==============================] - 1s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "WtZERq-RVwsN"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Visualizing the Fashion-MNIST dataset\n",
        "\n",
        "The first block of code above uses the NumPy library to extract the unique classes from the training labels and store them in the `unique_classes` variable. It then creates a grid of subplots using the `subplots()` function from the Matplotlib library, with one subplot for each unique class.\n",
        "\n",
        "Next, it loops through the unique classes and selects one image from each class to plot in its corresponding subplot. This is done by using the `where()` function from NumPy to find the indices of all images in the training set that belong to the current class, and then selecting the first index from that array. The `imshow()` function from Matplotlib is used to display the image in grayscale, and the `set_title()` function is used to set the title of the subplot to the current class.\n",
        "\n",
        "The result of this code block is a grid of subplots, with each subplot showing one example image from a different class of clothing item.\n",
        "\n",
        "The second block of code above uses NumPy again to extract the unique classes from the training labels and count the number of occurrences of each class, which is stored in the `class_counts` variable.\n",
        "\n",
        "It then uses the `bar()` function from Matplotlib to create a bar chart showing the frequency of each class in the training set. The `xticks()` function is used to set the x-axis labels to the unique classes, and the `xlim()` function is used to set the limits of the x-axis to show all unique classes.\n",
        "\n",
        "Finally, the `xlabel()`, `ylabel()`, and `title()` functions are used to set the labels and title of the plot. The result is a bar chart showing the frequency of each class in the training set, which can be useful for understanding the distribution of the data and identifying potential biases.\n",
        "\n",
        "The classes of the Fashion-MNIST dataset are:\n",
        "\n",
        "1. T-shirt/top\n",
        "2. Trouser\n",
        "3. Pullover\n",
        "4. Dress\n",
        "5. Coat\n",
        "6. Sandal\n",
        "7. Shirt\n",
        "8. Sneaker\n",
        "9. Bag\n",
        "10. Ankle boot\n",
        "\n",
        "Each class contains 6,000 grayscale images with a resolution of 28x28 pixels, for a total of 60,000 images in the dataset. The images are labeled with integer values ranging from 0 to 9, corresponding to the class of the clothing item or accessory."
      ],
      "metadata": {
        "collapsed": false,
        "id": "LQHRksTZhEFv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "unique_classes = np.unique(train_labels)\n",
        "\n",
        "# Create a grid of subplots\n",
        "fig, axs = plt.subplots(1, len(unique_classes), figsize=(20, 5))\n",
        "\n",
        "# Plot one image from each class in a separate subplot\n",
        "for i, cls in enumerate(unique_classes):\n",
        "    idx = np.where(train_labels == cls)[0][0]\n",
        "    axs[i].imshow(train_images[idx], cmap='gray')\n",
        "    axs[i].set_title(f\"Class {cls}\")\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 174
        },
        "id": "jVhD0hS7ZSY8",
        "outputId": "0f153f27-65d7-422a-abfc-a7ec775ecd53",
        "is_executing": true
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2000x500 with 10 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "unique_classes, class_counts = np.unique(train_labels, return_counts=True)\n",
        "\n",
        "plt.bar(unique_classes, class_counts, color='b')\n",
        "plt.xticks(unique_classes)  # set the x-ticks to the unique classes\n",
        "\n",
        "# set the x-axis limits to show all unique classes\n",
        "plt.xlim(unique_classes[0] - 0.5, unique_classes[-1] + 0.5)\n",
        "\n",
        "plt.xlabel('Class')\n",
        "plt.ylabel('Frequency')\n",
        "plt.title('Class Frequency in Train Labels')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 489
        },
        "id": "1MPY-CCVXfo5",
        "outputId": "749dde37-e636-4cae-e808-827006db4cf0",
        "is_executing": true
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Class Frequency in Train Labels')"
            ]
          },
          "metadata": {},
          "execution_count": 4
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "unique_classes, class_counts = np.unique(test_labels, return_counts=True)\n",
        "\n",
        "plt.bar(unique_classes, class_counts, color='r')\n",
        "plt.xticks(unique_classes)\n",
        "\n",
        "plt.xlim(unique_classes[0] - 0.5, unique_classes[-1] + 0.5)\n",
        "\n",
        "plt.xlabel('Class')\n",
        "plt.ylabel('Frequency')\n",
        "plt.title('Class Frequency in Test Labels')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 489
        },
        "id": "GuaHnkaXXfjM",
        "outputId": "6ab91eb1-8958-4da1-9c25-e1856180eb2d",
        "is_executing": true
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Class Frequency in Test Labels')"
            ]
          },
          "metadata": {},
          "execution_count": 5
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Custom DataLoader class for Fashion-MNIST dataset\n",
        "\n",
        "The code above defines a custom `DataLoader` class for the Fashion-MNIST dataset, which can be used to load data in batches for training a machine learning model. The class takes in the dataset and labels as NumPy arrays, as well as an optional batch size and shuffle flag.\n",
        "\n",
        "The `__init__()` method initializes the data and labels arrays, batch size, and shuffle flag. It also computes the number of samples and classes in the dataset, and one-hot encodes the labels using the `np.eye()` function.\n",
        "\n",
        "The `__shuffle_dataset()` method shuffles the data and one-hot encoded labels using `np.random.permutation()`, which randomly permutes the indices of the samples in the dataset.\n",
        "\n",
        "The `__iter__()` method is used to iterate over the data in batches. If the `shuffle` flag is set to `True`, it calls the `__shuffle_dataset()` method to shuffle the dataset before iterating over it.\n",
        "\n",
        "If the `batch_size` is `None`, it yields the entire dataset as a single batch. Otherwise, it iterates over the data in batches of size `batch_size`. For each batch, it extracts the corresponding batch of data and one-hot encoded labels, and yields them as a tuple.\n",
        "\n",
        "The result of this code block is a custom `DataLoader` class that can be used to load Fashion-MNIST data in batches for machine learning model training."
      ],
      "metadata": {
        "collapsed": false,
        "id": "RECoYhBLhEFy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import Tuple, Optional\n",
        "\n",
        "\n",
        "class DataLoader:\n",
        "    def __init__(self, data: np.ndarray, labels: np.ndarray, batch_size: Optional[int] = 32,\n",
        "                 shuffle: Optional[bool] = True) -> None:\n",
        "        # Initialize the data and labels arrays, batch size, and shuffle flag\n",
        "        self.__data = data\n",
        "        self.__labels = labels\n",
        "        self.__batch_size = batch_size\n",
        "        self.__shuffle = shuffle\n",
        "\n",
        "        # Compute the number of samples and classes in the dataset\n",
        "        self.__num_samples = data.shape[0]\n",
        "        self.__num_classes = np.max(labels) + 1\n",
        "\n",
        "        # One-hot encode the labels using np.eye()\n",
        "        self.__onehot_labels = np.eye(self.__num_classes)[labels]\n",
        "\n",
        "    def __shuffle_dataset(self) -> None:\n",
        "        # Shuffle the data and one-hot encoded labels using np.random.permutation()\n",
        "        indices = np.random.permutation(self.__num_samples)\n",
        "        self.__data = self.__data[indices]\n",
        "        self.__onehot_labels = self.__onehot_labels[indices]\n",
        "\n",
        "    def __iter__(self) -> Tuple[np.ndarray, np.ndarray]:\n",
        "        if self.__shuffle:\n",
        "            self.__shuffle_dataset()\n",
        "\n",
        "        # If batch size is None, yield the entire dataset as a single batch\n",
        "        if self.__batch_size is None:\n",
        "            yield (np.array(self.__data.reshape(-1, self.__data.shape[1], self.__data.shape[2], 1)),\n",
        "                   np.array(self.__onehot_labels))\n",
        "            return\n",
        "\n",
        "        # Iterate over the data in batches of size batch_size\n",
        "        for idx in range(0, len(self.__data), self.__batch_size):\n",
        "            # Extract the corresponding batch of data and one-hot encoded labels\n",
        "            batch_data = np.array(\n",
        "                self.__data[idx:idx + self.__batch_size].reshape(-1, self.__data.shape[1], self.__data.shape[2], 1))\n",
        "            batch_labels = np.array(self.__onehot_labels[idx:idx + self.__batch_size])\n",
        "\n",
        "            # Yield the batch as a tuple\n",
        "            yield batch_data, batch_labels\n"
      ],
      "metadata": {
        "id": "ofLiOzh5XfY4",
        "is_executing": true
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Activation Functions for Neural Networks\n",
        "\n",
        "The code above defines various activation functions that can be used in neural networks. Activation functions are used to introduce non-linearity into the output of a neural network, allowing it to model complex relationships between the input and output.\n",
        "\n",
        "The `ActivationFunction` class is the base class for all activation functions defined in this code block. It has an `__init__()` method that does not take any arguments, and two methods: `__compute_value()` and `derivative()`.\n",
        "\n",
        "The `__compute_value()` method is used to compute the value of the activation function for a given input matrix, while the `derivative()` method is used to compute the derivative of the activation function with respect to the input matrix.\n",
        "\n",
        "The `Identical` class defines the identity activation function, which simply returns the input matrix. The `Relu` class defines the Rectified Linear Unit (ReLU) activation function, which returns the maximum of the input matrix and 0. The `LeakyRelu` class defines the Leaky ReLU activation function, which is similar to ReLU but has a small slope for negative inputs.\n",
        "\n",
        "The `Sigmoid` class defines the sigmoid activation function, which returns the sigmoid of the input matrix. The `Softmax` class defines the softmax activation function, which is commonly used in the output layer of a neural network for multi-class classification problems.\n",
        "\n",
        "All activation functions defined in this code block inherit from the `ActivationFunction` base class and override the `__compute_value()` and `derivative()` methods to implement their respective activation functions.\n",
        "\n",
        "The result of this code block is a set of activation functions that can be used in neural networks to introduce non-linearity and improve their performance."
      ],
      "metadata": {
        "collapsed": false,
        "id": "x3XkK4F4hEFz"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "outputs": [],
      "source": [
        "class ActivationFunction:\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def __compute_value(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        raise NotImplementedError\n",
        "\n",
        "    def derivative(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        raise NotImplementedError\n",
        "\n",
        "    def __call__(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        return self.__compute_value(matrix)\n"
      ],
      "metadata": {
        "is_executing": true,
        "id": "23XeR4HShEFz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Identical(ActivationFunction):\n",
        "    def __compute_value(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        return np.matrix(matrix, dtype=np.float32)\n",
        "\n",
        "    def derivative(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        return np.matrix(np.full(np.shape(matrix), 1.), dtype=np.float32)\n",
        "\n",
        "    def __call__(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        return self.__compute_value(matrix)"
      ],
      "metadata": {
        "id": "TiRK2eB9ousE",
        "is_executing": true
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Relu(ActivationFunction):\n",
        "    def __compute_value(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        relu_value = np.maximum(matrix, 0)\n",
        "        return np.matrix(relu_value, dtype=np.float32)\n",
        "\n",
        "    def derivative(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        relu_derivative = np.where(matrix > 0, 1.0, 0.0)\n",
        "        return np.matrix(relu_derivative, dtype=np.float32)\n",
        "\n",
        "    def __call__(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        return self.__compute_value(matrix)\n"
      ],
      "metadata": {
        "id": "Ffh-dv0XXfTy",
        "is_executing": true
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class LeakyRelu(ActivationFunction):\n",
        "    def __init__(self, negative_slope: float = 0.01) -> None:\n",
        "        super().__init__()\n",
        "        self.negative_slope = negative_slope\n",
        "\n",
        "    def __compute_value(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        leaky_relu_value = np.maximum(matrix, 0)\n",
        "        negative_part = np.minimum(matrix, 0) * self.negative_slope\n",
        "        return np.matrix(leaky_relu_value + negative_part, dtype=np.float32)\n",
        "\n",
        "    def derivative(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        leaky_relu_derivative = np.where(matrix > 0, 1.0, self.negative_slope)\n",
        "        return np.matrix(leaky_relu_derivative, dtype=np.float32)\n"
      ],
      "metadata": {
        "id": "ilEKmg9NXfQv",
        "is_executing": true
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Sigmoid(ActivationFunction):\n",
        "    def __compute_value(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        sigmoid_value = 1 / (1 + np.exp(-matrix))\n",
        "        return np.matrix(sigmoid_value, dtype=np.float32)\n",
        "\n",
        "    def derivative(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        sigmoid_value = self.__compute_value(matrix)\n",
        "        sigmoid_derivative = np.multiply(sigmoid_value, 1 - sigmoid_value)\n",
        "        return np.matrix(sigmoid_derivative, dtype=np.float32)\n",
        "\n",
        "    def __call__(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        return self.__compute_value(matrix)\n",
        "\n"
      ],
      "metadata": {
        "id": "qcd8UqtgXfNx",
        "is_executing": true
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Softmax(ActivationFunction):\n",
        "    def __compute_value(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        softmax_value = np.exp(np.asarray(matrix) - np.max(np.asarray(matrix), axis=1, keepdims=True))\n",
        "        softmax_value /= np.sum(np.asarray(softmax_value), axis=1, keepdims=True)\n",
        "        return softmax_value\n",
        "\n",
        "    def derivative(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        softmax_value = self.__compute_value(matrix)\n",
        "        return softmax_value * (1 - softmax_value)\n",
        "\n",
        "    def __call__(self, matrix: np.ndarray) -> np.ndarray:\n",
        "        return self.__compute_value(matrix)\n"
      ],
      "metadata": {
        "id": "OeZIl6WbroFr",
        "is_executing": true
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Cross-Entropy Loss Function for Neural Networks\n",
        "\n",
        "The code above defines the `CrossEntropy` class, which is a commonly used loss function for multi-class classification problems in neural networks.\n",
        "\n",
        "The `CrossEntropy` class has an `__init__()` method that initializes the `Softmax` activation function, which is used to compute the softmax of the predicted values. It has two methods: `__compute_value()` and `derivative()`.\n",
        "\n",
        "The `__compute_value()` method is used to compute the cross-entropy loss between the true values and predicted values. It takes in two NumPy arrays: `true_val` and `pred_val`, which represent the true values and predicted values, respectively. It first ensures that the shapes of the two input arrays are the same, and then clips the predicted values to a small value to avoid numerical instability.\n",
        "\n",
        "It then uses the `Softmax` activation function to compute the softmax of the predicted values, and computes the cross-entropy loss using the formula `-true_val*log(pred_val_softmax)`. The result is a NumPy array representing the cross-entropy loss for each sample in the batch.\n",
        "\n",
        "The `derivative()` method computes the derivative of the cross-entropy loss with respect to the predicted values. It takes in the same two input arrays as `__compute_value()`, and first ensures that their shapes are the same. It then computes the softmax of the predicted values using the `Softmax` activation function, and returns the difference between the softmax values and the true values.\n",
        "\n",
        "The `__call__()` method is a convenience method that calls the `__compute_value()` method to compute the cross-entropy loss for the given inputs.\n",
        "\n",
        "The result of this code block is a `CrossEntropy` class that can be used as a loss function in neural networks for multi-class classification problems."
      ],
      "metadata": {
        "collapsed": false,
        "id": "SXHvtN7MhEF2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class CrossEntropy:\n",
        "    def __init__(self):\n",
        "        self.softmax = Softmax()\n",
        "\n",
        "    def __compute_value(self, true_val: np.ndarray, pred_val: np.ndarray) -> np.ndarray:\n",
        "        assert true_val.shape == pred_val.shape\n",
        "        pred_val = np.clip(pred_val, 1e-8, None)\n",
        "\n",
        "        pred_val_softmax = self.softmax(pred_val)\n",
        "        loss = -np.sum(np.asarray(true_val) * np.log(pred_val_softmax), axis=1, keepdims=True)\n",
        "\n",
        "        return loss\n",
        "\n",
        "    def derivative(self, true_val: np.ndarray, pred_val: np.ndarray) -> np.ndarray:\n",
        "        assert true_val.shape == pred_val.shape\n",
        "        pred_val_softmax = self.softmax(pred_val)\n",
        "        return pred_val_softmax - true_val\n",
        "\n",
        "    def __call__(self, true_val: np.ndarray, pred_val: np.ndarray) -> np.ndarray:\n",
        "        return self.__compute_value(true_val, pred_val)\n"
      ],
      "metadata": {
        "id": "GiUrf3XPvJUX",
        "is_executing": true
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# NeuralLayer Class\n",
        "\n",
        "The NeuralLayer class represents a single layer in a neural network. It contains:\n",
        "\n",
        "## `__init__()`\n",
        "\n",
        "Initializes the layer with:\n",
        "- `input_size`: Number of input neurons\n",
        "- `output_size`: Number of output neurons\n",
        "- `activation`: The activation function for this layer\n",
        "- `initial_weight`: The weight initialization method ('uniform' or 'normal')\n",
        "- Other optional parameters for weight initialization\n",
        "\n",
        "Initializes weight and bias variables using the specified initialization method.\n",
        "\n",
        "## `forward()`\n",
        "\n",
        "Perform a forward pass through the layer:\n",
        "- Multiplies the input `layer_input` by the weight matrix\n",
        "- Adds the bias\n",
        "- Applies the activation function\n",
        "- Stores the input, output and derivative for backpropagation\n",
        "\n",
        "Returns the activation output\n",
        "\n",
        "## `update_weights()`\n",
        "\n",
        "Perform a weight update during backpropagation:\n",
        "- Calculates the gradients of the loss with respect to the weights, biases and input\n",
        "- Updates the weights and biases by moving in the opposite direction of the gradient by the learning rate `lr`\n",
        "\n",
        "Returns the back propagated error tensor\n",
        "\n",
        "## Weight initialization methods\n",
        "\n",
        "The weights are initialized using either:\n",
        "\n",
        "- `__uniform_weight()`: Initializes weights randomly from a uniform distribution between `low` and `high`\n",
        "- `__normal_weight()`: Initializes weights from a normal distribution with mean `mean` and variance `var`\n",
        "\n",
        "The initialized weight matrix is then returned."
      ],
      "metadata": {
        "id": "mfgqvvyi7DIR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import math\n",
        "from typing import Optional\n",
        "\n",
        "\n",
        "class NeuralLayer:\n",
        "    # Default values for initialization parameters\n",
        "    DEFAULT_LOW: float = 0\n",
        "    DEFAULT_HIGH: float = 0.05\n",
        "    DEFAULT_MEAN: float = 0.\n",
        "    DEFAULT_VAR: float = 1.\n",
        "\n",
        "    def __init__(self, input_size: int, output_size: int, activation, initial_weight: str = 'uniform',\n",
        "                 **initializing_parameters):\n",
        "        \"\"\"\n",
        "        Initializes a layer of neurons with the specified input and output sizes,\n",
        "        activation function, and weight initialization method.\n",
        "\n",
        "        Args:\n",
        "            input_size (int): The number of input neurons.\n",
        "            output_size (int): The number of output neurons.\n",
        "            activation (Activation): The activation function to use for the layer.\n",
        "            initial_weight (str): The weight initialization method to use.\n",
        "            **initializing_parameters: Additional parameters for weight initialization.\n",
        "\n",
        "        Raises:\n",
        "            ValueError: If the activation function is not specified.\n",
        "            ValueError: If the weight initialization method is not recognized.\n",
        "        \"\"\"\n",
        "        if activation is None:\n",
        "            raise ValueError('Activation function must be specified!')\n",
        "\n",
        "        # Dictionary to map weight initialization method names to functions\n",
        "        weight_initializer_methods = {\n",
        "            'uniform': self.__uniform_weight,\n",
        "            'normal': self.__normal_weight\n",
        "        }\n",
        "\n",
        "        if initial_weight not in weight_initializer_methods:\n",
        "            raise ValueError('Undefined weight initialization function!')\n",
        "\n",
        "        # Initialize instance variables\n",
        "        self.n_neurons: int = output_size\n",
        "        self.weight_initializer = weight_initializer_methods[initial_weight]\n",
        "        self.weight = self.weight_initializer(input_size, self.n_neurons, **initializing_parameters)\n",
        "        self.bias = self.weight_initializer(1, self.n_neurons, **initializing_parameters)\n",
        "        self.activation = activation\n",
        "\n",
        "        # Last computed values\n",
        "        self.last_input: Optional[np.ndarray] = None\n",
        "        self.last_activation_input: Optional[np.ndarray] = None\n",
        "        self.last_activation_output: Optional[np.ndarray] = None\n",
        "        self.last_activation_derivative: Optional[np.ndarray] = None\n",
        "\n",
        "    def forward(self, layer_input: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        Computes the output of the layer given an input.\n",
        "\n",
        "        Args:\n",
        "            layer_input (ndarray): The input to the layer.\n",
        "\n",
        "        Returns:\n",
        "            ndarray: The output of the layer.\n",
        "\n",
        "        Raises:\n",
        "            ValueError: If the input is not a 2D array.\n",
        "            ValueError: If the input size does not match the weight size.\n",
        "        \"\"\"\n",
        "        if np.ndim(layer_input) != 2:\n",
        "            layer_input = layer_input.reshape(layer_input.shape[0], -1)  # Reshape to 2D array\n",
        "\n",
        "        if np.size(self.weight, 0) != np.size(layer_input, 1):\n",
        "            raise ValueError(\n",
        "                f'Weight shape 0 {np.size(self.weight, 0)} and Layer shape 1 {np.size(layer_input, 1)} do not match!')\n",
        "\n",
        "        # Compute activation input, output, and derivative\n",
        "        self.last_input = layer_input\n",
        "        self.last_activation_input = np.matmul(layer_input, self.weight) + self.bias\n",
        "        self.last_activation_output = self.activation(self.last_activation_input)\n",
        "        self.last_activation_derivative = self.activation.derivative(self.last_activation_input)\n",
        "\n",
        "        return self.last_activation_output\n",
        "\n",
        "    def update_weights(self, backprop_tensor: np.ndarray, lr: float) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        Updates the weights of the layer given a backpropagation tensor and a learning rate.\n",
        "\n",
        "        Args:\n",
        "            backprop_tensor (ndarray): The backpropagation tensor from the next layer.\n",
        "            lr (float): The learning rate.\n",
        "\n",
        "        Returns:\n",
        "            ndarray: The backpropagation tensor for the current layer.\n",
        "\n",
        "        Raises:\n",
        "            ValueError: If the backprop tensor is not a 2D array.\n",
        "            ValueError: If the backprop tensor shape does not match the activation derivative shape.\n",
        "            ValueError: If the backprop tensor shape does not match the number of neurons in the layer.\n",
        "        \"\"\"\n",
        "        if np.ndim(backprop_tensor) != 2:\n",
        "            raise ValueError('Backprop tensor must be a 2D array!')\n",
        "        if np.size(backprop_tensor, 0) != np.size(self.last_activation_derivative, 0):\n",
        "            raise ValueError(\n",
        "                f'Backprop tensor shape 0 {np.size(backprop_tensor, 1)} and activation derivative shape 0 {np.size(self.last_activation_derivative, 0)} do not match!')\n",
        "        if np.size(backprop_tensor, 1) != self.n_neurons:\n",
        "            raise ValueError(\n",
        "                f'Backprop tensor shape 1 {np.size(backprop_tensor, 1)} and number of neurons {self.n_neurons} do not match!')\n",
        "\n",
        "        # Compute gradients and update weights and biases\n",
        "        bias_mul = np.ones(np.size(backprop_tensor, 0))\n",
        "        bias_mul = np.asmatrix(bias_mul)\n",
        "        derivation_of_L_to_Y = np.multiply(self.last_activation_derivative, backprop_tensor)\n",
        "        derivation_of_L_to_W = np.matmul(self.last_input.T, derivation_of_L_to_Y)\n",
        "        derivation_of_L_to_B = np.matmul(bias_mul, derivation_of_L_to_Y)\n",
        "        backprop_tensor = np.matmul(derivation_of_L_to_Y, self.weight.T)\n",
        "        self.weight = self.weight - lr * derivation_of_L_to_W\n",
        "        self.bias = self.bias - lr * derivation_of_L_to_B\n",
        "\n",
        "        return backprop_tensor\n",
        "\n",
        "    def __uniform_weight(self, dim1: int, dim2: int, **initializing_parameters) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        Initializes weights using a uniform distribution with the specified parameters.\n",
        "\n",
        "        Args:\n",
        "            dim1 (int): The first dimension of the weight matrix.\n",
        "            dim2 (int): The second dimension of the weight matrix.\n",
        "\n",
        "        Returns:\n",
        "            ndarray: The initialized weight matrix.\n",
        "        \"\"\"\n",
        "        low = initializing_parameters.get('low', self.DEFAULT_LOW)\n",
        "        high = initializing_parameters.get('high', self.DEFAULT_HIGH)\n",
        "        weights = np.random.uniform(low=low, high=high, size=(dim1, dim2))\n",
        "        weights = np.asmatrix(weights)\n",
        "\n",
        "        return weights\n",
        "\n",
        "    def __normal_weight(self, dim1: int, dim2: int, **initializing_parameters) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        Initializes weights using a normal distribution with the specified parameters.\n",
        "\n",
        "        Args:\n",
        "            dim1 (int): The first dimension of the weight matrix.\n",
        "            dim2 (int): The second dimension of the weight matrix.\n",
        "\n",
        "        Returns:\n",
        "            ndarray: The initialized weight matrix.\n",
        "        \"\"\"\n",
        "        mean = initializing_parameters.get('mean', self.DEFAULT_MEAN)\n",
        "        var = initializing_parameters.get('var', self.DEFAULT_VAR)\n",
        "        weights = np.random.normal(loc=mean, scale=math.sqrt(var), size=(dim1, dim2))\n",
        "        weights = np.asmatrix(weights)\n",
        "\n",
        "        return weights\n"
      ],
      "metadata": {
        "id": "wyEOTF9-0KJI",
        "is_executing": true
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# FeedForwardNN Class\n",
        "\n",
        "This class implements a feedforward neural network with:\n",
        "\n",
        "- Arbitrary number of layers\n",
        "- Customizable activation functions and weight initialization\n",
        "- Trainable with stochastic gradient descent\n",
        "\n",
        "## `__init__()`\n",
        "\n",
        "Initializes the model and stores:\n",
        "\n",
        "- `input_shape`: The input dimension\n",
        "- `output_shape`: The output dimension of the last layer (set after adding layers)\n",
        "- `layers_list`: A list of added `NeuralLayer` instances\n",
        "- `lr`: Learning rate (set later)\n",
        "- `loss`: Loss function (set later)\n",
        "\n",
        "## `add_layer()`\n",
        "\n",
        "Adds a `NeuralLayer` to the network with:\n",
        "\n",
        "- `n_neurons`: Number of neurons in the layer\n",
        "- Other arguments are passed to the `NeuralLayer` initializer\n",
        "\n",
        "Updates the `output_shape` and appends the new layer to `layers_list`\n",
        "\n",
        "## `set_training_param()`\n",
        "\n",
        "Sets the:\n",
        "\n",
        "- `loss`: Loss function\n",
        "- `lr`: Learning rate\n",
        "\n",
        "## `forward()`\n",
        "\n",
        "Performs a forward pass by running input through each layer sequentially and returns the final output.\n",
        "\n",
        "## `fit()`\n",
        "\n",
        "Fits the model to data by:\n",
        "\n",
        "- Training on `trainloader` (runs `_train()`)\n",
        "- Testing on `testloader` (runs `_test()`)\n",
        "- Logging the loss and accuracy after each epoch\n",
        "\n",
        "Returns a dict containing the losses and accuracies.\n",
        "\n",
        "## `_run_on_loader()`\n",
        "\n",
        "Runs the model on a data loader by:\n",
        "\n",
        "- Iterating over batches\n",
        "- Running `_run_on_batch()` for each batch\n",
        "- Averaging the accuracies and losses\n",
        "\n",
        "## `_run_on_batch()`\n",
        "\n",
        "Runs a forward pass and calculates:\n",
        "\n",
        "- The `batch_accuracy`\n",
        "- The `batch_average_loss`\n",
        "\n",
        "If training, runs `_update_weights()`\n",
        "\n",
        "## `_get_labels()`\n",
        "\n",
        "Converts model outputs to one-hot encoded labels for computing accuracy\n",
        "\n",
        "## `_compute_accuracy()`\n",
        "\n",
        "Calculates the accuracy between model outputs and expected outputs\n",
        "\n",
        "## `_update_weights()`\n",
        "\n",
        "Performs backpropagation through all layers:\n",
        "\n",
        "- Calculates the derivative of the loss w.r.t. the outputs\n",
        "- Updates each layer's weights using its `update_weights()` method\n",
        "   passing the derivative and `self._lr` learning rate"
      ],
      "metadata": {
        "id": "OsqFCkGxKjKQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import List, Tuple, Dict, Optional, Iterable\n",
        "\n",
        "\n",
        "class FeedForwardNN:\n",
        "    \"\"\"\n",
        "    A feedforward neural network class with customizable layers,\n",
        "    loss function, and optimization algorithm for training.\n",
        "\n",
        "    Example usage:\n",
        "\n",
        "    model = FeedForwardNN(input_shape=200)\n",
        "    model.add_layer(256, activation=Relu())\n",
        "    model.add_layer(10, activation=Softmax())\n",
        "    model.set_training_param(loss=CrossEntropy(), lr=1e-3)\n",
        "    log = model.fit(epochs=10, train_loader=train_loader, test_loader=test_loader)\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, input_shape: int):\n",
        "        \"\"\"\n",
        "        Initialize a new feedforward neural network object.\n",
        "\n",
        "        Args:\n",
        "            input_shape: int, the shape of the input data (number of features).\n",
        "        \"\"\"\n",
        "        self._input_shape = input_shape\n",
        "        self._output_shape = None\n",
        "        self._layers_list = []\n",
        "        self._lr = None\n",
        "        self._loss = None\n",
        "\n",
        "    def add_layer(self,\n",
        "                  n_neurons: int,\n",
        "                  activation,\n",
        "                  initial_weight: str = 'uniform',\n",
        "                  **initializing_parameters) -> None:\n",
        "        \"\"\"\n",
        "        Add a new layer to the neural network.\n",
        "\n",
        "        Args:\n",
        "            n_neurons: int, the number of neurons in the new layer.\n",
        "            activation: an instance of an activation function class.\n",
        "            initial_weight: str, the initialization method for the layer weights            (default is 'uniform').\n",
        "            **initializing_parameters: additional parameters for the weight initialization method.\n",
        "\n",
        "        Returns:\n",
        "            None.\n",
        "        \"\"\"\n",
        "        self._validate_neurons_number(n_neurons)\n",
        "\n",
        "        n_prev_neurons = self._input_shape if not self._layers_list else self._layers_list[-1].n_neurons\n",
        "        new_layer = NeuralLayer(n_prev_neurons, n_neurons, activation, initial_weight, **initializing_parameters)\n",
        "        self._layers_list.append(new_layer)\n",
        "        self._output_shape = self._layers_list[-1].n_neurons\n",
        "\n",
        "    def set_training_param(self, loss, lr: float) -> None:\n",
        "        \"\"\"\n",
        "        Set the loss function and learning rate for the neural network training.\n",
        "\n",
        "        Args:\n",
        "            loss: an instance of a loss function class.\n",
        "            lr: float, the learning rate for the optimization algorithm.\n",
        "        \"\"\"\n",
        "        if not self._layers_list:\n",
        "            raise ValueError(\"Incomplete model\")\n",
        "\n",
        "        self._loss = loss\n",
        "        self._lr = lr\n",
        "\n",
        "    def forward(self, network_input: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        Perform a forward pass through the neural network.\n",
        "\n",
        "        Args:\n",
        "            network_input: numpy array, the input data to the neural network.\n",
        "\n",
        "        Returns:\n",
        "            numpy array, the output of the neural network.\n",
        "        \"\"\"\n",
        "        if not self._output_shape:\n",
        "            raise ValueError(\"Model is not compiled!\")\n",
        "\n",
        "        for layer in self._layers_list:\n",
        "            network_input = layer.forward(network_input)\n",
        "\n",
        "        network_output = network_input\n",
        "\n",
        "        return network_output\n",
        "\n",
        "    def fit(self,\n",
        "            epochs: int,\n",
        "            train_loader: Iterable[Tuple[np.ndarray, np.ndarray]],\n",
        "            test_loader: Optional[Iterable[Tuple[np.ndarray, np.ndarray]]] = None,\n",
        "            print_results: bool = True) -> Dict[str, List[float]]:\n",
        "        \"\"\"\n",
        "        Train the neural network on a given dataset for a specified number of epochs.\n",
        "\n",
        "        Args:\n",
        "            epochs: int, the number of training epochs.\n",
        "            train_loader: an iterable that provides batches of training data.\n",
        "            test_loader: an iterable that provides batches of test data (optional).\n",
        "            print_results: bool, whether to print the results after each epoch.\n",
        "\n",
        "        Returns:\n",
        "            dict, a log of the training and test accuracy and loss for each epoch.\n",
        "        \"\"\"\n",
        "        self._validate_model_and_params()\n",
        "        log = {\"train_accuracy\": [], \"train_loss\": [], \"test_accuracy\": [], \"test_loss\": []}\n",
        "\n",
        "        for epoch in range(1, epochs + 1):\n",
        "            if print_results:\n",
        "                print(f'Epoch {epoch}:')\n",
        "\n",
        "            train_accuracy, train_loss = self._train(train_loader)\n",
        "\n",
        "            log['train_accuracy'].append(train_accuracy)\n",
        "            log['train_loss'].append(train_loss)\n",
        "\n",
        "            if print_results:\n",
        "                print(f'\\tTrain: Average Accuracy: {train_accuracy}\\tAverage Loss: {train_loss}')\n",
        "\n",
        "            if test_loader:\n",
        "                test_accuracy, test_loss = self._test(test_loader)\n",
        "                log['test_accuracy'].append(test_accuracy)\n",
        "                log['test_loss'].append(test_loss)\n",
        "                if print_results:\n",
        "                    print(f'\\tTest: Average Accuracy: {test_accuracy}\\tAverage Loss:{test_loss}')\n",
        "\n",
        "        return log\n",
        "\n",
        "    def _train(self, train_loader: Iterable[Tuple[np.ndarray, np.ndarray]]) -> tuple[ndarray, ndarray]:\n",
        "        \"\"\"\n",
        "        Train the neural network on a single batch of training data.\n",
        "\n",
        "        Args:\n",
        "            train_loader: an iterable that provides batches of training data.\n",
        "\n",
        "        Returns:\n",
        "            float, the average training accuracy on the batch.\n",
        "            float, the average training loss on the batch.\n",
        "        \"\"\"\n",
        "        return self._run_on_loader(train_loader, train=True)\n",
        "\n",
        "    def _test(self, test_loader: Iterable[Tuple[np.ndarray, np.ndarray]]) -> tuple[ndarray, ndarray]:\n",
        "        \"\"\"\n",
        "        Test the neural network on a single batch of test data.\n",
        "\n",
        "        Args:\n",
        "            test_loader: an iterable that provides batches of test data.\n",
        "\n",
        "        Returns:\n",
        "            float, the average test accuracy on the batch.\n",
        "            float, the average test loss on the batch.\n",
        "        \"\"\"\n",
        "        return self._run_on_loader(test_loader, train=False)\n",
        "\n",
        "    def _run_on_loader(self, loader: Iterable[Tuple[np.ndarray, np.ndarray]], train: bool) -> tuple[ndarray, ndarray]:\n",
        "        \"\"\"\n",
        "        Run the neural network on a given dataset (train or test).\n",
        "\n",
        "        Args:\n",
        "            loader: an iterable that provides batches of data.\n",
        "            train: bool, whether to train the network or not.\n",
        "\n",
        "        Returns:\n",
        "            float, the average accuracy on the dataset.\n",
        "            float, the average loss on the dataset.\n",
        "        \"\"\"\n",
        "        accuracies, losses = [], []\n",
        "\n",
        "        for x_batch, y_batch in loader:\n",
        "            accuracy, loss = self._run_on_batch(x_batch, y_batch, train)\n",
        "            accuracies.append(accuracy)\n",
        "            losses.append(loss)\n",
        "\n",
        "        return np.mean(accuracies), np.mean(losses)\n",
        "\n",
        "    def _run_on_batch(self, x_batch: np.ndarray, y_batch: np.ndarray, train: bool) -> Tuple[float, float]:\n",
        "        \"\"\"\n",
        "        Run the neural network on a single batch of data.\n",
        "\n",
        "        Args:\n",
        "            x_batch: numpy array, the input data for the batch.\n",
        "            y_batch: numpy array, the target output data for the batch.\n",
        "            train: bool, whether to train the network or not.\n",
        "\n",
        "        Returns:\n",
        "            float, the accuracy on the batch.\n",
        "            float, the average loss on the batch.\n",
        "        \"\"\"\n",
        "        batch_res = self.forward(x_batch)\n",
        "\n",
        "        batch_accuracy = self._compute_accuracy(batch_res, y_batch, train)\n",
        "\n",
        "        batch_losses = self._loss(y_batch, batch_res)\n",
        "        batch_average_loss = np.mean(batch_losses)\n",
        "\n",
        "        if train:\n",
        "            self._update_weights(batch_res, y_batch)\n",
        "\n",
        "        return batch_accuracy, batch_average_loss\n",
        "\n",
        "    def _get_labels(self, outputs: np.ndarray, train=False) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        Convert the predicted output probabilities into binary labels.\n",
        "\n",
        "        Args:\n",
        "            outputs: numpy array, the predicted output probabilities.\n",
        "\n",
        "        Returns:\n",
        "            numpy array, the binary labels.\n",
        "        \"\"\"\n",
        "        labels = np.zeros((outputs.shape[0], outputs.shape[1]))\n",
        "        indices = np.argmax(outputs, axis=1)\n",
        "\n",
        "        for i in range(outputs.shape[0]):\n",
        "            labels[i, indices[i]] = 1\n",
        "\n",
        "        return labels\n",
        "\n",
        "    def _compute_accuracy(self, output: np.ndarray, expected_output: np.ndarray, train=False) -> float:\n",
        "        \"\"\"\n",
        "        Compute the accuracy of the predicted output with respect to the expected output.\n",
        "\n",
        "        Args:\n",
        "            output: numpy array, the predicted output from the neural network.\n",
        "            expected_output: numpy array, the ground truth output.\n",
        "\n",
        "        Returns:\n",
        "            float, the accuracy of the predicted output.\n",
        "        \"\"\"\n",
        "        output_labels = self._get_labels(output, train)\n",
        "        expected_labels = self._get_labels(expected_output, train)\n",
        "        accuracy = np.mean(np.all(output_labels == expected_labels, axis=1))\n",
        "\n",
        "        return accuracy\n",
        "\n",
        "    def _update_weights(self, output: np.ndarray, y_train: np.ndarray) -> None:\n",
        "        \"\"\"\n",
        "        Update the weights of the neural network based on the predicted output and the ground truth output.\n",
        "\n",
        "        Args:\n",
        "            output: numpy array, the predicted output from the neural network.\n",
        "            y_train: numpy array, the ground truth output.\n",
        "\n",
        "        \"\"\"\n",
        "        derivation_of_layer = self._loss.derivative(y_train, output)\n",
        "\n",
        "        for layer in reversed(self._layers_list):\n",
        "            derivation_of_layer = layer.update_weights(derivation_of_layer, self._lr)\n",
        "\n",
        "    def _validate_neurons_number(self, n_neurons):\n",
        "        \"\"\"\n",
        "        Check that the number of neurons is a positive integer.\n",
        "\n",
        "        Args:\n",
        "            n_neurons: int, the number of neurons.\n",
        "\n",
        "        Raises:\n",
        "            ValueError: if the number of neurons is not a positive integer.\n",
        "        \"\"\"\n",
        "        if not isinstance(n_neurons, int) or n_neurons <= 0:\n",
        "            raise ValueError(\"Invalid number of neurons for the layer!\")\n",
        "\n",
        "    def _validate_model_and_params(self):\n",
        "        \"\"\"\n",
        "        Check that the neural network is fully defined and the training parameters are set        properly.\n",
        "\n",
        "        Raises:\n",
        "            ValueError: if the neural network is not fully defined or the training parameters are not set.\n",
        "        \"\"\"\n",
        "        if not self._output_shape:\n",
        "            raise ValueError(\"Model is not compiled!\")\n",
        "        if not self._lr or not self._loss:\n",
        "            raise ValueError(\"Training parameters are not set!\")\n",
        "\n"
      ],
      "metadata": {
        "id": "kmkGeqBlFEfk",
        "is_executing": true
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Training the Network\n",
        "\n",
        "I define:\n",
        "\n",
        "- Data loaders for the training and test sets\n",
        "- A learning rate\n",
        "- Number of epochs\n",
        "- The network\n",
        "\n",
        "I add 3 hidden layers with 20 neurons each using ReLU activation and uniform weight initialization.\n",
        "\n",
        "The output layer has 10 neurons for the 10 digit classes and uses an Identity activation.\n",
        "\n",
        "I set the loss function to Cross Entropy and the learning rate.\n",
        "\n",
        "Then I call `fit()` to train the network:\n",
        "\n",
        "- `EPOCHS` - Number of epochs\n",
        "- `TRAINLOADER` - Training data loader\n",
        "- `TESTLOADER` - Test data loader (optional)\n",
        "- `log` - A list to append the result logs to\n",
        "\n",
        "The `fit()` method:\n",
        "\n",
        "- Trains on the training set by running `_train()`\n",
        "- Tests on the test set by running `_test()`\n",
        "- Logs the accuracy and loss after each epoch\n",
        "\n",
        "The result logs, containing the train/test accuracy and loss for each epoch, are returned and appended to `log`"
      ],
      "metadata": {
        "id": "456PsO73MGjx"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1:\n",
            "\tTrain: Average Accuracy: 0.2654666666666667\tAverage Loss: 1.9310712383269333\n",
            "\tTest: Average Accuracy: 0.4363019169329074\tAverage Loss:1.461730245506754\n",
            "Epoch 2:\n",
            "\tTrain: Average Accuracy: 0.5898166666666667\tAverage Loss: 1.0426716092694301\n",
            "\tTest: Average Accuracy: 0.6811102236421726\tAverage Loss:0.8221273884123391\n",
            "Epoch 3:\n",
            "\tTrain: Average Accuracy: 0.7135833333333333\tAverage Loss: 0.7690428457822807\n",
            "\tTest: Average Accuracy: 0.7727635782747604\tAverage Loss:0.6840878542636761\n",
            "Epoch 4:\n",
            "\tTrain: Average Accuracy: 0.7878166666666667\tAverage Loss: 0.6225597251079739\n",
            "\tTest: Average Accuracy: 0.7972244408945687\tAverage Loss:0.5845441234051227\n",
            "Epoch 5:\n",
            "\tTrain: Average Accuracy: 0.8105333333333333\tAverage Loss: 0.5480858699213816\n",
            "\tTest: Average Accuracy: 0.8191892971246006\tAverage Loss:0.5363351610326713\n",
            "Epoch 6:\n",
            "\tTrain: Average Accuracy: 0.8282\tAverage Loss: 0.4898860046318106\n",
            "\tTest: Average Accuracy: 0.8325678913738019\tAverage Loss:0.48157978434724097\n",
            "Epoch 7:\n",
            "\tTrain: Average Accuracy: 0.8412\tAverage Loss: 0.4470575460131965\n",
            "\tTest: Average Accuracy: 0.8287739616613419\tAverage Loss:0.5201462964089792\n",
            "Epoch 8:\n",
            "\tTrain: Average Accuracy: 0.84835\tAverage Loss: 0.4239119992072064\n",
            "\tTest: Average Accuracy: 0.8202875399361023\tAverage Loss:0.5257095533152228\n",
            "Epoch 9:\n",
            "\tTrain: Average Accuracy: 0.8552666666666666\tAverage Loss: 0.4032065125022309\n",
            "\tTest: Average Accuracy: 0.8436501597444089\tAverage Loss:0.44528304700576066\n",
            "Epoch 10:\n",
            "\tTrain: Average Accuracy: 0.8598333333333333\tAverage Loss: 0.38986987912644655\n",
            "\tTest: Average Accuracy: 0.8436501597444089\tAverage Loss:0.4421968545818861\n",
            "Epoch 11:\n",
            "\tTrain: Average Accuracy: 0.8628333333333333\tAverage Loss: 0.37951023464293304\n",
            "\tTest: Average Accuracy: 0.8443490415335463\tAverage Loss:0.42775998583007735\n",
            "Epoch 12:\n",
            "\tTrain: Average Accuracy: 0.8663333333333333\tAverage Loss: 0.36848191556013854\n",
            "\tTest: Average Accuracy: 0.8486421725239617\tAverage Loss:0.4351333953752392\n",
            "Epoch 13:\n",
            "\tTrain: Average Accuracy: 0.8699\tAverage Loss: 0.35972699504864225\n",
            "\tTest: Average Accuracy: 0.8544329073482428\tAverage Loss:0.4114523166899274\n",
            "Epoch 14:\n",
            "\tTrain: Average Accuracy: 0.8717666666666667\tAverage Loss: 0.3523697276914548\n",
            "\tTest: Average Accuracy: 0.8514376996805112\tAverage Loss:0.41674083941289575\n",
            "Epoch 15:\n",
            "\tTrain: Average Accuracy: 0.8745166666666667\tAverage Loss: 0.3458256677708078\n",
            "\tTest: Average Accuracy: 0.858326677316294\tAverage Loss:0.4041840330918221\n",
            "Epoch 16:\n",
            "\tTrain: Average Accuracy: 0.8772166666666666\tAverage Loss: 0.33972712588521586\n",
            "\tTest: Average Accuracy: 0.8625199680511182\tAverage Loss:0.39794155985466545\n",
            "Epoch 17:\n",
            "\tTrain: Average Accuracy: 0.8766166666666667\tAverage Loss: 0.3352602662508929\n",
            "\tTest: Average Accuracy: 0.8666134185303515\tAverage Loss:0.3845910482346355\n",
            "Epoch 18:\n",
            "\tTrain: Average Accuracy: 0.8799333333333333\tAverage Loss: 0.32907669309785725\n",
            "\tTest: Average Accuracy: 0.867611821086262\tAverage Loss:0.3825064928479545\n",
            "Epoch 19:\n",
            "\tTrain: Average Accuracy: 0.88145\tAverage Loss: 0.3248712895508043\n",
            "\tTest: Average Accuracy: 0.8666134185303515\tAverage Loss:0.3909359075219468\n",
            "Epoch 20:\n",
            "\tTrain: Average Accuracy: 0.8816\tAverage Loss: 0.32162698130644907\n",
            "\tTest: Average Accuracy: 0.8644169329073482\tAverage Loss:0.3882446875264936\n",
            "Epoch 21:\n",
            "\tTrain: Average Accuracy: 0.8844166666666666\tAverage Loss: 0.31629179052407197\n",
            "\tTest: Average Accuracy: 0.8600239616613419\tAverage Loss:0.38618585705453157\n",
            "Epoch 22:\n",
            "\tTrain: Average Accuracy: 0.8852833333333333\tAverage Loss: 0.31240490542267885\n",
            "\tTest: Average Accuracy: 0.862020766773163\tAverage Loss:0.3883253487255273\n",
            "Epoch 23:\n",
            "\tTrain: Average Accuracy: 0.88675\tAverage Loss: 0.3084785019625165\n",
            "\tTest: Average Accuracy: 0.8541333865814696\tAverage Loss:0.4108607829368253\n",
            "Epoch 24:\n",
            "\tTrain: Average Accuracy: 0.8884333333333333\tAverage Loss: 0.3051798429450629\n",
            "\tTest: Average Accuracy: 0.865814696485623\tAverage Loss:0.3805326954551931\n",
            "Epoch 25:\n",
            "\tTrain: Average Accuracy: 0.88855\tAverage Loss: 0.3033629562625426\n",
            "\tTest: Average Accuracy: 0.8656150159744409\tAverage Loss:0.3814341443752129\n"
          ]
        }
      ],
      "source": [
        "TRAIN_LOADER = DataLoader(train_images, train_labels, batch_size=32, shuffle=True)\n",
        "TEST_LOADER = DataLoader(test_images, test_labels, batch_size=32, shuffle=True)\n",
        "\n",
        "log = []\n",
        "LEARNING_RATE = 0.001\n",
        "EPOCHS = 25\n",
        "\n",
        "network = FeedForwardNN(train_images.shape[1] * train_images.shape[2])\n",
        "network.add_layer(20, activation=Relu(), weight_initializer='uniform')\n",
        "network.add_layer(20, activation=Relu(), weight_initializer='uniform')\n",
        "network.add_layer(20, activation=Relu(), weight_initializer='uniform')\n",
        "network.add_layer(10, activation=Identical(), weight_initializer='uniform')\n",
        "\n",
        "network.set_training_param(loss=CrossEntropy(), lr=LEARNING_RATE)\n",
        "\n",
        "log.append(network.fit(EPOCHS, TRAIN_LOADER, TEST_LOADER))"
      ],
      "metadata": {
        "id": "64NotgbdhEF4",
        "outputId": "847ebb66-c7e8-446b-c3f3-dbe0104c64dc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "check_log = log[0]\n",
        "\n",
        "fig, axs = plt.subplots(2, figsize=(8, 8))\n",
        "\n",
        "axs[0].plot(check_log['train_loss'], label='Train Loss')\n",
        "axs[0].plot(check_log['test_loss'], label='Test Loss')\n",
        "axs[0].set_title('Train and Test Loss')\n",
        "axs[0].set_xlabel('Epoch')\n",
        "axs[0].set_ylabel('Loss')\n",
        "axs[0].legend()\n",
        "\n",
        "axs[1].plot(check_log['train_accuracy'], label='Train Accuracy')\n",
        "axs[1].plot(check_log['test_accuracy'], label='Test Accuracy')\n",
        "axs[1].set_title('Train and Test Accuracy')\n",
        "axs[1].set_xlabel('Epoch')\n",
        "axs[1].set_ylabel('Accuracy')\n",
        "axs[1].legend()\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 807
        },
        "id": "QY9RT38QBMED",
        "outputId": "302f8060-a6cd-4419-d4f6-72a4ff14b2b0"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "8bLGTm0VM2ox"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}