group12_Phase2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "group12_Phase2.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "bf307765891b4a598bfffa5bfbe75255": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "state": {
            "_view_name": "HBoxView",
            "_dom_classes": [],
            "_model_name": "HBoxModel",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "box_style": "",
            "layout": "IPY_MODEL_e99ffed49f3a40a285fa09c3aae22d56",
            "_model_module": "@jupyter-widgets/controls",
            "children": [
              "IPY_MODEL_16c60ae6d0034f5fb52add9f1bd5ffdd",
              "IPY_MODEL_ed002ac04e494d099f8fa6972de5dd36"
            ]
          }
        },
        "e99ffed49f3a40a285fa09c3aae22d56": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "16c60ae6d0034f5fb52add9f1bd5ffdd": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "state": {
            "_view_name": "ProgressView",
            "style": "IPY_MODEL_3353d46307c9422db6d415c093aa24ca",
            "_dom_classes": [],
            "description": "100%",
            "_model_name": "FloatProgressModel",
            "bar_style": "success",
            "max": 140,
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": 140,
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "orientation": "horizontal",
            "min": 0,
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_7012ba51df774727822bd119070d9eec"
          }
        },
        "ed002ac04e494d099f8fa6972de5dd36": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "state": {
            "_view_name": "HTMLView",
            "style": "IPY_MODEL_86c833a9f7b140af848cd5f2afc5d1cf",
            "_dom_classes": [],
            "description": "",
            "_model_name": "HTMLModel",
            "placeholder": "​",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": " 140/140 [2:03:15&lt;00:00, 52.82s/it]",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_7d1e7d554b994a4e95da84243439a5ff"
          }
        },
        "3353d46307c9422db6d415c093aa24ca": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "ProgressStyleModel",
            "description_width": "initial",
            "_view_module": "@jupyter-widgets/base",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.2.0",
            "bar_color": null,
            "_model_module": "@jupyter-widgets/controls"
          }
        },
        "7012ba51df774727822bd119070d9eec": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "86c833a9f7b140af848cd5f2afc5d1cf": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "DescriptionStyleModel",
            "description_width": "",
            "_view_module": "@jupyter-widgets/base",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.2.0",
            "_model_module": "@jupyter-widgets/controls"
          }
        },
        "7d1e7d554b994a4e95da84243439a5ff": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        }
      }
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SYT-2x47-sjY"
      },
      "source": [
        "# CS331 - Spring 2021 - Phase 2 [10%]\n",
        "\n",
        "*__Submission Guidelines:__*\n",
        "- Naming convention for submission of this notebook is `groupXX_Phase2.ipynb` where XX needs to be replaced by your group number. For example: group 1 would rename their notebook to `group01_Phase2.ipynb`\n",
        "- Only the group lead is supposed to make the submission\n",
        "- Only the single .ipynb file needs to be submitted via LMS \n",
        "- All the cells <b>must</b> be run once before submission. If your submission's cells are not showing the results (plots etc.), marks wil be deducted\n",
        "- Only the code written within this notebook will be considered while grading. No other files will be entertained\n",
        "- You are advised to follow good programming practies including approriate variable naming and making use of logical comments \n",
        "\n",
        "The university honor code should be maintained. Any violation, if found, will result in disciplinary action. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zpC12Mye-9uZ"
      },
      "source": [
        "#### <b>Introduction</b> \n",
        "This is the second of the three phases of this offering's project. Having implemented a neural network from scratch using for loops, you will now be using vectorization (wherever applicable) to improve the performance of the model and equip it to deal with the complete Fashion MNIST Dataset.\n",
        "\n",
        "The dataset consists of 70,000 images of fashion/clothing items belonging to 10 different categories/classes. It has furhter been divided into 60,000 training images and 10,000 test images and each image is a 28*28 grayscale image (hence 1 color channel). It is recommended that you go through  [this link](https://www.kaggle.com/zalando-research/fashionmnist) to familiarize yourself with the dataset.\n",
        "\n",
        "In this phase, you will load the required dataset from the keras datasets library. To get the best results, you will need to tweak hyperparameters, and the best values will not necessarily be the ones you performed for your computations in phase 1 with.\n",
        "\n",
        "###### <b>IMPORTANT\n",
        "\n",
        "In this phase, you will be required to implement multiple hidden layers (>= 2) alongside the input and output layer, as opposed to the one you implemented in phase 1. This may require some revision to the logic of the code you use.\n",
        "\n",
        "###### Modification of the provided code without prior discussion with the TAs will result in a grade deduction</b>\n",
        "\n",
        "---\n",
        "\n",
        "###### <b>Side note</b>\n",
        "The `plot_model` method will only work if you have the `pydot` python package installed along with [Graphviz](https://graphviz.gitlab.io/download/). If you do not wish to use this then simply comment out the import for `pydot`\n",
        "\n",
        "###### <b>Need Help?</b>\n",
        "If you need help, please refer to the course staff ASAP and do not wait till the last moment as they might not be available on very short notice close to deadlines"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "idDbgABDBuvZ"
      },
      "source": [
        "#### <b>Before You Begin</b>\n",
        "\n",
        "Skeleton code is provided to get you started. The main methods that you need to implement correspond to the four steps of the training process of a NN which are as follows:\n",
        "1. Initialize variables and initialize weights\n",
        "2. Forward pass\n",
        "3. Backward pass AKA Backpropogation\n",
        "4. Weight Update AKA Gradient Descent\n",
        "\n",
        "__Look for comments in the code to see where you are supposed to write your code__ \n",
        "\n",
        "A `fit` function is what combines the previous three functions and overall trains the network to __fit__ to the provided training examples. The provided `fit` methods requires all the four steps of the training process to be working correctly. The function has been setup in a way that it expects the above four methods to take particular inputs and return particular outputs. __You are supposed to work within this restriction__ \n",
        "\n",
        "\n",
        "\n",
        "__To see if your model is working correctly, you need to make sure that your model loss is going down during training__\n",
        "\n",
        "__The number of hidden layers needs to be >= 2, and the implementation should not crash if we attempt to arbitrarily change it__\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s0OE_p0V-q-H"
      },
      "source": [
        "# making all the necessary imports here\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import time\n",
        "%matplotlib inline\n",
        "import matplotlib.pyplot as plt\n",
        "plt.style.use('seaborn')\n",
        "from IPython.display import Image\n",
        "import pydot\n",
        "from tqdm import tqdm_notebook\n",
        "import seaborn as sns\n",
        "from keras.datasets import fashion_mnist\n",
        "from sklearn.model_selection import train_test_split\n",
        "from keras.utils import np_utils\n",
        "from sklearn.datasets import make_moons\n",
        "from sklearn.linear_model import LinearRegression, LogisticRegression\n",
        "from sklearn.metrics import confusion_matrix,classification_report\n",
        "from google.colab import drive\n",
        "import glob\n",
        "import cv2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sz6xWsK3B-k4"
      },
      "source": [
        "# This function will be used to plot the confusion matrix at the end of this notebook\n",
        "\n",
        "def plot_confusion_matrix(conf_mat):\n",
        "    classes = ['T-shirt/top','Trouser/pants','Pullover shirt','Dress','Coat','Sandal','Shirt','Sneaker','Bag','Ankle boot']\n",
        "    df_cm = pd.DataFrame(conf_mat,classes,classes)\n",
        "    plt.figure(figsize=(15,9))\n",
        "    sns.set(font_scale=1.4)\n",
        "    sns.heatmap(df_cm, annot=True,annot_kws={\"size\": 16})\n",
        "    plt.show()\n",
        "\n",
        "class_labels = ['T-shirt/top','Trouser/pants','Pullover shirt','Dress','Coat','Sandal','Shirt','Sneaker','Bag','Ankle boot']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J8vdVLQ0B_bd"
      },
      "source": [
        "# Enter group lead's roll number here. This will be used for plotting purposes\n",
        "\n",
        "rollnumber = 22100145"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MK2xKOxzCqgE"
      },
      "source": [
        "#### __Dataset from Keras Library__\n",
        "\n",
        "The required library has been imported for you as fashion_mnist. Use it to load the train and test data accordingly."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ehOJSGECqOD",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 486
        },
        "outputId": "81b465ba-cc8d-42fc-c35e-749a8a0ee408"
      },
      "source": [
        "classes = 10 # Do not change this\n",
        "import tensorflow as tf\n",
        "#Download Fashion MNIST dataset\n",
        "# fashion_mnist = keras.dataset.fashion_mnist\n",
        "###### Code Here ######\n",
        "\n",
        "\n",
        "(X_train, y_train), (X_test, y_test) = fashion_mnist.load_data()\n",
        "\n",
        "\n",
        "y_train = tf.keras.utils.to_categorical(\n",
        "    y_train, num_classes=10, dtype='float32'\n",
        ")\n",
        "\n",
        "y_test = tf.keras.utils.to_categorical(\n",
        "    y_test, num_classes=10, dtype='float32'\n",
        ")\n",
        "\n",
        "X_train = X_train.flatten().reshape(60000,784)\n",
        "X_test = X_test.flatten().reshape(10000,784)\n",
        "X_test = X_test/255.0\n",
        "X_train = X_train/255.0\n",
        "print(\"xtrain\",X_train.shape)\n",
        "print(\"x test\",X_test.shape)\n",
        "print(\"ytrain\",y_train.shape)\n",
        "print(\"ytest\",y_test.shape)\n",
        "\n",
        "\n",
        "plt.imshow(X_train[0:1].reshape(28,28).squeeze(),cmap = \"gray\") # just to check if dataset is being loaded properly"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz\n",
            "32768/29515 [=================================] - 0s 0us/step\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz\n",
            "26427392/26421880 [==============================] - 0s 0us/step\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz\n",
            "8192/5148 [===============================================] - 0s 0us/step\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz\n",
            "4423680/4422102 [==============================] - 0s 0us/step\n",
            "xtrain (60000, 784)\n",
            "x test (10000, 784)\n",
            "ytrain (60000, 10)\n",
            "ytest (10000, 10)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f343eb0f690>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BLeZFElYFINX"
      },
      "source": [
        "#### __NN Implementation__\n",
        "Your implementation of NN needs to use the `sigmoid` activation function for all hidden layers and the `softmax` activation function for the output layer. The NN model you will be creating here will consits of only three layers: 1 input layer, n hidden layers (where you have the liberty to define n) and 1 output layer."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rVq8Oq-MD2wZ"
      },
      "source": [
        "class NeuralNetwork():\n",
        "    @staticmethod\n",
        "    def cross_entropy_loss(y_pred, y_true):\n",
        "        # implement cross_entropy_loss function\n",
        "        #TO DO\n",
        "        loss = - np.sum(y_true * np.log(y_pred),axis = 1, keepdims = True)\n",
        "        # cost = np.mean(loss)\n",
        "        # dim = loss.shape\n",
        "        # print(dim)\n",
        "        # print(\"loss\", loss.shape)\n",
        "        return np.sum(loss)\n",
        "\n",
        "    @staticmethod\n",
        "    def accuracy(y_pred, y_true):\n",
        "        # implement accuracy function\n",
        "        #TO DO\n",
        "        count = 0 \n",
        "        for i in range(len(y_pred)):\n",
        "          if y_pred[i] == y_true[i]:\n",
        "            count = count + 1\n",
        "          \n",
        "        return count/len(y_pred)\n",
        "\n",
        "    @staticmethod\n",
        "    def softmax(x):\n",
        "        # implement softmax function\n",
        "        #TO DO\n",
        "        x = np.exp(x)\n",
        "        return x/np.sum(x) \n",
        "\n",
        "    @staticmethod\n",
        "    def sigmoid(x):\n",
        "        #TO DO\n",
        "        x = -x \n",
        "        exp = np.exp(x) + 1\n",
        "        return 1/exp\n",
        "\n",
        "    def __init__(self, nodes_per_layer):\n",
        "        '''Creates a Feed-Forward Neural Network.\n",
        "        The parameters represent the number of nodes in each layer. \n",
        "        Look at the inputs to the function, and use 'try and accept'\n",
        "        to catch errors if number of layers are < 2.\n",
        "        '''\n",
        "        if len(nodes_per_layer) < 2:\n",
        "          raise Exception('Cannot have less than 2 hidden layers')\n",
        "        self.num_layers = 2+len(nodes_per_layer) # including input and output layers\n",
        "        self.nodes_per_layer = nodes_per_layer\n",
        "        self.input_shape = 784\n",
        "        self.output_shape = 10\n",
        "\n",
        "        self.weights_ = []\n",
        "        self.biases_ = []\n",
        "        self.__init_weights(nodes_per_layer)\n",
        "\n",
        "    def __init_weights(self, nodes_per_layer):\n",
        "        '''Initializes all weights based on standard normal distribution and all biases to 0.'''\n",
        "        '''Initialize weights for each layer except the input layer, since it does not have weights.'''\n",
        "        \n",
        "        ###### Code Here ######\n",
        "        self.weights_.append(np.random.normal(size= (self.nodes_per_layer[0],self.input_shape)))\n",
        "        self.biases_.append(np.zeros(shape=(self.nodes_per_layer[0],1)))\n",
        "\n",
        "        #loop\n",
        "        for i in range(len(self.nodes_per_layer)):\n",
        "          if i == 0: #sasta kaam\n",
        "            continue\n",
        "          self.weights_.append(np.random.normal(size= (self.nodes_per_layer[i],self.nodes_per_layer[i-1])))\n",
        "          self.biases_.append(np.zeros(shape=(self.nodes_per_layer[i],1)))\n",
        "        \n",
        "        self.weights_.append(np.random.normal(size= (self.output_shape,self.nodes_per_layer[-1])))\n",
        "        self.biases_.append(np.zeros(shape=(self.output_shape,1)))\n",
        "       \n",
        "    \n",
        "    def forward_pass(self, input_data):\n",
        "        '''Executes the feed forward algorithm.\n",
        "        \"input_data\" is the input to the network in row-major form\n",
        "        Returns \"activations\", which is a list of all layer outputs (excluding input layer of course)'''\n",
        "        \n",
        "        ###### Code Here ######\n",
        "        # tyaar\n",
        "        activations = [] #initialize\n",
        "        # print(\"inputdatashape\",input_data.shape)\n",
        "        # print(self.weights_[0].shape)\n",
        "        a = np.dot(self.weights_[0],input_data.T) \n",
        "        # print(\"a shape\", a.shape)\n",
        "        a += self.biases_[0]\n",
        "\n",
        "        z = NeuralNetwork.sigmoid(a) \n",
        "\n",
        "        activations.append(z)\n",
        "\n",
        "        for i in range(1,len(self.nodes_per_layer)):\n",
        "          a_i = np.dot(self.weights_[i],activations[-1]) + self.biases_[i]\n",
        "          z_i = NeuralNetwork.sigmoid(a_i)\n",
        "          activations.append(z_i)\n",
        "        \n",
        "        a_o = np.dot(self.weights_[-1],activations[-1]) + self.biases_[-1]\n",
        "        z_o = NeuralNetwork.softmax(a_o)\n",
        "        activations.append(z_o.T)\n",
        "\n",
        "        return activations\n",
        "\n",
        "    def backward_pass(self, targets, layer_activations):\n",
        "        '''Executes the backpropogation algorithm.\n",
        "        \"targets\" is the ground truth/labels\n",
        "        \"layer_activations\" are the return value of the forward pass step\n",
        "        Returns \"deltas\", which is a list containing weight update values for all layers (excluding the input layer of course)'''\n",
        "        \n",
        "        ###### Code Here ######\n",
        "        deltas = []\n",
        "\n",
        "        d_b_o = layer_activations[-1] - targets\n",
        "        d_b_o = d_b_o.T\n",
        "        deltas.append(d_b_o)\n",
        "\n",
        "        for i in range(len(self.nodes_per_layer)-1,-1,-1):\n",
        "          dy_dz_h = (layer_activations[i])*(1-(layer_activations[i]))\n",
        "          dy_dz = np.dot(self.weights_[i+1].T,deltas[-1])\n",
        "          multiplication = np.multiply(dy_dz,dy_dz_h)\n",
        "          deltas.append(multiplication)\n",
        "        \n",
        "        deltas.reverse()\n",
        "        return deltas\n",
        "    \n",
        "    def weight_update(self, deltas, layer_inputs, lr):\n",
        "        '''Executes the gradient descent algorithm.\n",
        "        \"deltas\" is return value of the backward pass step\n",
        "        \"layer_inputs\" is a list containing the inputs for all layers (including the input layer)\n",
        "        \"lr\" is the learning rate'''\n",
        "        \n",
        "        ###### Code Here ######\n",
        "        for i in range(len(self.weights_)):\n",
        "          if i == 0:\n",
        "            transpose = layer_inputs[i]\n",
        "          else:\n",
        "            transpose = layer_inputs[i].T\n",
        "          gradient = np.dot(deltas[i],transpose)\n",
        "          self.weights_[i] -= lr*gradient\n",
        "          self.biases_[i] -= lr*deltas[i]\n",
        "  \n",
        "    \n",
        "    ###### Do Not Change Anything Below this line in This Cell ######\n",
        "    \n",
        "    def fit(self, Xs, Ys, epochs, lr=1e-3):\n",
        "            history = []\n",
        "            for epoch in tqdm_notebook(range(epochs)):\n",
        "                num_samples = Xs.shape[0]\n",
        "                for i in range(num_samples):\n",
        "\n",
        "                    sample_input = Xs[i,:].reshape((1,self.input_shape))\n",
        "                    sample_target = Ys[i,:].reshape((1,self.output_shape))\n",
        "                    \n",
        "                    activations = self.forward_pass(sample_input)   # Call forward_pass function \n",
        "                    deltas = self.backward_pass(sample_target, activations)    # Call backward_pass function \n",
        "                    layer_inputs = [sample_input] + activations[:-1]\n",
        "                    \n",
        "                    # Call weight_update function \n",
        "                    self.weight_update(deltas, layer_inputs, lr)\n",
        "                \n",
        "                preds = self.predict(Xs)   # Call predict function \n",
        "\n",
        "                current_loss = self.cross_entropy_loss(preds, Ys)\n",
        "                \n",
        "                if  epoch==epochs-1:\n",
        "                  confusion_mat=confusion_matrix(Ys.argmax(axis=1), preds.argmax(axis=1),labels=np.arange(10))  \n",
        "                  plot_confusion_matrix(confusion_mat)\n",
        "                  report = classification_report(Ys, np_utils.to_categorical(preds.argmax(axis=1),num_classes=classes), target_names=class_labels)\n",
        "                  print(report)\n",
        "                history.append(current_loss)\n",
        "            return history\n",
        "    \n",
        "    def predict(self, Xs):\n",
        "        '''Returns the model predictions (output of the last layer) for the given \"Xs\".'''\n",
        "        predictions = []\n",
        "        num_samples = Xs.shape[0]\n",
        "        for i in range(num_samples):\n",
        "            sample = Xs[i,:].reshape((1,self.input_shape))\n",
        "            sample_prediction = self.forward_pass(sample)[-1]\n",
        "            predictions.append(sample_prediction.reshape((self.output_shape,)))\n",
        "        return np.array(predictions)\n",
        "    \n",
        "    def evaluate(self, Xs, Ys):\n",
        "        '''Returns appropriate metrics for the task, calculated on the dataset passed to this method.'''\n",
        "        pred = self.predict(Xs)\n",
        "        return self.cross_entropy_loss(pred, Ys), self.accuracy(pred.argmax(axis=1), Ys.argmax(axis=1))\n",
        "    \n",
        "    def plot_model(self, filename):\n",
        "        '''Provide the \"filename\" as a string including file extension. Creates an image showing the model as a graph.'''\n",
        "        graph = pydot.Dot(graph_type='digraph')\n",
        "        graph.set_rankdir('LR')\n",
        "        graph.set_node_defaults(shape='circle', fontsize=0)\n",
        "        nodes_per_layer = [self.input_shape, self.hidden_shape, self.output_shape]\n",
        "        for i in range(self.num_layers-1):\n",
        "            for n1 in range(nodes_per_layer[i]):\n",
        "                for n2 in range(nodes_per_layer[i+1]):\n",
        "                    edge = pydot.Edge(f'l{i}n{n1}', f'l{i+1}n{n2}')\n",
        "                    graph.add_edge(edge)\n",
        "        graph.write_png(filename)"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ew6nN0HyfbSd"
      },
      "source": [
        "# These are what we call the hyperparameters (a.k.a Black Magic). You need to research on them and tweak them to see what generates the best result for you \n",
        "\n",
        "EPOCH = 140           \n",
        "LEARNING_RATE = 0.001  \n",
        "nodes_per_layer = [150,75] # please note: we are only taking input for the hidden layers since input and ouput layer have fixed number of nodes!\n",
        "                           # so nodes per layer will only get the nodes for hidden layers and the number of nodes must be atleast 2!\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z6TTr8h1fo4l",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000,
          "referenced_widgets": [
            "bf307765891b4a598bfffa5bfbe75255",
            "e99ffed49f3a40a285fa09c3aae22d56",
            "16c60ae6d0034f5fb52add9f1bd5ffdd",
            "ed002ac04e494d099f8fa6972de5dd36",
            "3353d46307c9422db6d415c093aa24ca",
            "7012ba51df774727822bd119070d9eec",
            "86c833a9f7b140af848cd5f2afc5d1cf",
            "7d1e7d554b994a4e95da84243439a5ff"
          ]
        },
        "outputId": "53466ba2-5dc0-4811-e739-2054e36dba37"
      },
      "source": [
        "start = time.time()\n",
        "\n",
        "# Instantiate the neural network with the number of nodes you choose per layer, right now it is done for three layers only.\n",
        "nn = NeuralNetwork(nodes_per_layer=nodes_per_layer)\n",
        "history = nn.fit(X_train, y_train, epochs=EPOCH, lr=LEARNING_RATE)\n",
        "plt.plot(history);\n",
        "plt.gca().set(xlabel='Epoch', ylabel='Cross-entropy', title='Training Plot {}'.format(rollnumber));\n",
        "end = time.time()\n",
        "\n",
        "print(\"Runtime of the algorithm is \", round((end - start),3),\" seconds\")\n",
        "\n",
        "# print accuracy on test set here\n",
        "print(nn.evaluate(X_test,y_test))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:145: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
            "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "bf307765891b4a598bfffa5bfbe75255",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": [
              "HBox(children=(FloatProgress(value=0.0, max=140.0), HTML(value='')))"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x648 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "                precision    recall  f1-score   support\n",
            "\n",
            "   T-shirt/top       0.82      0.89      0.86      6000\n",
            " Trouser/pants       0.99      0.98      0.99      6000\n",
            "Pullover shirt       0.82      0.83      0.82      6000\n",
            "         Dress       0.89      0.93      0.91      6000\n",
            "          Coat       0.80      0.86      0.83      6000\n",
            "        Sandal       0.98      0.98      0.98      6000\n",
            "         Shirt       0.81      0.66      0.72      6000\n",
            "       Sneaker       0.97      0.96      0.96      6000\n",
            "           Bag       0.98      0.97      0.97      6000\n",
            "    Ankle boot       0.97      0.98      0.97      6000\n",
            "\n",
            "     micro avg       0.90      0.90      0.90     60000\n",
            "     macro avg       0.90      0.90      0.90     60000\n",
            "  weighted avg       0.90      0.90      0.90     60000\n",
            "   samples avg       0.90      0.90      0.90     60000\n",
            "\n",
            "\n",
            "Runtime of the algorithm is  7395.21  seconds\n",
            "(4346.557956530026, 0.8527)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "weUMg5e6FrMa"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}