ANN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "---\n",
    "\n",
    "# 0. Imports\n",
    "\n",
    "---\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\alireza\\anaconda3\\lib\\site-packages\\numpy\\_distributor_init.py:30: UserWarning: loaded more than 1 DLL from .libs:\n",
      "C:\\Users\\alireza\\anaconda3\\lib\\site-packages\\numpy\\.libs\\libopenblas64__v0.3.21-gcc_10_3_0.dll\n",
      "C:\\Users\\alireza\\anaconda3\\lib\\site-packages\\numpy\\.libs\\libopenblas64__v0.3.23-gcc_10_3_0.dll\n",
      "  warnings.warn(\"loaded more than 1 DLL from .libs:\"\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.datasets import make_classification\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.datasets import load_digits\n",
    "\n",
    "# import tqdm for progress bar\n",
    "from tqdm.auto import tqdm\n",
    "\n",
    "# import PyTorch related libraries\n",
    "import torch\n",
    "from torch import nn\n",
    "\n",
    "import torchvision \n",
    "from torchvision import datasets\n",
    "from torchvision import transforms\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "# import helper functions tools\n",
    "from helper_functions import load_cifar10\n",
    "from helper_functions import decision_surface\n",
    "from helper_functions import decision_surface_torch\n",
    "\n",
    "# general settings\n",
    "plt.style.use('ggplot')\n",
    "# device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "np.set_printoptions(precision=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "---\n",
    "\n",
    "\n",
    "# 1. Definitions\n",
    "\n",
    "\n",
    "---\n",
    "---\n",
    "\n",
    "The first section of the notebook contains the definitions of all tools used in the section two of the notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 implementing neural network architecture from scratch \n",
    "\n",
    "from now on, we are going to call all instances of `Dense_Layer` class as **independent models**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1.1 Base Layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The parent class of all Layers\n",
    "class Layer:\n",
    "    def __init__(self):\n",
    "        self.input = 0\n",
    "        self.output = 0\n",
    "    def forward(self):\n",
    "        pass\n",
    "    def backward(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1.2 Dense Layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Provides the ability to create a sequential network of arbitrary number of dense layers (fully connected).\n",
    "class Dense_Layer(Layer):\n",
    "    def __init__(self, input_size, output_size):\n",
    "        np.random.seed(10)\n",
    "        self.weights = np.random.randn(output_size, input_size) * 0.01\n",
    "        self.bias = np.random.randn(output_size, 1) * 0.01\n",
    "    \n",
    "    def forward(self, Xs):\n",
    "        self.input = Xs\n",
    "        self.output = np.dot(self.weights, self.input) + self.bias\n",
    "        return self.output\n",
    "    \n",
    "    def backward(self, chained_grad, learning_rate):\n",
    "        weights_grad = np.dot(chained_grad, self.input.T)\n",
    "        input_grads = np.dot(self.weights.T, chained_grad) \n",
    "\n",
    "        self.weights -= learning_rate * weights_grad / chained_grad.shape[1]\n",
    "        self.bias -= learning_rate * chained_grad.sum(axis=1, keepdims=True) / chained_grad.shape[1]\n",
    "\n",
    "        return input_grads"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1.3 Activation Layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Implementing Activation part as a seperate layer is more intuitive and simplifies the coding  \n",
    "class activation_layer(Layer):\n",
    "    def __init__(self, activation, activation_prime):\n",
    "        self.activation = activation\n",
    "        self.activation_prime = activation_prime\n",
    "    \n",
    "    def forward(self, Xs):\n",
    "        self.input = Xs\n",
    "        self.output = self.activation(self.input)\n",
    "        return self.output\n",
    "\n",
    "    def backward(self, chained_grad, learning_rate):\n",
    "        input_grad = self.activation_prime(self.input) * chained_grad\n",
    "        return input_grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Different Activation Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After implementing the framework of activation layer as the activation_layer class, we need to define certain activation functions, both for forward and backward.\n",
    "Here we implemented the four most famous activation functions:\n",
    "- Sigmoid\n",
    "- Tanh\n",
    "- ReLU\n",
    "- Leaky ReLU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# implement 'Sigmoid' activation function for both forward and backward path\n",
    "def sigmoid(x):\n",
    "    return 1 / (1 + np.exp(-x))\n",
    "\n",
    "def sigmoid_prime(x):\n",
    "    sig = (1 / (1 + np.exp(-x)))\n",
    "    return sig * (1 - sig)\n",
    "\n",
    "\n",
    "# implement 'Tanh' activation function for both forward and backward path\n",
    "def tanh(x):\n",
    "    return np.tanh(x)\n",
    "\n",
    "def tanh_prime(x):\n",
    "    return 1 - tanh(x)**2\n",
    "\n",
    "\n",
    "# implement 'ReLU' activation function for both forward and backward path\n",
    "def relu(x):\n",
    "    return np.maximum(0, x)\n",
    "\n",
    "def relu_prime(x):\n",
    "    grads = np.zeros_like(x)\n",
    "    grads[x > 0] = 1 \n",
    "    return grads\n",
    "\n",
    "\n",
    "# implement 'Leaky ReLU' activation function for both forward and backward path\n",
    "def leaky_relu(x):\n",
    "    return np.maximum(0.1*x, x)\n",
    "\n",
    "def leaky_relu_prime(x):\n",
    "    grads = np.full(x.shape, 0.1)\n",
    "    grads[x > 0.1 * x] = 1\n",
    "    return grads\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Different Loss Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the elementary parts of each learning procedure is the **Loss function / Cost function**, there are many different \n",
    "cost functions for different purposes, here we are implementing three different loss functions. \n",
    "- Mean Squared Error (MSE)\n",
    "- Cross Entropy\n",
    "- Multiclass Hinge loss\n",
    "\n",
    "As the loss function is the final computation applied on the network's input, the backpropagation strarts on it, so we need\n",
    "to implement both the forward path, and the backward path for each loss function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# different loss functions\n",
    "\n",
    "# Mean Squared Error \n",
    "def mse(y_true, y_pred):\n",
    "    return np.mean( (y_true - y_pred)**2 )\n",
    "\n",
    "def mse_prime(y_true, y_pred):\n",
    "    grads = 2 * (y_pred - y_true) / np.size(y_true)\n",
    "    return np.array(grads)\n",
    "\n",
    "\n",
    "\n",
    "# Cross Entropy vectorized implementation for both forward and backward pass\n",
    "def cross_entropy(y_true, x):\n",
    "    loss_of_samples = -np.log(np.exp(x[y_true, range(x.shape[1])]) / np.exp(x).sum(axis=0))\n",
    "    return loss_of_samples.sum()\n",
    "\n",
    "def cross_entropy_prime(y_true, x):\n",
    "    exponents = np.exp(x)\n",
    "    denoms = exponents.sum(axis=0)                                             \n",
    "    grads =  exponents / denoms\n",
    "    grads[y_true, range(x.shape[1])] -= 1    \n",
    "    return grads\n",
    "\n",
    "\n",
    "\n",
    "# Multiclass hinge vectorized implementation for both forward and backward pass\n",
    "def multi_class_hinge(y_true, x, delta=1):\n",
    "    losses = np.maximum(0, x - x[y_true, range(x.shape[1])] + delta)\n",
    "    losses[y_true, range(losses.shape[1])] = 0\n",
    "\n",
    "    return losses.sum() / y_true.size \n",
    "\n",
    "def multi_class_hinge_prime(y_true, x, delta=1):\n",
    "    grads = ((x - x[y_true, range(x.shape[1])]) > 0)\n",
    "    grads = grads.astype(int)\n",
    "    grads[y_true, range(grads.shape[1])] = 0                    \n",
    "    grads[y_true, range(grads.shape[1])] = -grads.sum(axis=0)                 # count the all miss-classified classes \n",
    "\n",
    "    return grads / y_true.size "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 L2 Regularization "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to prevent our model to overfit, we implement the **L2 regularization** to penalize large values for weights, which is the main cause of overfit. Ofcourse each computation in forward pass will encounter in backward pass, in other words, we need to implement the backward pass as well as forward pass for our regularization term."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a function to add regularization to the loss function\n",
    "\n",
    "def apply_L2_regularization(weights_list, loss, reg):\n",
    "    squared_sum_of_weights = 0\n",
    "    for i in weights_list:\n",
    "        squared_sum_of_weights += np.sum(i * i)\n",
    "    return loss + reg * squared_sum_of_weights\n",
    "\n",
    "def apply_L2_regularization_prime(weights_list, grad, reg):\n",
    "    grad_of_sum_of_weights = 0\n",
    "    for i in weights_list:\n",
    "        grad_of_sum_of_weights += np.sum(i)\n",
    "    return grad + 2 * reg * grad_of_sum_of_weights\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5 Prediction and Accuracy function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5.1 Predict function  (from-scratch version neural network)\n",
    "\n",
    "Define a function to convert raw output scores of the network/model to class labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(X, network):\n",
    "    output = X.T\n",
    "    for layer in network:\n",
    "        output = layer.forward(output)\n",
    "    return output.argmax(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5.2 accuracy function (PyTorch models)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculates accuracy between truth labels and predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accuracy_fn(y_true, y_pred):\n",
    "    correct = torch.eq(y_true, y_pred).sum().item()\n",
    "    acc = (correct / len(y_pred)) * 100\n",
    "    return acc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.6 Train functions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.6.1 Training function that uses gradient descent to train independent model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to train our independent version neural networks, we're going to  functionize the learning process using `train` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(X_train, Y_train, X_test, Y_test, network, loss_function, loss_function_prime, learning_rate, reg_func, reg_func_prime, reg_rate, epochs=100, sgd=False, batch_size=256, verbose=25, **kwargs):\n",
    "    \"\"\"Performs the whole training and evaluating procedure for a model on a certain dataset.\"\"\"\n",
    "    losses = []\n",
    "    for epoch in range(epochs):\n",
    "        weights = []\n",
    "\n",
    "        # if sgd==True, use stochastic gradient descent optimization method, otherwise use gradient descent/full gradient descent.\n",
    "        if sgd:\n",
    "            indices = np.random.choice(np.arange(0, len(X_train)), batch_size, replace=False)\n",
    "            X_train_batch = X_train[indices]\n",
    "            y_train_batch = Y_train[indices]\n",
    "        else:\n",
    "            X_train_batch = X_train\n",
    "            y_train_batch = Y_train\n",
    "        \n",
    "\n",
    "        output = X_train_batch.T\n",
    "        \n",
    "        # foward pass\n",
    "        for layer in network:\n",
    "            output = layer.forward(output)\n",
    "            try:\n",
    "                weights.append(layer.weights)\n",
    "            except:\n",
    "                pass\n",
    "\n",
    "        # calculate the loss\n",
    "        loss_without_reg = loss_function(y_train_batch, output)\n",
    "        losses.append(reg_func(weights, loss_without_reg, reg_rate))\n",
    "\n",
    "        # start the backpropagation pass\n",
    "        grad = loss_function_prime(y_train_batch, output)\n",
    "        grad = reg_func_prime(weights, grad, reg_rate)\n",
    "\n",
    "        for layer in reversed(network):\n",
    "            grad = layer.backward(grad, learning_rate)\n",
    "\n",
    "        if verbose and (epoch % verbose == 0):\n",
    "\n",
    "            train_predicts = predict(X_train_batch, network)\n",
    "            test_predicts = predict(X_test, network)\n",
    "\n",
    "            accuracy_on_train = np.mean(train_predicts == y_train_batch)\n",
    "            accuracy_on_test = np.mean(test_predicts == Y_test)\n",
    "\n",
    "            sum_of_weights = 0\n",
    "            for i in weights:\n",
    "                sum_of_weights += np.sum(i)\n",
    "\n",
    "            print(f'epoch {epoch:4}/{epochs} | accuracy on train: {accuracy_on_train:.3f} | accuracy on test: {accuracy_on_test:.3f} | loss: {losses[-1]:.3f} | sum of weights: {sum_of_weights:.4f}')\n",
    "    print(f'epoch {epoch:4}/{epochs} | accuracy on train: {accuracy_on_train:.3f} | accuracy on test: {accuracy_on_test:.3f} | loss: {losses[-1]:.3f} | sum of weights: {sum_of_weights:.4f}')\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.6.2 Perform one training epoch on model (PyTorch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_step(model: torch.nn.Module, \n",
    "               data_loader: torch.utils.data.DataLoader, \n",
    "               loss_fn: torch.nn.Module,\n",
    "               optimizer: torch.optim.Optimizer,\n",
    "               accuracy_fn,\n",
    "               device: torch.device = device):\n",
    "    \"\"\"Performs a training step/epoch with model trying to learn on data_loader.\"\"\"\n",
    "\n",
    "    train_loss, train_acc = 0, 0\n",
    "\n",
    "\n",
    "    # put model into training mode \n",
    "    model.train()\n",
    "\n",
    "\n",
    "    # add a loop to loop through the training batches\n",
    "    for batch, (X, y) in enumerate(data_loader):\n",
    "\n",
    "        # put data on target device\n",
    "        X, y = X.to(device), y.to(device)\n",
    "\n",
    "        # 1. forward pass (outputs the raw logits from the model)\n",
    "        y_pred = model(X)\n",
    "\n",
    "        # 2. calcualate loss and accuracy (per batch)\n",
    "        loss = loss_fn(y_pred, y)\n",
    "        train_loss += loss    # accumlate train loss \n",
    "        acc = accuracy_fn(y_true=y, y_pred=y_pred.argmax(dim=1)) # go from logits -> prediction labels\n",
    "        train_acc += acc\n",
    "        \n",
    "        # 3. optimizer zero grad\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # 4. loss backward\n",
    "        loss.backward()\n",
    "\n",
    "        # 5. optimizer step\n",
    "        optimizer.step()\n",
    "        \n",
    "        if batch % 25 == 0:\n",
    "            print(f\"batch (128 samples): {batch:4}/{len(data_loader)} | Train loss: {loss:.5f} | Train accuracy: {acc:.2f}%\")    \n",
    "        \n",
    "    # divide total train loss and accuracy by length of train dataloader \n",
    "    train_loss /= len(data_loader)\n",
    "    train_acc /= len(data_loader)\n",
    "\n",
    "    print(f\"End of an epoch --> Train loss: {train_loss:.5f} | Train accuracy: {train_acc:.2f}%\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.6.3 Perform one testing step on whole test dataset (PyTorch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_step(model: torch.nn.Module,\n",
    "              data_loader: torch.utils.data.DataLoader,\n",
    "              loss_fn: torch.nn.Module,\n",
    "              accuracy_fn,\n",
    "              device: torch.device = device):\n",
    "    \"\"\"Perfoms a testing loop step on model going over data_loader.\"\"\"\n",
    "    test_loss, test_acc = 0, 0\n",
    "\n",
    "    \n",
    "    # put the model in eval mode\n",
    "    model.eval()\n",
    "    \n",
    "    # turn on indference mode context manager\n",
    "    with torch.inference_mode():\n",
    "        for batch, (X, y) in enumerate(data_loader):\n",
    "            # send data to the target device\n",
    "            X, y = X.to(device), y.to(device)\n",
    "            \n",
    "            # 1. forward pass (outputs raw logits)\n",
    "            test_pred = model(X)\n",
    "            \n",
    "            # 2. calculate the loss and accuracy\n",
    "            loss = loss_fn(test_pred, y)\n",
    "            test_loss += loss\n",
    "            acc = accuracy_fn(y_true=y, \n",
    "                                    y_pred=test_pred.argmax(dim=1)) # logits -> prediction labels\n",
    "            test_acc += acc\n",
    "                     \n",
    "        # # divide total train loss and accuracy by length of test dataloader \n",
    "        test_loss /= len(data_loader)\n",
    "        test_acc /= len(data_loader)\n",
    "        \n",
    "        print(f\"-------\\nTest loss: {test_loss:.5f} | Test accuracy: {test_acc:.2f}%\\n-------\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "---\n",
    "\n",
    "\n",
    "# 2. Implementations\n",
    "\n",
    "\n",
    "---\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Artificial Data classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.1 Creating data used for train and test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "using the scikit-learn to create an artifical dataset with two features and 250 samples in three classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'feature 2')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "N_classes = 3\n",
    "\n",
    "data = make_classification(n_samples=250, n_features=2, n_classes=N_classes, n_redundant=0, n_informative=2, \n",
    "                           hypercube=True, n_clusters_per_class=1, class_sep=1.6, random_state=5)\n",
    "\n",
    "Xs = data[0]\n",
    "ys = data[1]\n",
    "\n",
    "for i in range(N_classes):\n",
    "    class_i = Xs[ys == i]\n",
    "    plt.scatter(class_i[:, 0], class_i[:, 1], label=f'class {i}')\n",
    "\n",
    "plt.title('Dataset with circled test datapoints\\n')\n",
    "plt.legend()\n",
    "plt.xlabel('feature 1')\n",
    "plt.ylabel('feature 2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.2 Independent neural network for artificial dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.2.1 Defining the network architecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a network with two hidden layers and Tanh activation function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "network = [\n",
    "    Dense_Layer(2, 10),\n",
    "    activation_layer(tanh, tanh_prime),\n",
    "    Dense_Layer(10, 10),\n",
    "    activation_layer(tanh, tanh_prime),\n",
    "    Dense_Layer(10, 3),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.2.2 Train the defiend network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train the defined model on created dataset and evaluate the accuracy on both train and test sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    0/400 | accuracy on train: 0.350 | accuracy on test: 0.280 | loss: 219.653 | sum of weights: 0.1654\n",
      "epoch   25/400 | accuracy on train: 0.920 | accuracy on test: 0.940 | loss: 95.630 | sum of weights: -2.6612\n",
      "epoch   50/400 | accuracy on train: 0.970 | accuracy on test: 1.000 | loss: 34.248 | sum of weights: -1.6901\n",
      "epoch   75/400 | accuracy on train: 0.980 | accuracy on test: 1.000 | loss: 22.817 | sum of weights: -2.4850\n",
      "epoch  100/400 | accuracy on train: 0.990 | accuracy on test: 1.000 | loss: 14.371 | sum of weights: -3.9577\n",
      "epoch  125/400 | accuracy on train: 0.990 | accuracy on test: 1.000 | loss: 12.114 | sum of weights: -4.4335\n",
      "epoch  150/400 | accuracy on train: 0.990 | accuracy on test: 1.000 | loss: 11.417 | sum of weights: -4.6470\n",
      "epoch  175/400 | accuracy on train: 0.990 | accuracy on test: 1.000 | loss: 11.120 | sum of weights: -4.8131\n",
      "epoch  200/400 | accuracy on train: 0.990 | accuracy on test: 1.000 | loss: 10.946 | sum of weights: -4.9600\n",
      "epoch  225/400 | accuracy on train: 0.990 | accuracy on test: 1.000 | loss: 10.827 | sum of weights: -5.0967\n",
      "epoch  250/400 | accuracy on train: 0.990 | accuracy on test: 1.000 | loss: 10.735 | sum of weights: -5.2303\n",
      "epoch  275/400 | accuracy on train: 0.990 | accuracy on test: 1.000 | loss: 10.652 | sum of weights: -5.3698\n",
      "epoch  300/400 | accuracy on train: 0.990 | accuracy on test: 1.000 | loss: 10.536 | sum of weights: -5.5370\n",
      "epoch  325/400 | accuracy on train: 0.990 | accuracy on test: 1.000 | loss: 10.092 | sum of weights: -5.8401\n",
      "epoch  350/400 | accuracy on train: 0.990 | accuracy on test: 1.000 | loss: 9.753 | sum of weights: -6.2006\n",
      "epoch  375/400 | accuracy on train: 0.990 | accuracy on test: 1.000 | loss: 9.630 | sum of weights: -6.4656\n",
      "epoch  399/400 | accuracy on train: 0.990 | accuracy on test: 1.000 | loss: 9.559 | sum of weights: -6.4656\n"
     ]
    }
   ],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(Xs, ys, test_size=0.2, random_state=3)\n",
    "\n",
    "train(X_train, \n",
    "      y_train, \n",
    "      X_test, \n",
    "      y_test, \n",
    "      network, \n",
    "      cross_entropy, \n",
    "      cross_entropy_prime, \n",
    "      learning_rate=3, \n",
    "      reg_func=apply_L2_regularization, \n",
    "      reg_func_prime=apply_L2_regularization_prime,\n",
    "      reg_rate=0, \n",
    "      epochs=400,\n",
    "      verbose=25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.2.3 Plot decision boundaries for trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "output = X_train.T\n",
    "for layer in network:\n",
    "    output = layer.forward(output)\n",
    "\n",
    "    \n",
    "train_predicts = predict(X_train, network)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "decision_surface(network, predict, plt, Xs, ys, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.3 PyTorch for artificial dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.3.1 Defining the network architecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a network with same architecture as above network, but using PyTorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ArtificialData(nn.Module):\n",
    "    def __init__(self, input_shape: int, hidden_units: int, output_shape: int):\n",
    "        super().__init__()\n",
    "        self.layer_stack = nn.Sequential(\n",
    "            nn.Linear(in_features=input_shape, out_features=hidden_units),\n",
    "            nn.Tanh(),\n",
    "            nn.Linear(in_features=hidden_units, out_features=hidden_units),\n",
    "            nn.Tanh(),\n",
    "            nn.Linear(in_features=hidden_units, out_features=output_shape)\n",
    "        )\n",
    "\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.layer_stack(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the same architecture and optimization technique as above experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ArtificialData(\n",
       "  (layer_stack): Sequential(\n",
       "    (0): Linear(in_features=2, out_features=10, bias=True)\n",
       "    (1): Tanh()\n",
       "    (2): Linear(in_features=10, out_features=10, bias=True)\n",
       "    (3): Tanh()\n",
       "    (4): Linear(in_features=10, out_features=3, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf_model = ArtificialData(2, 10, 3)\n",
    "\n",
    "loss_fn = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(params=clf_model.parameters(), lr=3)\n",
    "\n",
    "clf_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.3.2 Train and evaluatethe defined model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   0/400 | Train loss: 1.1690 | Train accuracy: 0.09%\n",
      "   0/400 | Test loss: 0.8991  | Test accuracy: 0.62%\n",
      "\n",
      "  50/400 | Train loss: 0.0515 | Train accuracy: 0.99%\n",
      "  50/400 | Test loss: 0.0214  | Test accuracy: 1.00%\n",
      "\n",
      " 100/400 | Train loss: 0.0413 | Train accuracy: 0.99%\n",
      " 100/400 | Test loss: 0.0170  | Test accuracy: 1.00%\n",
      "\n",
      " 150/400 | Train loss: 0.0384 | Train accuracy: 0.99%\n",
      " 150/400 | Test loss: 0.0150  | Test accuracy: 1.00%\n",
      "\n",
      " 200/400 | Train loss: 0.0364 | Train accuracy: 0.99%\n",
      " 200/400 | Test loss: 0.0106  | Test accuracy: 1.00%\n",
      "\n",
      " 250/400 | Train loss: 0.0326 | Train accuracy: 0.99%\n",
      " 250/400 | Test loss: 0.0101  | Test accuracy: 1.00%\n",
      "\n",
      " 300/400 | Train loss: 0.0295 | Train accuracy: 0.99%\n",
      " 300/400 | Test loss: 0.0115  | Test accuracy: 1.00%\n",
      "\n",
      " 350/400 | Train loss: 0.0275 | Train accuracy: 0.99%\n",
      " 350/400 | Test loss: 0.0109  | Test accuracy: 1.00%\n",
      "\n"
     ]
    }
   ],
   "source": [
    "epochs = 400\n",
    "\n",
    "train_loss, train_acc = [], []\n",
    "test_loss, test_acc = [], []\n",
    "\n",
    "X_train_t, X_test_t, y_train_t, y_test_t = torch.tensor(X_train).type(torch.float), torch.tensor(X_test).type(torch.float), torch.tensor(y_train).type(torch.LongTensor), torch.tensor(y_test).type(torch.LongTensor) \n",
    "\n",
    "# add a loop to loop through the training batches\n",
    "for epoch in range(epochs):\n",
    "    # put model into training mode \n",
    "    clf_model.train()\n",
    "\n",
    "    # 1. forward pass (outputs the raw logits from the model)\n",
    "    train_scores = clf_model(X_train_t)\n",
    "    train_preds = train_scores.detach().numpy().argmax(axis=1) # go from logits -> prediction labels\n",
    "    \n",
    "    # 2. calcualate loss and accuracy (per batch)\n",
    "    loss = loss_fn(train_scores, y_train_t)\n",
    "    train_loss.append(loss)    # accumlate train loss \n",
    "    acc = np.mean(y_train == train_preds)\n",
    "    train_acc.append(acc)\n",
    "\n",
    "    # 3. optimizer zero grad\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    # 4. loss backward\n",
    "    loss.backward()\n",
    "\n",
    "    # 5. optimizer step\n",
    "    optimizer.step()\n",
    "\n",
    "    if epoch % 50 == 0:\n",
    "        \n",
    "        print(f\"{epoch:4}/{epochs} | Train loss: {loss:.4f} | Train accuracy: {acc:.2f}%\")  \n",
    "          \n",
    "        # put the model in eval mode\n",
    "        clf_model.eval()\n",
    "\n",
    "        # turn on indference mode context manager\n",
    "        with torch.inference_mode():\n",
    "            # 1. forward pass (outputs raw logits)\n",
    "            test_scores = clf_model(X_test_t)\n",
    "            test_preds = test_scores.numpy().argmax(axis=1) # go from logits -> prediction labels\n",
    "            \n",
    "\n",
    "            # 2. calculate the loss and accuracy\n",
    "            loss = loss_fn(test_scores, y_test_t)\n",
    "            test_loss.append(loss)\n",
    "\n",
    "            acc = np.mean(y_test == test_preds)\n",
    "            test_acc.append(acc)\n",
    "\n",
    "            print(f\"{epoch:4}/{epochs} | Test loss: {loss:.4f}  | Test accuracy: {acc:.2f}%\\n\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.3.3 Plot decision boundaries for trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "decision_surface_torch(clf_model, plt, Xs, ys, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Models on MNIST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.1 Loading MNIST dataset using PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this experiment we use PyTorch to load MNIST dataset for both independent and PyTorch classifiers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setup training and testing data\n",
    "DATA_PATH = 'D:\\PyTorch_datasets'\n",
    "\n",
    "mnist_train_data = datasets.MNIST(\n",
    "    root=DATA_PATH,\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor(),    # how do we want to transform the data\n",
    "    target_transform=None    # how do we want to transform the labels/targets\n",
    ")\n",
    "\n",
    "mnist_test_data = datasets.MNIST(\n",
    "    root=DATA_PATH,\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor(),\n",
    "    target_transform=None\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([60000, 28, 28]), torch.Size([60000]))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnist_train_data.data.shape, mnist_train_data.targets.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.2 Independent neural network on MNIST dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2.2.1 make the data ready for Independent model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data now we have is in tensor form, we want the data in the form of numpy arrays for our independent model, so the next\n",
    "cell is dedicated to transform the data type, as well as its shape, to flatten the 28 * 28 MNIST images. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((60000, 784), (60000,), (10000, 784), (10000,))"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# transform data type and shape for training data\n",
    "X_train_mn = mnist_train_data.data.numpy().reshape(mnist_train_data.data.shape[0], mnist_train_data.data.shape[1] * mnist_train_data.data.shape[2])\n",
    "y_train_mn = mnist_train_data.targets.numpy()\n",
    "\n",
    "# transform data type and shape for testing data\n",
    "X_test_mn = mnist_test_data.data.numpy().reshape(mnist_test_data.data.shape[0], mnist_test_data.data.shape[1] * mnist_test_data.data.shape[2])\n",
    "y_test_mn = mnist_test_data.targets.numpy()\n",
    "\n",
    "X_train_mn.shape, y_train_mn.shape, X_test_mn.shape, y_test_mn.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2.2.2 Define the architecture for network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a network architecture with three hidden layers and **Leaky ReLU** activation function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "mnist_network = [\n",
    "    Dense_Layer(784, 100),\n",
    "    activation_layer(leaky_relu, leaky_relu_prime),\n",
    "    Dense_Layer(100, 100),\n",
    "    activation_layer(leaky_relu, leaky_relu_prime),\n",
    "    Dense_Layer(100, 100),\n",
    "    activation_layer(leaky_relu, leaky_relu_prime),\n",
    "    Dense_Layer(100, 10)   \n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2.2.3 Train the defined network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train and evaluate the defined independent model on the MNIST dataset. In this experiment we are using stochastic gradient descent (also known as batch gradient descent), with a batch-size of 1024."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    0/2000 | accuracy on train: 0.845 | accuracy on test: 0.834 | loss: 8.484 | sum of weights: -8.9254\n",
      "epoch  100/2000 | accuracy on train: 0.846 | accuracy on test: 0.837 | loss: 8.509 | sum of weights: -9.2042\n",
      "epoch  200/2000 | accuracy on train: 0.817 | accuracy on test: 0.842 | loss: 8.550 | sum of weights: -9.4245\n",
      "epoch  300/2000 | accuracy on train: 0.851 | accuracy on test: 0.843 | loss: 8.559 | sum of weights: -9.6560\n",
      "epoch  400/2000 | accuracy on train: 0.849 | accuracy on test: 0.847 | loss: 8.577 | sum of weights: -9.8555\n",
      "epoch  500/2000 | accuracy on train: 0.857 | accuracy on test: 0.851 | loss: 8.594 | sum of weights: -10.0348\n",
      "epoch  600/2000 | accuracy on train: 0.849 | accuracy on test: 0.851 | loss: 8.616 | sum of weights: -10.2073\n",
      "epoch  700/2000 | accuracy on train: 0.858 | accuracy on test: 0.856 | loss: 8.629 | sum of weights: -10.3313\n",
      "epoch  800/2000 | accuracy on train: 0.864 | accuracy on test: 0.857 | loss: 8.639 | sum of weights: -10.4446\n",
      "epoch  900/2000 | accuracy on train: 0.871 | accuracy on test: 0.855 | loss: 8.650 | sum of weights: -10.5827\n",
      "epoch 1000/2000 | accuracy on train: 0.856 | accuracy on test: 0.860 | loss: 8.661 | sum of weights: -10.6747\n",
      "epoch 1100/2000 | accuracy on train: 0.897 | accuracy on test: 0.862 | loss: 8.661 | sum of weights: -10.7801\n",
      "epoch 1200/2000 | accuracy on train: 0.868 | accuracy on test: 0.863 | loss: 8.680 | sum of weights: -10.8710\n",
      "epoch 1300/2000 | accuracy on train: 0.867 | accuracy on test: 0.867 | loss: 8.693 | sum of weights: -10.9718\n",
      "epoch 1400/2000 | accuracy on train: 0.881 | accuracy on test: 0.867 | loss: 8.703 | sum of weights: -11.0566\n",
      "epoch 1500/2000 | accuracy on train: 0.860 | accuracy on test: 0.865 | loss: 8.704 | sum of weights: -11.1478\n",
      "epoch 1600/2000 | accuracy on train: 0.878 | accuracy on test: 0.868 | loss: 8.716 | sum of weights: -11.2294\n",
      "epoch 1700/2000 | accuracy on train: 0.870 | accuracy on test: 0.867 | loss: 8.721 | sum of weights: -11.3068\n",
      "epoch 1800/2000 | accuracy on train: 0.871 | accuracy on test: 0.869 | loss: 8.726 | sum of weights: -11.3662\n",
      "epoch 1900/2000 | accuracy on train: 0.890 | accuracy on test: 0.867 | loss: 8.737 | sum of weights: -11.4375\n",
      "epoch 1999/2000 | accuracy on train: 0.890 | accuracy on test: 0.867 | loss: 8.737 | sum of weights: -11.4375\n"
     ]
    }
   ],
   "source": [
    "train(X_train_mn, \n",
    "      y_train_mn, \n",
    "      X_test_mn, \n",
    "      y_test_mn, \n",
    "      mnist_network, \n",
    "      multi_class_hinge, \n",
    "      multi_class_hinge_prime, \n",
    "      learning_rate=2, \n",
    "      reg_func=apply_L2_regularization, \n",
    "      reg_func_prime=apply_L2_regularization_prime, \n",
    "      reg_rate=0.0, \n",
    "      epochs=2000,\n",
    "      sgd=True,\n",
    "      batch_size=1024,\n",
    "      verbose=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After training the model, predict the label for 16 random samples from test set and plot the output. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x900 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "torch.manual_seed(42)\n",
    "\n",
    "number_of_images = 16\n",
    "ncols = 4\n",
    "nrows = 4\n",
    "\n",
    "# pick some random images from the train set\n",
    "random_idx = torch.randint(low=0, high=len(mnist_test_data), size=(number_of_images,))#.item()\n",
    "images = mnist_test_data.data[random_idx].type(torch.float32).numpy().reshape(16, -1)\n",
    "labels = mnist_test_data.targets[random_idx].numpy()\n",
    "\n",
    "scores = images.T\n",
    "for layer in mnist_network:\n",
    "    scores = layer.forward(scores)\n",
    "    \n",
    "\n",
    "preds = predict(images, mnist_network)\n",
    "\n",
    "\n",
    "# plot the images and the predicted label for each one alongside it's real label\n",
    "plt.figure(figsize=(9, 9))\n",
    "for i, img in enumerate(images):\n",
    "    plt.subplot(nrows, ncols, i+1)\n",
    "    plt.imshow(img.reshape(28, 28), cmap='gray')#.permute(2, 1, 0))\n",
    "    \n",
    "    if labels[i] == preds[i]:\n",
    "        plt.title(f'true: {mnist_test_data.classes[labels[i]]}, predicted: {mnist_test_data.classes[preds[i]]}', fontsize=9, c='g')\n",
    "    else:\n",
    "        plt.title(f'true: {mnist_test_data.classes[labels[i]]}, predicted: {mnist_test_data.classes[preds[i]]}', fontsize=9, c='r')\n",
    "    plt.grid('off')\n",
    "    plt.axis('off')\n",
    "\n",
    "plt.tight_layout()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.3 PyTorch on MNIST implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2.3.1 Make the data ready for PyTorch model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To perform stochastic gradient descent as optimization technique in PyTorch model, we need to turn our train and test datasets into dataloaders. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<torch.utils.data.dataloader.DataLoader at 0x240a86a39d0>,\n",
       " <torch.utils.data.dataloader.DataLoader at 0x240a86a3910>)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Turn train and test datasets into DataLoader's\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "# The chosen batch size for this experiment is 1024 samples\n",
    "BATCH_SIZE = 1024\n",
    "mnist_train_dataloader = DataLoader(dataset=mnist_train_data, batch_size=BATCH_SIZE, num_workers=1, shuffle=True)\n",
    "mnist_test_dataloader = DataLoader(dataset=mnist_test_data, batch_size=BATCH_SIZE, num_workers=1, shuffle=False)\n",
    "\n",
    "mnist_train_dataloader, mnist_test_dataloader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2.3.2 Define and the network architecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a network with same architecture as above network, but using PyTorch. We're using a flatten layer as first layer, which provides us ability to input data with it's original shape, needless to reshape it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class MNISTClassifier(nn.Module):\n",
    "    def __init__(self, input_shape, hidden_units, output_shape):\n",
    "        super().__init__()\n",
    "        self.layer_stack = nn.Sequential(\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(in_features=input_shape, out_features=hidden_units),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.Linear(in_features=hidden_units, out_features=hidden_units),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.Linear(in_features=hidden_units, out_features=output_shape)\n",
    "        )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.layer_stack(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the same loss function and optimization technique as above experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MNISTClassifier(\n",
       "  (layer_stack): Sequential(\n",
       "    (0): Flatten(start_dim=1, end_dim=-1)\n",
       "    (1): Linear(in_features=784, out_features=100, bias=True)\n",
       "    (2): LeakyReLU(negative_slope=0.01)\n",
       "    (3): Linear(in_features=100, out_features=100, bias=True)\n",
       "    (4): LeakyReLU(negative_slope=0.01)\n",
       "    (5): Linear(in_features=100, out_features=10, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnist_model = MNISTClassifier(input_shape=784, hidden_units=100, output_shape=10)\n",
    "\n",
    "loss_fn = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(params=mnist_model.parameters(), lr=0.1)\n",
    "\n",
    "mnist_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2.3.3 Train and evaluate the defined network\n",
    "\n",
    "Train and evaluate the created model usnig PyTroch on train and test sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "73e7b97006ea4a0f86cc3150f8c105e2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0\n",
      "-------\n",
      "batch (128 samples):    0/59 | Train loss: 2.30614 | Train accuracy: 9.38%\n",
      "batch (128 samples):   25/59 | Train loss: 2.19803 | Train accuracy: 53.42%\n",
      "batch (128 samples):   50/59 | Train loss: 1.79402 | Train accuracy: 62.01%\n",
      "End of an epoch --> Train loss: 2.08073 | Train accuracy: 45.26%\n",
      "\n",
      "-------\n",
      "Test loss: 1.49226 | Test accuracy: 68.05%\n",
      "-------\n",
      "\n",
      "Epoch: 1\n",
      "-------\n",
      "batch (128 samples):    0/59 | Train loss: 1.53625 | Train accuracy: 65.82%\n",
      "batch (128 samples):   25/59 | Train loss: 0.89052 | Train accuracy: 77.25%\n",
      "batch (128 samples):   50/59 | Train loss: 0.66820 | Train accuracy: 81.64%\n",
      "End of an epoch --> Train loss: 0.92545 | Train accuracy: 77.10%\n",
      "\n",
      "-------\n",
      "Test loss: 0.60398 | Test accuracy: 83.37%\n",
      "-------\n",
      "\n",
      "Epoch: 2\n",
      "-------\n",
      "batch (128 samples):    0/59 | Train loss: 0.63997 | Train accuracy: 81.45%\n",
      "batch (128 samples):   25/59 | Train loss: 0.56454 | Train accuracy: 85.74%\n",
      "batch (128 samples):   50/59 | Train loss: 0.46883 | Train accuracy: 88.38%\n",
      "End of an epoch --> Train loss: 0.52910 | Train accuracy: 85.44%\n",
      "\n",
      "-------\n",
      "Test loss: 0.45132 | Test accuracy: 86.93%\n",
      "-------\n",
      "\n",
      "Epoch: 3\n",
      "-------\n",
      "batch (128 samples):    0/59 | Train loss: 0.46447 | Train accuracy: 87.40%\n",
      "batch (128 samples):   25/59 | Train loss: 0.41735 | Train accuracy: 88.57%\n",
      "batch (128 samples):   50/59 | Train loss: 0.38528 | Train accuracy: 89.75%\n",
      "End of an epoch --> Train loss: 0.43013 | Train accuracy: 88.01%\n",
      "\n",
      "-------\n",
      "Test loss: 0.38410 | Test accuracy: 89.07%\n",
      "-------\n",
      "\n",
      "Epoch: 4\n",
      "-------\n",
      "batch (128 samples):    0/59 | Train loss: 0.41563 | Train accuracy: 87.70%\n",
      "batch (128 samples):   25/59 | Train loss: 0.36536 | Train accuracy: 88.48%\n",
      "batch (128 samples):   50/59 | Train loss: 0.32960 | Train accuracy: 90.82%\n",
      "End of an epoch --> Train loss: 0.38297 | Train accuracy: 89.20%\n",
      "\n",
      "-------\n",
      "Test loss: 0.34963 | Test accuracy: 89.81%\n",
      "-------\n",
      "\n",
      "Epoch: 5\n",
      "-------\n",
      "batch (128 samples):    0/59 | Train loss: 0.34960 | Train accuracy: 90.82%\n",
      "batch (128 samples):   25/59 | Train loss: 0.37429 | Train accuracy: 89.06%\n",
      "batch (128 samples):   50/59 | Train loss: 0.30469 | Train accuracy: 92.09%\n",
      "End of an epoch --> Train loss: 0.35285 | Train accuracy: 90.03%\n",
      "\n",
      "-------\n",
      "Test loss: 0.32763 | Test accuracy: 90.48%\n",
      "-------\n",
      "\n",
      "Epoch: 6\n",
      "-------\n",
      "batch (128 samples):    0/59 | Train loss: 0.36685 | Train accuracy: 89.65%\n",
      "batch (128 samples):   25/59 | Train loss: 0.30521 | Train accuracy: 90.72%\n",
      "batch (128 samples):   50/59 | Train loss: 0.35022 | Train accuracy: 90.43%\n",
      "End of an epoch --> Train loss: 0.33195 | Train accuracy: 90.52%\n",
      "\n",
      "-------\n",
      "Test loss: 0.31030 | Test accuracy: 90.98%\n",
      "-------\n",
      "\n",
      "Epoch: 7\n",
      "-------\n",
      "batch (128 samples):    0/59 | Train loss: 0.28828 | Train accuracy: 92.09%\n",
      "batch (128 samples):   25/59 | Train loss: 0.28514 | Train accuracy: 91.11%\n",
      "batch (128 samples):   50/59 | Train loss: 0.29101 | Train accuracy: 90.72%\n",
      "End of an epoch --> Train loss: 0.31556 | Train accuracy: 90.99%\n",
      "\n",
      "-------\n",
      "Test loss: 0.29780 | Test accuracy: 91.37%\n",
      "-------\n",
      "\n",
      "Epoch: 8\n",
      "-------\n",
      "batch (128 samples):    0/59 | Train loss: 0.34134 | Train accuracy: 90.14%\n",
      "batch (128 samples):   25/59 | Train loss: 0.25494 | Train accuracy: 92.19%\n",
      "batch (128 samples):   50/59 | Train loss: 0.30170 | Train accuracy: 92.09%\n",
      "End of an epoch --> Train loss: 0.30199 | Train accuracy: 91.40%\n",
      "\n",
      "-------\n",
      "Test loss: 0.28375 | Test accuracy: 91.91%\n",
      "-------\n",
      "\n",
      "Epoch: 9\n",
      "-------\n",
      "batch (128 samples):    0/59 | Train loss: 0.30671 | Train accuracy: 91.02%\n",
      "batch (128 samples):   25/59 | Train loss: 0.29001 | Train accuracy: 91.60%\n",
      "batch (128 samples):   50/59 | Train loss: 0.29303 | Train accuracy: 91.11%\n",
      "End of an epoch --> Train loss: 0.28930 | Train accuracy: 91.75%\n",
      "\n",
      "-------\n",
      "Test loss: 0.27432 | Test accuracy: 92.09%\n",
      "-------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "torch.manual_seed(42)\n",
    "\n",
    "# set epochs\n",
    "epochs = 10\n",
    "\n",
    "# create an optimization and evaluation loop using train_step() and test_step()\n",
    "for epoch in tqdm(range(epochs)):\n",
    "    print(f\"Epoch: {epoch}\\n-------\")\n",
    "    train_step(model=mnist_model, \n",
    "               data_loader=mnist_train_dataloader, \n",
    "               loss_fn=loss_fn, \n",
    "               optimizer=optimizer, \n",
    "               accuracy_fn=accuracy_fn,\n",
    "               device='cpu')\n",
    "    \n",
    "    test_step(model=mnist_model,\n",
    "              data_loader=mnist_test_dataloader,\n",
    "              loss_fn=loss_fn,\n",
    "              accuracy_fn=accuracy_fn,\n",
    "              device='cpu')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After training the model, predict the label for 16 random samples from test set and plot the output.\n",
    "\n",
    "*Note: The purpose of this experiment is not comparing the results of the independent and PyTorch-based models (as the learning procedure is a little bit different, in other words, the circumstance for two models is not exactly the same).*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x900 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "torch.manual_seed(42)\n",
    "\n",
    "number_of_images = 16\n",
    "ncols = 4\n",
    "nrows = 4\n",
    "\n",
    "# pick some random images from the train set\n",
    "random_idx = torch.randint(low=0, high=len(mnist_test_data), size=(number_of_images,))#.item()\n",
    "images = mnist_test_data.data[random_idx].type(torch.float32)\n",
    "labels = mnist_test_data.targets[random_idx]\n",
    "\n",
    "mnist_model.eval()\n",
    "with torch.inference_mode():\n",
    "    scores = mnist_model(images)\n",
    "\n",
    "preds = torch.softmax(scores, dim=1).argmax(dim=1)\n",
    "\n",
    "\n",
    "# plot the images and the predicted label for each one alongside it's real label\n",
    "plt.figure(figsize=(9, 9))\n",
    "for i, img in enumerate(images):\n",
    "    plt.subplot(nrows, ncols, i+1)\n",
    "    plt.imshow(img.type(torch.int), cmap='gray')#.permute(2, 1, 0))\n",
    "    \n",
    "    if labels[i] == preds[i]:\n",
    "        plt.title(f'true: {mnist_test_data.classes[labels[i]]}, predicted: {mnist_test_data.classes[preds[i]]}', fontsize=9, c='g')\n",
    "    else:\n",
    "        plt.title(f'true: {mnist_test_data.classes[labels[i]]}, predicted: {mnist_test_data.classes[preds[i]]}', fontsize=9, c='r')\n",
    "    plt.grid('off')\n",
    "    plt.axis('off')\n",
    "\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Models on CIFAR-10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.1 Loading CIFAR-10 dataset using PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this experiment we use PyTorch to load CIFAR-10 dataset for both independent and PyTorch classifiers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.2 Independent neural network on CIFAR-10 dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4.2.1 Load the data for the independent model using PyTorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "# setup training data\n",
    "\n",
    "DATA_PATH = 'D:\\PyTorch_datasets'\n",
    "\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "\n",
    "cifar10_train_data = datasets.CIFAR10(\n",
    "    root=DATA_PATH,\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor(),    # how do we want to transform the data\n",
    "    target_transform=None    # how do we want to transform the labels/targets\n",
    ")\n",
    "\n",
    "cifar10_test_data = datasets.CIFAR10(\n",
    "    root=DATA_PATH,\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor(),\n",
    "    target_transform=None\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((50000, 3072), (50000,), (10000, 3072), (10000,))"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# transform data type and shape for training data\n",
    "cifar10_X_train = cifar10_train_data.data.reshape(cifar10_train_data.data.shape[0], -1).astype(np.float32)\n",
    "cifar10_y_train = np.array(cifar10_train_data.targets)\n",
    "\n",
    "# transform data type and shape for testing data\n",
    "cifar10_X_test = cifar10_test_data.data.reshape(cifar10_test_data.data.shape[0], -1).astype(np.float32)\n",
    "cifar10_y_test = np.array(cifar10_test_data.targets)\n",
    "\n",
    "cifar10_X_train.shape, cifar10_y_train.shape, cifar10_X_test.shape, cifar10_y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n"
     ]
    }
   ],
   "source": [
    "class_names = cifar10_train_data.classes\n",
    "print(class_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Subtract the mean of all training images from both train and test sets, in order to make the mean of train images equal to zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_of_images = np.mean(cifar10_X_train, axis=0)\n",
    "\n",
    "cifar10_X_train -= mean_of_images\n",
    "cifar10_X_test -= mean_of_images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4.2.2 Define the architecture of network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a network architecture with three hidden layers and **Leaky ReLU** activation function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "c10_network = [\n",
    "    Dense_Layer(3072, 4000),\n",
    "    activation_layer(leaky_relu, leaky_relu_prime),\n",
    "    Dense_Layer(4000, 1000),\n",
    "    activation_layer(leaky_relu, leaky_relu_prime),\n",
    "    Dense_Layer(1000, 4000),\n",
    "    activation_layer(leaky_relu, leaky_relu_prime),\n",
    "    Dense_Layer(4000, 10),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4.2.3 Train and evaluate the defined network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train and evaluate the defined independent model on the CIFAR-10 dataset. In this experiment we are using stochastic gradient descent (also known as batch gradient descent), with a batch-size of 256."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    0/960 | accuracy on train: 0.402 | accuracy on test: 0.348 | loss: 4.850 | sum of weights: -393.2439\n",
      "epoch   30/960 | accuracy on train: 0.477 | accuracy on test: 0.341 | loss: 4.568 | sum of weights: -418.1389\n",
      "epoch   60/960 | accuracy on train: 0.480 | accuracy on test: 0.346 | loss: 4.763 | sum of weights: -441.5904\n",
      "epoch   90/960 | accuracy on train: 0.441 | accuracy on test: 0.342 | loss: 4.570 | sum of weights: -461.6985\n",
      "epoch  120/960 | accuracy on train: 0.414 | accuracy on test: 0.357 | loss: 4.620 | sum of weights: -479.8441\n",
      "epoch  150/960 | accuracy on train: 0.496 | accuracy on test: 0.345 | loss: 4.299 | sum of weights: -494.1549\n",
      "epoch  180/960 | accuracy on train: 0.461 | accuracy on test: 0.354 | loss: 4.786 | sum of weights: -508.0264\n",
      "epoch  210/960 | accuracy on train: 0.469 | accuracy on test: 0.368 | loss: 4.405 | sum of weights: -520.6207\n",
      "epoch  240/960 | accuracy on train: 0.461 | accuracy on test: 0.361 | loss: 4.211 | sum of weights: -530.4402\n",
      "epoch  270/960 | accuracy on train: 0.480 | accuracy on test: 0.366 | loss: 4.145 | sum of weights: -539.7492\n",
      "epoch  300/960 | accuracy on train: 0.535 | accuracy on test: 0.359 | loss: 4.342 | sum of weights: -547.2021\n",
      "epoch  330/960 | accuracy on train: 0.504 | accuracy on test: 0.363 | loss: 4.421 | sum of weights: -554.4246\n",
      "epoch  360/960 | accuracy on train: 0.461 | accuracy on test: 0.367 | loss: 4.152 | sum of weights: -561.4558\n",
      "epoch  390/960 | accuracy on train: 0.496 | accuracy on test: 0.360 | loss: 4.508 | sum of weights: -568.7505\n",
      "epoch  420/960 | accuracy on train: 0.508 | accuracy on test: 0.367 | loss: 4.522 | sum of weights: -574.7813\n",
      "epoch  450/960 | accuracy on train: 0.516 | accuracy on test: 0.358 | loss: 4.298 | sum of weights: -580.4098\n",
      "epoch  480/960 | accuracy on train: 0.520 | accuracy on test: 0.374 | loss: 4.506 | sum of weights: -586.1028\n",
      "epoch  510/960 | accuracy on train: 0.523 | accuracy on test: 0.368 | loss: 4.393 | sum of weights: -590.1090\n",
      "epoch  540/960 | accuracy on train: 0.539 | accuracy on test: 0.368 | loss: 4.509 | sum of weights: -594.4909\n",
      "epoch  570/960 | accuracy on train: 0.496 | accuracy on test: 0.360 | loss: 4.515 | sum of weights: -597.6801\n",
      "epoch  600/960 | accuracy on train: 0.543 | accuracy on test: 0.371 | loss: 4.354 | sum of weights: -601.1883\n",
      "epoch  630/960 | accuracy on train: 0.566 | accuracy on test: 0.371 | loss: 4.404 | sum of weights: -604.4180\n",
      "epoch  660/960 | accuracy on train: 0.574 | accuracy on test: 0.376 | loss: 4.568 | sum of weights: -608.1555\n",
      "epoch  690/960 | accuracy on train: 0.508 | accuracy on test: 0.363 | loss: 4.562 | sum of weights: -610.7638\n",
      "epoch  720/960 | accuracy on train: 0.570 | accuracy on test: 0.365 | loss: 4.417 | sum of weights: -614.0921\n",
      "epoch  750/960 | accuracy on train: 0.566 | accuracy on test: 0.369 | loss: 4.306 | sum of weights: -616.8151\n",
      "epoch  780/960 | accuracy on train: 0.590 | accuracy on test: 0.369 | loss: 4.395 | sum of weights: -618.3620\n",
      "epoch  810/960 | accuracy on train: 0.547 | accuracy on test: 0.364 | loss: 4.577 | sum of weights: -621.1204\n",
      "epoch  840/960 | accuracy on train: 0.602 | accuracy on test: 0.380 | loss: 4.331 | sum of weights: -623.2012\n",
      "epoch  870/960 | accuracy on train: 0.609 | accuracy on test: 0.374 | loss: 4.324 | sum of weights: -625.7479\n",
      "epoch  900/960 | accuracy on train: 0.605 | accuracy on test: 0.370 | loss: 4.584 | sum of weights: -627.2707\n",
      "epoch  930/960 | accuracy on train: 0.605 | accuracy on test: 0.371 | loss: 4.331 | sum of weights: -628.9651\n",
      "epoch  959/960 | accuracy on train: 0.605 | accuracy on test: 0.371 | loss: 4.295 | sum of weights: -628.9651\n"
     ]
    }
   ],
   "source": [
    "train(  cifar10_X_train, \n",
    "        cifar10_y_train, \n",
    "        cifar10_X_test, \n",
    "        cifar10_y_test,  \n",
    "        c10_network, \n",
    "        multi_class_hinge, \n",
    "        multi_class_hinge_prime, \n",
    "        learning_rate=1e-1, \n",
    "        reg_func=apply_L2_regularization, \n",
    "        reg_func_prime=apply_L2_regularization_prime, \n",
    "        reg_rate=1e-9, \n",
    "        epochs=960,\n",
    "        sgd=True,\n",
    "        batch_size=256,\n",
    "        verbose=30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After training the model, predict the label for 16 random samples from test set and plot the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x900 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(12)\n",
    "\n",
    "number_of_images = 16\n",
    "ncols = 4\n",
    "nrows = 4\n",
    "\n",
    "\n",
    "# pick some random images from the train set\n",
    "random_indices = np.random.choice(np.arange(0, len(cifar10_test_data.data)), number_of_images, replace=False)\n",
    "random_images = cifar10_test_data.data[random_indices]\n",
    "random_labels = np.array(cifar10_test_data.targets)[random_indices]\n",
    "\n",
    "random_images = random_images.reshape(random_images.shape[0], -1).astype(np.float32)\n",
    "random_images -= mean_of_images\n",
    "\n",
    "# do the forward pass and output the computed scores for each class\n",
    "output = random_images.T\n",
    "for layer in c10_network:\n",
    "    output = layer.forward(output)\n",
    "\n",
    "    \n",
    "# convert the scores to class labels    \n",
    "predicts = predict(random_images, c10_network)\n",
    "accuracy_on_train = np.mean(predicts == random_labels)\n",
    "\n",
    "\n",
    "# add the mean of images back\n",
    "random_images += mean_of_images\n",
    "\n",
    "\n",
    "# plot the images and the predicted label for each one alongside it's real label\n",
    "plt.figure(figsize=(9, 9))\n",
    "for i in range(number_of_images):\n",
    "    plt.subplot(nrows, ncols, i+1)\n",
    "    plt.imshow(random_images[i, :].reshape(32, 32, 3).astype('int'))\n",
    "    \n",
    "    if random_labels[i] == predicts[i]:\n",
    "        plt.title(f'true: {class_names[random_labels[i]]}, predicted: {class_names[predicts[i]]}', fontsize=9, c='g')\n",
    "    else:\n",
    "        plt.title(f'true: {class_names[random_labels[i]]}, predicted: {class_names[predicts[i]]}', fontsize=9, c='r')\n",
    "    plt.grid('off')\n",
    "    plt.axis('off')\n",
    "\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.3 PyTorch on Cifar-10 dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4.3.1 Make the data ready for PyTorch model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To perform stochastic gradient descent as optimization technique in PyTorch model, we need to turn our train and test datasets into dataloaders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<torch.utils.data.dataloader.DataLoader at 0x240e11382e0>,\n",
       " <torch.utils.data.dataloader.DataLoader at 0x240e1138a30>)"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# setup the batch size hyperparameter\n",
    "BATCH_SIZE = 256\n",
    "\n",
    "# turn dataset into iterables (batches)\n",
    "cifar10_train_dataloader = DataLoader(dataset=cifar10_train_data, batch_size=BATCH_SIZE, shuffle=True)\n",
    "\n",
    "cifar10_test_dataloader = DataLoader(dataset=cifar10_test_data, batch_size=1000, shuffle=False)\n",
    "\n",
    "cifar10_train_dataloader, cifar10_test_dataloader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([256, 3, 32, 32]), torch.Size([256]))"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check out what's inside the training dataloader\n",
    "train_features_batch, train_label_batch = next(iter(cifar10_train_dataloader))\n",
    "\n",
    "train_features_batch.shape, train_label_batch.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4.3.2 Define the architecture of network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Replicate the architecture of above netwrok using PyTorch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cifar10ModelV0(nn.Module):\n",
    "    def __init__(self, input_shape: int, hidden_units: int, output_shape: int):\n",
    "        super().__init__()\n",
    "        self.layer_stack = nn.Sequential(\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(in_features=input_shape, out_features=4000),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.Linear(in_features=4000, out_features=1000),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.Linear(in_features=1000, out_features=4000),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.Linear(in_features=4000, out_features=output_shape)\n",
    "        )\n",
    "\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.layer_stack(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the same loss function and optimization technique as above experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cifar10ModelV0(\n",
       "  (layer_stack): Sequential(\n",
       "    (0): Flatten(start_dim=1, end_dim=-1)\n",
       "    (1): Linear(in_features=3072, out_features=4000, bias=True)\n",
       "    (2): LeakyReLU(negative_slope=0.01)\n",
       "    (3): Linear(in_features=4000, out_features=1000, bias=True)\n",
       "    (4): LeakyReLU(negative_slope=0.01)\n",
       "    (5): Linear(in_features=1000, out_features=4000, bias=True)\n",
       "    (6): LeakyReLU(negative_slope=0.01)\n",
       "    (7): Linear(in_features=4000, out_features=10, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.manual_seed(42)\n",
    "\n",
    "cifar10_model = Cifar10ModelV0(input_shape=3072, hidden_units=0, output_shape=len(class_names)).to('cpu')\n",
    "\n",
    "loss_fn = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(params=cifar10_model.parameters(), lr=0.01)\n",
    "\n",
    "cifar10_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4.3.3 Train the defined model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train and evaluate the created PyTorch model on train and test sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c58217a398c9452a8fb3c39481a13127",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0\n",
      "-------\n",
      "batch (128 samples):    0/196 | Train loss: 1.94991 | Train accuracy: 26.17%\n",
      "batch (128 samples):   25/196 | Train loss: 1.94852 | Train accuracy: 27.73%\n",
      "batch (128 samples):   50/196 | Train loss: 1.96115 | Train accuracy: 29.30%\n",
      "batch (128 samples):   75/196 | Train loss: 1.90731 | Train accuracy: 26.95%\n",
      "batch (128 samples):  100/196 | Train loss: 1.92821 | Train accuracy: 32.03%\n",
      "batch (128 samples):  125/196 | Train loss: 1.91665 | Train accuracy: 31.64%\n",
      "batch (128 samples):  150/196 | Train loss: 1.93705 | Train accuracy: 32.03%\n",
      "batch (128 samples):  175/196 | Train loss: 1.94158 | Train accuracy: 30.08%\n",
      "End of an epoch --> Train loss: 1.94213 | Train accuracy: 30.34%\n",
      "\n",
      "-------\n",
      "Test loss: 1.92559 | Test accuracy: 31.05%\n",
      "-------\n",
      "\n",
      "Epoch: 1\n",
      "-------\n",
      "batch (128 samples):    0/196 | Train loss: 1.93584 | Train accuracy: 30.86%\n",
      "batch (128 samples):   25/196 | Train loss: 1.91112 | Train accuracy: 31.64%\n",
      "batch (128 samples):   50/196 | Train loss: 2.00170 | Train accuracy: 30.08%\n",
      "batch (128 samples):   75/196 | Train loss: 1.90336 | Train accuracy: 30.86%\n",
      "batch (128 samples):  100/196 | Train loss: 1.95200 | Train accuracy: 32.03%\n",
      "batch (128 samples):  125/196 | Train loss: 1.83817 | Train accuracy: 37.89%\n",
      "batch (128 samples):  150/196 | Train loss: 1.89211 | Train accuracy: 36.33%\n",
      "batch (128 samples):  175/196 | Train loss: 1.89928 | Train accuracy: 32.03%\n",
      "End of an epoch --> Train loss: 1.90206 | Train accuracy: 31.98%\n",
      "\n",
      "-------\n",
      "Test loss: 1.89082 | Test accuracy: 32.17%\n",
      "-------\n",
      "\n",
      "Epoch: 2\n",
      "-------\n",
      "batch (128 samples):    0/196 | Train loss: 1.89731 | Train accuracy: 31.64%\n",
      "batch (128 samples):   25/196 | Train loss: 1.88737 | Train accuracy: 32.42%\n",
      "batch (128 samples):   50/196 | Train loss: 1.92286 | Train accuracy: 28.91%\n",
      "batch (128 samples):   75/196 | Train loss: 1.87162 | Train accuracy: 32.03%\n",
      "batch (128 samples):  100/196 | Train loss: 1.86016 | Train accuracy: 36.33%\n",
      "batch (128 samples):  125/196 | Train loss: 1.86553 | Train accuracy: 32.03%\n",
      "batch (128 samples):  150/196 | Train loss: 1.89870 | Train accuracy: 32.03%\n",
      "batch (128 samples):  175/196 | Train loss: 1.85230 | Train accuracy: 32.03%\n",
      "End of an epoch --> Train loss: 1.86940 | Train accuracy: 33.38%\n",
      "\n",
      "-------\n",
      "Test loss: 1.86388 | Test accuracy: 33.79%\n",
      "-------\n",
      "\n",
      "Epoch: 3\n",
      "-------\n",
      "batch (128 samples):    0/196 | Train loss: 1.83852 | Train accuracy: 35.94%\n",
      "batch (128 samples):   25/196 | Train loss: 1.76205 | Train accuracy: 37.11%\n",
      "batch (128 samples):   50/196 | Train loss: 1.86954 | Train accuracy: 33.20%\n",
      "batch (128 samples):   75/196 | Train loss: 1.85606 | Train accuracy: 36.72%\n",
      "batch (128 samples):  100/196 | Train loss: 1.85024 | Train accuracy: 31.64%\n",
      "batch (128 samples):  125/196 | Train loss: 1.85472 | Train accuracy: 33.59%\n",
      "batch (128 samples):  150/196 | Train loss: 1.91121 | Train accuracy: 31.25%\n",
      "batch (128 samples):  175/196 | Train loss: 1.90718 | Train accuracy: 33.59%\n",
      "End of an epoch --> Train loss: 1.84315 | Train accuracy: 34.52%\n",
      "\n",
      "-------\n",
      "Test loss: 1.86290 | Test accuracy: 33.44%\n",
      "-------\n",
      "\n",
      "Epoch: 4\n",
      "-------\n",
      "batch (128 samples):    0/196 | Train loss: 1.93891 | Train accuracy: 28.91%\n",
      "batch (128 samples):   25/196 | Train loss: 1.90026 | Train accuracy: 25.00%\n",
      "batch (128 samples):   50/196 | Train loss: 1.77695 | Train accuracy: 39.45%\n",
      "batch (128 samples):   75/196 | Train loss: 1.85412 | Train accuracy: 35.55%\n",
      "batch (128 samples):  100/196 | Train loss: 1.80422 | Train accuracy: 35.94%\n",
      "batch (128 samples):  125/196 | Train loss: 1.72960 | Train accuracy: 36.33%\n",
      "batch (128 samples):  150/196 | Train loss: 1.75787 | Train accuracy: 37.89%\n",
      "batch (128 samples):  175/196 | Train loss: 1.75783 | Train accuracy: 39.06%\n",
      "End of an epoch --> Train loss: 1.81617 | Train accuracy: 35.41%\n",
      "\n",
      "-------\n",
      "Test loss: 1.84111 | Test accuracy: 34.64%\n",
      "-------\n",
      "\n",
      "Epoch: 5\n",
      "-------\n",
      "batch (128 samples):    0/196 | Train loss: 1.77735 | Train accuracy: 40.62%\n",
      "batch (128 samples):   25/196 | Train loss: 1.78909 | Train accuracy: 33.98%\n",
      "batch (128 samples):   50/196 | Train loss: 1.83752 | Train accuracy: 32.42%\n",
      "batch (128 samples):   75/196 | Train loss: 1.87195 | Train accuracy: 33.20%\n",
      "batch (128 samples):  100/196 | Train loss: 1.79585 | Train accuracy: 37.50%\n",
      "batch (128 samples):  125/196 | Train loss: 1.74236 | Train accuracy: 36.33%\n",
      "batch (128 samples):  150/196 | Train loss: 1.80901 | Train accuracy: 30.86%\n",
      "batch (128 samples):  175/196 | Train loss: 1.71985 | Train accuracy: 38.28%\n",
      "End of an epoch --> Train loss: 1.79160 | Train accuracy: 36.29%\n",
      "\n",
      "-------\n",
      "Test loss: 1.77192 | Test accuracy: 36.63%\n",
      "-------\n",
      "\n",
      "Epoch: 6\n",
      "-------\n",
      "batch (128 samples):    0/196 | Train loss: 1.78958 | Train accuracy: 35.94%\n",
      "batch (128 samples):   25/196 | Train loss: 1.77620 | Train accuracy: 32.42%\n",
      "batch (128 samples):   50/196 | Train loss: 1.76934 | Train accuracy: 37.11%\n",
      "batch (128 samples):   75/196 | Train loss: 1.86114 | Train accuracy: 34.77%\n",
      "batch (128 samples):  100/196 | Train loss: 1.81118 | Train accuracy: 37.11%\n",
      "batch (128 samples):  125/196 | Train loss: 1.76116 | Train accuracy: 37.11%\n",
      "batch (128 samples):  150/196 | Train loss: 1.72349 | Train accuracy: 39.84%\n",
      "batch (128 samples):  175/196 | Train loss: 1.87625 | Train accuracy: 32.42%\n",
      "End of an epoch --> Train loss: 1.76841 | Train accuracy: 37.03%\n",
      "\n",
      "-------\n",
      "Test loss: 1.76056 | Test accuracy: 36.77%\n",
      "-------\n",
      "\n",
      "Epoch: 7\n",
      "-------\n",
      "batch (128 samples):    0/196 | Train loss: 1.72479 | Train accuracy: 40.23%\n",
      "batch (128 samples):   25/196 | Train loss: 1.70804 | Train accuracy: 41.41%\n",
      "batch (128 samples):   50/196 | Train loss: 1.72293 | Train accuracy: 38.28%\n",
      "batch (128 samples):   75/196 | Train loss: 1.75124 | Train accuracy: 37.89%\n",
      "batch (128 samples):  100/196 | Train loss: 1.72569 | Train accuracy: 37.11%\n",
      "batch (128 samples):  125/196 | Train loss: 1.70016 | Train accuracy: 40.23%\n",
      "batch (128 samples):  150/196 | Train loss: 1.75815 | Train accuracy: 35.94%\n",
      "batch (128 samples):  175/196 | Train loss: 1.75322 | Train accuracy: 39.06%\n",
      "End of an epoch --> Train loss: 1.74868 | Train accuracy: 37.66%\n",
      "\n",
      "-------\n",
      "Test loss: 1.72893 | Test accuracy: 38.22%\n",
      "-------\n",
      "\n",
      "Epoch: 8\n",
      "-------\n",
      "batch (128 samples):    0/196 | Train loss: 1.73112 | Train accuracy: 34.77%\n",
      "batch (128 samples):   25/196 | Train loss: 1.74561 | Train accuracy: 41.41%\n",
      "batch (128 samples):   50/196 | Train loss: 1.70438 | Train accuracy: 39.45%\n",
      "batch (128 samples):   75/196 | Train loss: 1.71569 | Train accuracy: 34.77%\n",
      "batch (128 samples):  100/196 | Train loss: 1.83475 | Train accuracy: 36.33%\n",
      "batch (128 samples):  125/196 | Train loss: 1.71472 | Train accuracy: 40.23%\n",
      "batch (128 samples):  150/196 | Train loss: 1.68625 | Train accuracy: 37.50%\n",
      "batch (128 samples):  175/196 | Train loss: 1.72578 | Train accuracy: 36.72%\n",
      "End of an epoch --> Train loss: 1.72996 | Train accuracy: 38.43%\n",
      "\n",
      "-------\n",
      "Test loss: 1.71684 | Test accuracy: 39.04%\n",
      "-------\n",
      "\n",
      "Epoch: 9\n",
      "-------\n",
      "batch (128 samples):    0/196 | Train loss: 1.69377 | Train accuracy: 38.67%\n",
      "batch (128 samples):   25/196 | Train loss: 1.69081 | Train accuracy: 38.67%\n",
      "batch (128 samples):   50/196 | Train loss: 1.75022 | Train accuracy: 33.59%\n",
      "batch (128 samples):   75/196 | Train loss: 1.85025 | Train accuracy: 34.77%\n",
      "batch (128 samples):  100/196 | Train loss: 1.74362 | Train accuracy: 41.41%\n",
      "batch (128 samples):  125/196 | Train loss: 1.66438 | Train accuracy: 39.06%\n",
      "batch (128 samples):  150/196 | Train loss: 1.66702 | Train accuracy: 41.41%\n",
      "batch (128 samples):  175/196 | Train loss: 1.72703 | Train accuracy: 40.23%\n",
      "End of an epoch --> Train loss: 1.70978 | Train accuracy: 39.08%\n",
      "\n",
      "-------\n",
      "Test loss: 1.69514 | Test accuracy: 39.59%\n",
      "-------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "torch.manual_seed(42)\n",
    "\n",
    "# set epochs\n",
    "epochs = 10\n",
    "\n",
    "# create an optimization and evaluation loop using train_step() and test_step()\n",
    "for epoch in tqdm(range(epochs)):\n",
    "    print(f\"Epoch: {epoch}\\n-------\")\n",
    "    train_step(model=cifar10_model, \n",
    "               data_loader=cifar10_train_dataloader, \n",
    "               loss_fn=loss_fn, \n",
    "               optimizer=optimizer, \n",
    "               accuracy_fn=accuracy_fn,\n",
    "               device='cpu')\n",
    "    \n",
    "    test_step(model=cifar10_model,\n",
    "              data_loader=cifar10_test_dataloader,\n",
    "              loss_fn=loss_fn,\n",
    "              accuracy_fn=accuracy_fn,\n",
    "              device='cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------\n",
      "Test loss: 1.69514 | Test accuracy: 39.59%\n",
      "-------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "test_step(model=cifar10_model,\n",
    "              data_loader=cifar10_test_dataloader,\n",
    "              loss_fn=loss_fn,\n",
    "              accuracy_fn=accuracy_fn,\n",
    "              device='cpu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After training the model, predict the label for 16 random samples (same as above experiment) from test set and plot the output.\n",
    "\n",
    "*Note: The purpose of this experiment is not comparing the results of the independent and PyTorch-based models (as the learning procedure is a little bit different, in other words, the circumstance for two models isn't exactly the same).*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x900 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(12)\n",
    "\n",
    "number_of_images = 16\n",
    "ncols = 4\n",
    "nrows = 4\n",
    "\n",
    "# pick some random images from the train set\n",
    "random_idx = torch.tensor(np.random.choice(np.arange(0, len(cifar10_test_data.data)), number_of_images, replace=False))\n",
    "images = torch.tensor(cifar10_test_data.data[random_idx]).type(torch.float32).permute(0, 3, 1, 2)\n",
    "labels = torch.tensor(cifar10_test_data.targets)[random_idx]\n",
    "\n",
    "cifar10_model.eval()\n",
    "with torch.inference_mode():\n",
    "    scores = cifar10_model(images)\n",
    "preds = torch.softmax(scores, dim=1).argmax(dim=1)\n",
    "\n",
    "\n",
    "# plot the images and the predicted label for each one alongside it's real label\n",
    "plt.figure(figsize=(9, 9))\n",
    "for i, img in enumerate(images):\n",
    "    plt.subplot(nrows, ncols, i+1)\n",
    "#     print(img.type())\n",
    "    plt.imshow(img.type(torch.int).permute(2, 1, 0))\n",
    "    \n",
    "    if labels[i] == preds[i]:\n",
    "        plt.title(f'true: {classes[labels[i]]}, predicted: {classes[preds[i]]}', fontsize=9, c='g')\n",
    "    else:\n",
    "        plt.title(f'true: {classes[labels[i]]}, predicted: {classes[preds[i]]}', fontsize=9, c='r')\n",
    "    plt.grid('off')\n",
    "    plt.axis('off')\n",
    "\n",
    "plt.tight_layout()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "82961d191f51bf000ec3359ee4c028fff9dfd49d44967cf2a5608644c47eaab5"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}