Digit_recog_Neural_Network.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this assignment, you'll implement an L-layered deep neural network and train it on the MNIST dataset. The MNIST dataset contains scanned images of handwritten digits, along with their correct classification labels (between 0-9). MNIST's name comes from the fact that it is a modified subset of two data sets collected by NIST, the United States' National Institute of Standards and Technology.<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pickle\n",
    "import gzip\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "import sklearn\n",
    "import sklearn.datasets\n",
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The MNIST dataset we use here is 'mnist.pkl.gz' which is divided into training, validation and test data. The following function <i> load_data() </i> unpacks the file and extracts the training, validation and test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data():\n",
    "    f = gzip.open('mnist.pkl.gz', 'rb')\n",
    "    f.seek(0)\n",
    "    training_data, validation_data, test_data = pickle.load(f, encoding='latin1')\n",
    "    f.close()\n",
    "    return (training_data, validation_data, test_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how the data looks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_data, validation_data, test_data = load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.]], dtype=float32),\n",
       " array([5, 0, 4, ..., 8, 4, 8], dtype=int64))"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "training_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50000, 784)\n",
      "(50000,)\n"
     ]
    }
   ],
   "source": [
    "# shape of data\n",
    "print(training_data[0].shape)\n",
    "print(training_data[1].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The feature dataset is:[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " ...\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n",
      "The target dataset is:[5 0 4 ... 8 4 8]\n",
      "The number of examples in the training dataset is:50000\n",
      "The number of points in a single input is:784\n"
     ]
    }
   ],
   "source": [
    "print(\"The feature dataset is:\" + str(training_data[0]))\n",
    "print(\"The target dataset is:\" + str(training_data[1]))\n",
    "print(\"The number of examples in the training dataset is:\" + str(len(training_data[0])))\n",
    "print(\"The number of points in a single input is:\" + str(len(training_data[0][1])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, as discussed earlier in the lectures, the target variable is converted to a one hot matrix. We use the function <i> one_hot </i> to convert the target dataset to one hot encoding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_hot(j):\n",
    "    # input is the target dataset of shape (m,) where m is the number of data points\n",
    "    # returns a 2 dimensional array of shape (10, m) where each target value is converted to a one hot encoding\n",
    "    # Look at the next block of code for a better understanding of one hot encoding\n",
    "    n = j.shape[0]\n",
    "    new_array = np.zeros((10, n))\n",
    "    index = 0\n",
    "    for res in j:\n",
    "        new_array[res][index] = 1.0\n",
    "        index = index + 1\n",
    "    return new_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
    "print(data.shape)\n",
    "one_hot(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following function data_wrapper() will convert the dataset into the desired shape and also convert the ground truth labels to one_hot matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_wrapper():\n",
    "    tr_d, va_d, te_d = load_data()\n",
    "    \n",
    "    training_inputs = np.array(tr_d[0][:]).T\n",
    "    training_results = np.array(tr_d[1][:])\n",
    "    train_set_y = one_hot(training_results)\n",
    "    \n",
    "    validation_inputs = np.array(va_d[0][:]).T\n",
    "    validation_results = np.array(va_d[1][:])\n",
    "    validation_set_y = one_hot(validation_results)\n",
    "    \n",
    "    test_inputs = np.array(te_d[0][:]).T\n",
    "    test_results = np.array(te_d[1][:])\n",
    "    test_set_y = one_hot(test_results)\n",
    "    \n",
    "    return (training_inputs, train_set_y, test_inputs, test_set_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set_x, train_set_y, test_set_x, test_set_y = data_wrapper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_set_x shape: (784, 50000)\n",
      "train_set_y shape: (10, 50000)\n",
      "test_set_x shape: (784, 10000)\n",
      "test_set_y shape: (10, 10000)\n"
     ]
    }
   ],
   "source": [
    "print (\"train_set_x shape: \" + str(train_set_x.shape))\n",
    "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
    "print (\"test_set_x shape: \" + str(test_set_x.shape))\n",
    "print (\"test_set_y shape: \" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the data_wrapper has converted the training and validation data into numpy array of desired shapes. Let's convert the actual labels into a dataframe to see if the one hot conversions are correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = pd.DataFrame(train_set_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The target dataset is:[5 0 4 ... 8 4 8]\n",
      "The one hot encoding dataset is:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>...</th>\n",
       "      <th>49990</th>\n",
       "      <th>49991</th>\n",
       "      <th>49992</th>\n",
       "      <th>49993</th>\n",
       "      <th>49994</th>\n",
       "      <th>49995</th>\n",
       "      <th>49996</th>\n",
       "      <th>49997</th>\n",
       "      <th>49998</th>\n",
       "      <th>49999</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>10 rows × 50000 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   0      1      2      3      4      5      6      7      8      9      ...  \\\n",
       "0    0.0    1.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  ...   \n",
       "1    0.0    0.0    0.0    1.0    0.0    0.0    1.0    0.0    1.0    0.0  ...   \n",
       "2    0.0    0.0    0.0    0.0    0.0    1.0    0.0    0.0    0.0    0.0  ...   \n",
       "3    0.0    0.0    0.0    0.0    0.0    0.0    0.0    1.0    0.0    0.0  ...   \n",
       "4    0.0    0.0    1.0    0.0    0.0    0.0    0.0    0.0    0.0    1.0  ...   \n",
       "5    1.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  ...   \n",
       "6    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  ...   \n",
       "7    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  ...   \n",
       "8    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  ...   \n",
       "9    0.0    0.0    0.0    0.0    1.0    0.0    0.0    0.0    0.0    0.0  ...   \n",
       "\n",
       "   49990  49991  49992  49993  49994  49995  49996  49997  49998  49999  \n",
       "0    0.0    0.0    0.0    0.0    0.0    0.0    1.0    0.0    0.0    0.0  \n",
       "1    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  \n",
       "2    0.0    0.0    0.0    1.0    0.0    0.0    0.0    0.0    0.0    0.0  \n",
       "3    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  \n",
       "4    0.0    0.0    0.0    0.0    1.0    0.0    0.0    0.0    1.0    0.0  \n",
       "5    0.0    1.0    1.0    0.0    0.0    1.0    0.0    0.0    0.0    0.0  \n",
       "6    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  \n",
       "7    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  \n",
       "8    1.0    0.0    0.0    0.0    0.0    0.0    0.0    1.0    0.0    1.0  \n",
       "9    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  \n",
       "\n",
       "[10 rows x 50000 columns]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"The target dataset is:\" + str(training_data[1]))\n",
    "print(\"The one hot encoding dataset is:\")\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let us visualise the dataset. Feel free to change the index to see if the training data has been correctly tagged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x24bb4ef9688>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "index  = 1000\n",
    "k = train_set_x[:,index]\n",
    "k = k.reshape((28, 28))\n",
    "plt.title('Label is {label}'.format(label= training_data[1][index]))\n",
    "plt.imshow(k, cmap='gray')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feedforward"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sigmoid\n",
    "This is one of the activation functions. It takes the cumulative input to the layer, the matrix **Z**, as the input. Upon application of the **`sigmoid`** function, the output matrix **H** is calculated. Also, **Z** is stored as the variable **sigmoid_memory** since it will be later used in backpropagation.You use _[np.exp()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.exp.html)_ here in the following way. The exponential gets applied to all the elements of Z."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(Z):\n",
    "    \n",
    "    # Z is numpy array of shape (n, m) where n is number of neurons in the layer and m is the number of samples \n",
    "    # sigmoid_memory is stored as it is used later on in backpropagation\n",
    "    \n",
    "    H = 1/(1+np.exp(-Z))\n",
    "    sigmoid_memory = Z\n",
    "    \n",
    "    return H, sigmoid_memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigmoid(Z) = (array([[0.5       , 0.73105858],\n",
      "       [0.88079708, 0.95257413],\n",
      "       [0.98201379, 0.99330715],\n",
      "       [0.99752738, 0.99908895]]), array([[0, 1],\n",
      "       [2, 3],\n",
      "       [4, 5],\n",
      "       [6, 7]]))\n"
     ]
    }
   ],
   "source": [
    "Z = np.arange(8).reshape(4,2)\n",
    "print (\"sigmoid(Z) = \" + str(sigmoid(Z)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### relu\n",
    "This is one of the activation functions. It takes the cumulative input to the layer, matrix **Z** as the input. Upon application of the **`relu`** function, matrix **H** which is the output matrix is calculated. Also, **Z** is stored as **relu_memory** which will be later used in backpropagation. You use _[np.maximum()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.maximum.html)_ here in the following way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def relu(Z):\n",
    "    # Z is numpy array of shape (n, m) where n is number of neurons in the layer and m is the number of samples \n",
    "    # relu_memory is stored as it is used later on in backpropagation\n",
    "    \n",
    "    H = np.maximum(0,Z)\n",
    "    \n",
    "    assert(H.shape == Z.shape)\n",
    "    \n",
    "    relu_memory = Z \n",
    "    return H, relu_memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "relu(Z) = (array([[ 1,  3],\n",
      "       [ 0,  0],\n",
      "       [ 0,  7],\n",
      "       [ 9, 18]]), array([[ 1,  3],\n",
      "       [-1, -4],\n",
      "       [-5,  7],\n",
      "       [ 9, 18]]))\n"
     ]
    }
   ],
   "source": [
    "Z = np.array([1, 3, -1, -4, -5, 7, 9, 18]).reshape(4,2)\n",
    "print (\"relu(Z) = \" + str(relu(Z)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### softmax\n",
    "This is the activation of the last layer. It takes the cumulative input to the layer, matrix **Z** as the input. Upon application of the **`softmax`** function, the output matrix **H** is calculated. Also, **Z** is stored as **softmax_memory** which will be later used in backpropagation. You use _[np.exp()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.exp.html)_ and _[np.sum()](https://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.sum.html)_ here in the following way. The exponential gets applied to all the elements of Z."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax(Z):\n",
    "    # Z is numpy array of shape (n, m) where n is number of neurons in the layer and m is the number of samples \n",
    "    # softmax_memory is stored as it is used later on in backpropagation\n",
    "   \n",
    "    Z_exp = np.exp(Z)\n",
    "\n",
    "    Z_sum = np.sum(Z_exp,axis = 0, keepdims = True)\n",
    "    \n",
    "    H = Z_exp/Z_sum  #normalising step\n",
    "    softmax_memory = Z\n",
    "    \n",
    "    return H, softmax_memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "Z = np.array([[11,19,10], [12, 21, 23]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2.68941421e-01 1.19202922e-01 2.26032430e-06]\n",
      " [7.31058579e-01 8.80797078e-01 9.99997740e-01]]\n",
      "[[11 19 10]\n",
      " [12 21 23]]\n"
     ]
    }
   ],
   "source": [
    "#Z = np.array(np.arange(30)).reshape(10,3)\n",
    "H, softmax_memory = softmax(Z)\n",
    "print(H)\n",
    "print(softmax_memory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### initialize_parameters\n",
    "Let's now create a function **`initialize_parameters`** which initializes the weights and biases of the various layers. One way to initialise is to set all the parameters to 0. This is not a considered a good strategy as all the neurons will behave the same way and it'll defeat the purpose of deep networks. Hence, we initialize the weights randomly to very small values but not zeros. The biases are initialized to 0. Note that the **`initialize_parameters`** function initializes the parameters for all the layers in one `for` loop. \n",
    "\n",
    "The inputs to this function is a list named `dimensions`. The length of the list is the number layers in the network + 1 (the plus one is for the input layer, rest are hidden + output). The first element of this list is the dimensionality or length of the input (784 for the MNIST dataset). The rest of the list contains the number of neurons in the corresponding (hidden and output) layers.\n",
    "\n",
    "For example `dimensions = [784, 3, 7, 10]` specifies a network for the MNIST dataset with two hidden layers and a 10-dimensional softmax output.\n",
    "\n",
    "Also, notice that the parameters are returned in a dictionary. This will help you in implementing the feedforward through the layer and the backprop throught the layer at once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_parameters(dimensions):\n",
    "\n",
    "    # dimensions is a list containing the number of neuron in each layer in the network\n",
    "    # It returns parameters which is a python dictionary containing the parameters \"W1\", \"b1\", ..., \"WL\", \"bL\":\n",
    "\n",
    "    np.random.seed(2)\n",
    "    parameters = {}\n",
    "    L = len(dimensions)            # number of layers in the network + 1\n",
    "\n",
    "    for l in range(1, L): \n",
    "        parameters['W' + str(l)] = np.random.randn(dimensions[l], dimensions[l-1]) * 0.1\n",
    "        parameters['b' + str(l)] = np.zeros((dimensions[l], 1)) \n",
    "        \n",
    "        assert(parameters['W' + str(l)].shape == (dimensions[l], dimensions[l-1]))\n",
    "        assert(parameters['b' + str(l)].shape == (dimensions[l], 1))\n",
    "\n",
    "        \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W1 = [[-0.04167578 -0.00562668 -0.21361961 ... -0.06168445  0.03213358\n",
      "  -0.09464469]\n",
      " [-0.05301394 -0.1259207   0.16775441 ... -0.03284246 -0.05623108\n",
      "   0.01179136]\n",
      " [ 0.07386378 -0.15872956  0.01532001 ... -0.08428557  0.10040469\n",
      "   0.00545832]]\n",
      "b1 = [[0.]\n",
      " [0.]\n",
      " [0.]]\n",
      "W2 = [[ 0.06650944 -0.19626047  0.2112715 ]\n",
      " [-0.28074571 -0.13967752  0.02641189]\n",
      " [ 0.10925169  0.06646016  0.08565535]\n",
      " [-0.11058228  0.03715795  0.13440124]\n",
      " [-0.16421272 -0.1153127   0.02013163]\n",
      " [ 0.13985659  0.07228733 -0.10717236]\n",
      " [-0.05673344 -0.03663499 -0.15460347]]\n",
      "b2 = [[0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]]\n"
     ]
    }
   ],
   "source": [
    "dimensions  = [784, 3,7,10]\n",
    "parameters = initialize_parameters(dimensions)\n",
    "print(\"W1 = \" + str(parameters[\"W1\"]))\n",
    "print(\"b1 = \" + str(parameters[\"b1\"]))\n",
    "print(\"W2 = \" + str(parameters[\"W2\"]))\n",
    "print(\"b2 = \" + str(parameters[\"b2\"]))\n",
    "# print(\"W3 = \" + str(parameters[\"W3\"]))\n",
    "# print(\"b3 = \" + str(parameters[\"b3\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### layer_forward\n",
    "\n",
    "The function **`layer_forward`** implements the forward propagation for a certain layer 'l'. It calculates the cumulative input into the layer **Z** and uses it to calculate the output of the layer **H**. It takes **H_prev, W, b and the activation function** as inputs and stores the **linear_memory, activation_memory** in the variable **memory** which will be used later in backpropagation. \n",
    "\n",
    "<br> You have to first calculate the **Z**(using the forward propagation equation), **linear_memory**(H_prev, W, b) and then calculate **H, activation_memory**(Z) by applying activation functions - **`sigmoid`**, **`relu`** and **`softmax`** on **Z**.\n",
    "\n",
    "<br> Note that $$H^{L-1}$$ is referred here as H_prev. You might want to use _[np.dot()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.dot.html)_ to carry out the matrix multiplication."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def layer_forward(H_prev, W, b, activation = 'relu'):\n",
    "\n",
    "    # H_prev is of shape (size of previous layer, number of examples)\n",
    "    # W is weights matrix of shape (size of current layer, size of previous layer)\n",
    "    # b is bias vector of shape (size of the current layer, 1)\n",
    "    # activation is the activation to be used for forward propagation : \"softmax\", \"relu\", \"sigmoid\"\n",
    "\n",
    "    # H is the output of the activation function \n",
    "    # memory is a python dictionary containing \"linear_memory\" and \"activation_memory\"\n",
    "    \n",
    "    if activation == \"sigmoid\":\n",
    "        Z = np.dot(W,H_prev)+b\n",
    "        linear_memory = (H_prev, W, b)\n",
    "        H, activation_memory = sigmoid(Z)\n",
    " \n",
    "    elif activation == \"softmax\":\n",
    "        Z = np.dot(W,H_prev)+b\n",
    "        linear_memory = (H_prev, W, b)\n",
    "        H, activation_memory = softmax(Z)\n",
    "    \n",
    "    elif activation == \"relu\":\n",
    "        Z = np.dot(W,H_prev)+b\n",
    "        linear_memory = (H_prev, W, b)\n",
    "        H, activation_memory = relu(Z)\n",
    "        \n",
    "    assert (H.shape == (W.shape[0], H_prev.shape[1]))\n",
    "    memory = (linear_memory, activation_memory)\n",
    "\n",
    "    return H, memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 1.        , 1.        , 1.        , 1.        ],\n",
       "       [0.99908895, 0.99330715, 0.99999969, 1.        , 0.99987661],\n",
       "       [0.73105858, 0.5       , 0.99330715, 0.9999546 , 0.88079708]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# verify\n",
    "# l-1 has two neurons, l has three, m = 5\n",
    "# H_prev is (l-1, m)\n",
    "# W is (l, l-1)\n",
    "# b is (l, 1)\n",
    "# H should be (l, m)\n",
    "H_prev = np.array([[1,0, 5, 10, 2], [2, 5, 3, 10, 2]])\n",
    "W_sample = np.array([[10, 5], [2, 0], [1, 0]])\n",
    "b_sample = np.array([10, 5, 0]).reshape((3, 1))\n",
    "\n",
    "H = layer_forward(H_prev, W_sample, b_sample, activation=\"sigmoid\")[0]\n",
    "H"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should get:<br>\n",
    "    array([[1.        , 1.        , 1.        , 1.        , 1.        ],<br>\n",
    "      [0.99908895, 0.99330715, 0.99999969, 1.        , 0.99987661],<br>\n",
    "       [0.73105858, 0.5       , 0.99330715, 0.9999546 , 0.88079708]])\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### L_layer_forward\n",
    "**`L_layer_forward`** performs one forward pass through the whole network for all the training samples (note that we are feeding all training examples in one single batch). Use the **`layer_forward`** you have created above here to perform the feedforward for layers 1 to 'L-1' in the for loop with the activation **`relu`**. The last layer having a different activation **`softmax`** is calculated outside the loop. Notice that the **memory** is appended to **memories** for all the layers. These will be used in the backward order during backpropagation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def L_layer_forward(X, parameters):\n",
    "\n",
    "    # X is input data of shape (input size, number of examples)\n",
    "    # parameters is output of initialize_parameters()\n",
    "    \n",
    "    # HL is the last layer's post-activation value\n",
    "    # memories is the list of memory containing (for a relu activation, for example):\n",
    "    # - every memory of relu forward (there are L-1 of them, indexed from 1 to L-1), \n",
    "    # - the memory of softmax forward (there is one, indexed L) \n",
    "\n",
    "    memories = []\n",
    "    H = X\n",
    "    L = len(parameters) // 2                  # number of layers in the neural network\n",
    "    bl=parameters['b'+str(L)]\n",
    "    wl=parameters['W'+str(L)]\n",
    "    # Implement relu layer (L-1) times as the Lth layer is the softmax layer\n",
    "    for l in range(1, L):\n",
    "        wn=parameters['W'+str(l)]\n",
    "        bn=parameters['b'+str(l)]\n",
    "        H_prev=H\n",
    "        H,memory=layer_forward(H_prev,wn,bn,activation=\"relu\")\n",
    "        memories.append(memory)\n",
    "    \n",
    "    # Implement the final softmax layer\n",
    "    # HL here is the final prediction P as specified in the lectures\n",
    "    HL, memory = layer_forward(H,wl,bl,activation=\"softmax\")\n",
    "    \n",
    "    memories.append(memory)\n",
    "\n",
    "    assert(HL.shape == (10, X.shape[1]))\n",
    "            \n",
    "    return HL, memories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(784, 10)\n",
      "[[0.10106734 0.10045152 0.09927757 0.10216656 0.1       ]\n",
      " [0.10567625 0.10230873 0.10170271 0.11250099 0.1       ]\n",
      " [0.09824287 0.0992886  0.09967128 0.09609693 0.1       ]\n",
      " [0.10028288 0.10013048 0.09998149 0.10046076 0.1       ]\n",
      " [0.09883601 0.09953443 0.09931419 0.097355   0.1       ]\n",
      " [0.10668575 0.10270912 0.10180736 0.11483609 0.1       ]\n",
      " [0.09832513 0.09932275 0.09954792 0.09627089 0.1       ]\n",
      " [0.09747092 0.09896735 0.0995387  0.09447277 0.1       ]\n",
      " [0.09489069 0.09788255 0.09929998 0.08915178 0.1       ]\n",
      " [0.09852217 0.09940447 0.09985881 0.09668824 0.1       ]]\n"
     ]
    }
   ],
   "source": [
    "# verify\n",
    "# X is (784, 10)\n",
    "# parameters is a dict\n",
    "# HL should be (10, 10)\n",
    "x_sample = train_set_x[:, 10:20]\n",
    "print(x_sample.shape)\n",
    "HL = L_layer_forward(x_sample, parameters=parameters)[0]\n",
    "print(HL[:, :5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should get:\n",
    "\n",
    "(784, 10)<br>\n",
    "[[0.10106734 0.10045152 0.09927757 0.10216656 0.1       ]<br>\n",
    " [0.10567625 0.10230873 0.10170271 0.11250099 0.1       ]<br>\n",
    " [0.09824287 0.0992886  0.09967128 0.09609693 0.1       ]<br>\n",
    " [0.10028288 0.10013048 0.09998149 0.10046076 0.1       ]<br>\n",
    " [0.09883601 0.09953443 0.09931419 0.097355   0.1       ]<br>\n",
    " [0.10668575 0.10270912 0.10180736 0.11483609 0.1       ]<br>\n",
    " [0.09832513 0.09932275 0.09954792 0.09627089 0.1       ]<br>\n",
    " [0.09747092 0.09896735 0.0995387  0.09447277 0.1       ]<br>\n",
    " [0.09489069 0.09788255 0.09929998 0.08915178 0.1       ]<br>\n",
    " [0.09852217 0.09940447 0.09985881 0.09668824 0.1       ]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss\n",
    "\n",
    "### compute_loss\n",
    "The next step is to compute the loss function after every forward pass to keep checking whether it is decreasing with training.<br> **`compute_loss`** here calculates the cross-entropy loss. You may want to use _[np.log()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.log.html)_, _[np.sum()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.log.html)_, _[np.multiply()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.multiply.html)_ here. Do not forget that it is the average loss across all the data points in the batch. It takes the output of the last layer **HL** and the ground truth label **Y** as input and returns the **loss**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def compute_loss(HL, Y):\n",
    "\n",
    "\n",
    "    # HL is probability matrix of shape (10, number of examples)\n",
    "    # Y is true \"label\" vector shape (10, number of examples)\n",
    "\n",
    "    # loss is the cross-entropy loss\n",
    "\n",
    "    m = Y.shape[1]\n",
    "    loss=-(1/m)*np.sum((Y*np.log(HL)))\n",
    "    loss = np.squeeze(loss)      # To make sure that the loss's shape is what we expect (e.g. this turns [[17]] into 17).\n",
    "    assert(loss.shape == ())\n",
    "    \n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.4359949  0.02592623 0.54966248 0.43532239 0.4203678 ]\n",
      " [0.33033482 0.20464863 0.61927097 0.29965467 0.26682728]\n",
      " [0.62113383 0.52914209 0.13457995 0.51357812 0.18443987]\n",
      " [0.78533515 0.85397529 0.49423684 0.84656149 0.07964548]\n",
      " [0.50524609 0.0652865  0.42812233 0.09653092 0.12715997]\n",
      " [0.59674531 0.226012   0.10694568 0.22030621 0.34982629]\n",
      " [0.46778748 0.20174323 0.64040673 0.48306984 0.50523672]\n",
      " [0.38689265 0.79363745 0.58000418 0.1622986  0.70075235]\n",
      " [0.96455108 0.50000836 0.88952006 0.34161365 0.56714413]\n",
      " [0.42754596 0.43674726 0.77655918 0.53560417 0.95374223]]\n",
      "[[0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 1.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [1. 0. 1. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 1. 0. 0. 0.]\n",
      " [0. 0. 0. 1. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n",
      "0.8964600261334037\n"
     ]
    }
   ],
   "source": [
    "# sample\n",
    "# HL is (10, 5), Y is (10, 5)\n",
    "np.random.seed(2)\n",
    "HL_sample = np.random.rand(10,5)\n",
    "Y_sample = train_set_y[:, 10:15]\n",
    "print(HL_sample)\n",
    "print(Y_sample)\n",
    "\n",
    "print(compute_loss(HL_sample, Y_sample))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should get:<br>\n",
    "    \n",
    "[[0.4359949  0.02592623 0.54966248 0.43532239 0.4203678 ]<br>\n",
    " [0.33033482 0.20464863 0.61927097 0.29965467 0.26682728]<br>\n",
    " [0.62113383 0.52914209 0.13457995 0.51357812 0.18443987]<br>\n",
    " [0.78533515 0.85397529 0.49423684 0.84656149 0.07964548]<br>\n",
    " [0.50524609 0.0652865  0.42812233 0.09653092 0.12715997]<br>\n",
    " [0.59674531 0.226012   0.10694568 0.22030621 0.34982629]<br>\n",
    " [0.46778748 0.20174323 0.64040673 0.48306984 0.50523672]<br>\n",
    " [0.38689265 0.79363745 0.58000418 0.1622986  0.70075235]<br>\n",
    " [0.96455108 0.50000836 0.88952006 0.34161365 0.56714413]<br>\n",
    " [0.42754596 0.43674726 0.77655918 0.53560417 0.95374223]]<br>\n",
    "[[0. 0. 0. 0. 0.]<br>\n",
    " [0. 0. 0. 0. 1.]<br>\n",
    " [0. 0. 0. 0. 0.]<br>\n",
    " [1. 0. 1. 0. 0.]<br>\n",
    " [0. 0. 0. 0. 0.]<br>\n",
    " [0. 1. 0. 0. 0.]<br>\n",
    " [0. 0. 0. 1. 0.]<br>\n",
    " [0. 0. 0. 0. 0.]<br>\n",
    " [0. 0. 0. 0. 0.]<br>\n",
    " [0. 0. 0. 0. 0.]]<br>\n",
    "0.8964600261334037"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Backpropagation\n",
    "Let's now get to the next step - backpropagation. Let's start with sigmoid_backward.\n",
    "\n",
    "### sigmoid-backward\n",
    "You might remember that we had created **`sigmoid`** function that calculated the activation for forward propagation. Now, we need the activation backward, which helps in calculating **dZ** from **dH**. Notice that it takes input **dH** and **sigmoid_memory** as input. **sigmoid_memory** is the **Z** which we had calculated during forward propagation. You use _[np.exp()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.exp.html)_ here the following way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid_backward(dH, sigmoid_memory):\n",
    "    \n",
    "    # Implement the backpropagation of a sigmoid function\n",
    "    # dH is gradient of the sigmoid activated activation of shape same as H or Z in the same layer    \n",
    "    # sigmoid_memory is the memory stored in the sigmoid(Z) calculation\n",
    "    \n",
    "    Z = sigmoid_memory\n",
    "    \n",
    "    H = 1/(1+np.exp(-Z))\n",
    "    dZ = dH * H * (1-H)\n",
    "    \n",
    "    assert (dZ.shape == Z.shape)\n",
    "    \n",
    "    return dZ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### relu-backward\n",
    "You might remember that we had created **`relu`** function that calculated the activation for forward propagation. Now, we need the activation backward, which helps in calculating **dZ** from **dH**. Notice that it takes input **dH** and **relu_memory** as input. **relu_memory** is the **Z** which we calculated uring forward propagation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def relu_backward(dH, relu_memory):\n",
    "    \n",
    "    # Implement the backpropagation of a relu function\n",
    "    # dH is gradient of the relu activated activation of shape same as H or Z in the same layer    \n",
    "    # relu_memory is the memory stored in the sigmoid(Z) calculation\n",
    "    \n",
    "    Z = relu_memory\n",
    "    dZ = np.array(dH, copy=True) # dZ will be the same as dA wherever the elements of A weren't 0\n",
    "    \n",
    "    dZ[Z <= 0] = 0\n",
    "    \n",
    "    assert (dZ.shape == Z.shape)\n",
    "    \n",
    "    return dZ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### layer_backward\n",
    "\n",
    "**`layer_backward`** is a complimentary function of **`layer_forward`**. Like **`layer_forward`** calculates **H** using **W**, **H_prev** and **b**, **`layer_backward`** uses **dH** to calculate **dW**, **dH_prev** and **db**. You have already studied the formulae in backpropogation. To calculate **dZ**, use the **`sigmoid_backward`** and **`relu_backward`** function. You might need to use _[np.dot()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.dot.html)_, _[np.sum()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.sum.html)_ for the rest. Remember to choose the axis correctly in db. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def layer_backward(dH, memory, activation = 'relu'):\n",
    "    \n",
    "    \n",
    "    # takes dH and the memory calculated in layer_forward and activation as input to calculate the dH_prev, dW, db\n",
    "    # performs the backprop depending upon the activation function\n",
    "    \n",
    "\n",
    "    linear_memory, activation_memory = memory\n",
    "    \n",
    "    if activation == \"relu\":\n",
    "        dZ = relu_backward(dH,activation_memory)\n",
    "        H_prev, W, b = linear_memory\n",
    "        m = H_prev.shape[1]\n",
    "        \n",
    "    elif activation == \"sigmoid\":\n",
    "        dZ = sigmoid_backward(dH,activation_memory)\n",
    "        H_prev, W, b = linear_memory\n",
    "        m = H_prev.shape[1]\n",
    "        \n",
    "    dW =(1./m)*np.dot(dZ,H_prev.T)\n",
    "    db =(1./m)*np.sum(dZ,axis=1,keepdims=True)\n",
    "    dH_prev = np.dot(W.T,dZ)\n",
    "    \n",
    "    return dH_prev, dW, db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dH_prev is \n",
      " [[5.6417525  0.66855959 6.86974666 5.46611139 4.92177244]\n",
      " [2.17997451 0.12963116 2.74831239 2.17661196 2.10183901]]\n",
      "dW is \n",
      " [[1.67565336 1.56891359]\n",
      " [1.39137819 1.4143854 ]\n",
      " [1.3597389  1.43013369]]\n",
      "db is \n",
      " [[0.37345476]\n",
      " [0.34414727]\n",
      " [0.29074635]]\n"
     ]
    }
   ],
   "source": [
    "# verify\n",
    "# l-1 has two neurons, l has three, m = 5\n",
    "# H_prev is (l-1, m)\n",
    "# W is (l, l-1)\n",
    "# b is (l, 1)\n",
    "# H should be (l, m)\n",
    "H_prev = np.array([[1,0, 5, 10, 2], [2, 5, 3, 10, 2]])\n",
    "W_sample = np.array([[10, 5], [2, 0], [1, 0]])\n",
    "b_sample = np.array([10, 5, 0]).reshape((3, 1))\n",
    "\n",
    "H, memory = layer_forward(H_prev, W_sample, b_sample, activation=\"relu\")\n",
    "np.random.seed(2)\n",
    "dH = np.random.rand(3,5)\n",
    "dH_prev, dW, db = layer_backward(dH, memory, activation = 'relu')\n",
    "print('dH_prev is \\n' , dH_prev)\n",
    "print('dW is \\n' ,dW)\n",
    "print('db is \\n', db)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should get:<br>\n",
    "dH_prev is <br>\n",
    " [[5.6417525  0.66855959 6.86974666 5.46611139 4.92177244]<br>\n",
    " [2.17997451 0.12963116 2.74831239 2.17661196 2.10183901]]<br>\n",
    "dW is <br>\n",
    " [[1.67565336 1.56891359]<br>\n",
    " [1.39137819 1.4143854 ]<br>\n",
    " [1.3597389  1.43013369]]<br>\n",
    "db is <br>\n",
    " [[0.37345476]<br>\n",
    " [0.34414727]<br>\n",
    " [0.29074635]]<br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### L_layer_backward\n",
    "\n",
    "**`L_layer_backward`** performs backpropagation for the whole network. Recall that the backpropagation for the last layer, i.e. the softmax layer, is different from the rest, hence it is outside the reversed `for` loop. You need to use the function **`layer_backward`** here in the loop with the activation function as **`relu`**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def L_layer_backward(HL, Y, memories):\n",
    "    \n",
    "    # Takes the predicted value HL and the true target value Y and the \n",
    "    # memories calculated by L_layer_forward as input\n",
    "    \n",
    "    # returns the gradients calulated for all the layers as a dict\n",
    "\n",
    "    gradients = {}\n",
    "    L = len(memories) # the number of layers\n",
    "    m = HL.shape[1]\n",
    "    Y = Y.reshape(HL.shape) # after this line, Y is the same shape as AL\n",
    "    # Perform the backprop for the last layer that is the softmax layer\n",
    "    current_memory = memories[L-1]\n",
    "    linear_memory, activation_memory = current_memory\n",
    "    dZ = HL - Y\n",
    "    H_prev, W, b = linear_memory\n",
    "    gradients[\"dW\" + str(L)] = (1./m)*(np.dot(dZ,H_prev.T))\n",
    "    gradients[\"db\" + str(L)] = (1./m)*np.sum(dZ,axis=1,keepdims=True) \n",
    "    gradients[\"dH\" + str(L-1)] =np.dot(W.T,dZ)\n",
    "    # Perform the backpropagation l-1 times\n",
    "    for l in reversed(range(L-1)):\n",
    "        # Lth layer gradients: \"gradients[\"dH\" + str(l + 1)] \", gradients[\"dW\" + str(l + 2)] , gradients[\"db\" + str(l + 2)]\n",
    "        current_memory = memories[l]\n",
    "        \n",
    "        dH_prev_temp, dW_temp, db_temp = layer_backward(gradients[\"dH\"+str(l+1)],current_memory,\"relu\")\n",
    "        gradients[\"dH\" + str(l)] = dH_prev_temp\n",
    "        gradients[\"dW\" + str(l + 1)] = dW_temp\n",
    "        gradients[\"db\" + str(l + 1)] = db_temp\n",
    "\n",
    "\n",
    "    return gradients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dW3 is \n",
      " [[ 0.02003701  0.0019043   0.01011729  0.0145757   0.00146444  0.00059863\n",
      "   0.        ]\n",
      " [ 0.02154547  0.00203519  0.01085648  0.01567075  0.00156469  0.00060533\n",
      "   0.        ]\n",
      " [-0.01718407 -0.00273711 -0.00499101 -0.00912135 -0.00207365  0.00059996\n",
      "   0.        ]\n",
      " [-0.01141498 -0.00158622 -0.00607049 -0.00924709 -0.00119619  0.00060381\n",
      "   0.        ]\n",
      " [ 0.01943173  0.0018421   0.00984543  0.01416368  0.00141676  0.00059682\n",
      "   0.        ]\n",
      " [ 0.01045447  0.00063974  0.00637621  0.00863306  0.00050118  0.00060441\n",
      "   0.        ]\n",
      " [-0.06338911 -0.00747251 -0.0242169  -0.03835708 -0.00581131  0.0006034\n",
      "   0.        ]\n",
      " [ 0.01911373  0.001805    0.00703101  0.0120636   0.00138836 -0.00140535\n",
      "   0.        ]\n",
      " [-0.01801603  0.0017357  -0.01489228 -0.02026076  0.00133528  0.00060264\n",
      "   0.        ]\n",
      " [ 0.0194218   0.00183381  0.00594427  0.01187949  0.00141043 -0.00340965\n",
      "   0.        ]]\n",
      "db3 is \n",
      " [[ 0.10031756]\n",
      " [ 0.00460183]\n",
      " [-0.00142942]\n",
      " [-0.0997827 ]\n",
      " [ 0.09872663]\n",
      " [ 0.00536378]\n",
      " [-0.10124784]\n",
      " [-0.00191121]\n",
      " [-0.00359044]\n",
      " [-0.00104818]]\n",
      "dW2 is \n",
      " [[ 4.94428956e-05  1.13215514e-02  5.44180380e-02]\n",
      " [-4.81267081e-05 -2.96999448e-05 -1.81899582e-02]\n",
      " [ 5.63424333e-05  4.77190073e-03  4.04810232e-02]\n",
      " [ 1.49767478e-04 -1.89780927e-03 -7.91231369e-03]\n",
      " [ 1.97866094e-04  1.22107085e-04  2.64140566e-02]\n",
      " [ 0.00000000e+00 -3.75805770e-04  1.63906102e-05]\n",
      " [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]]\n",
      "db2 is \n",
      " [[ 0.013979  ]\n",
      " [-0.01329383]\n",
      " [ 0.01275707]\n",
      " [-0.01052957]\n",
      " [ 0.03179224]\n",
      " [-0.00039877]\n",
      " [ 0.        ]]\n"
     ]
    }
   ],
   "source": [
    "# verify\n",
    "# X is (784, 10)\n",
    "# parameters is a dict\n",
    "# HL should be (10, 10)\n",
    "x_sample = train_set_x[:, 10:20]\n",
    "y_sample = train_set_y[:, 10:20]\n",
    "\n",
    "HL, memories = L_layer_forward(x_sample, parameters=parameters)\n",
    "gradients  = L_layer_backward(HL, y_sample, memories)\n",
    "print('dW3 is \\n', gradients['dW3'])\n",
    "print('db3 is \\n', gradients['db3'])\n",
    "print('dW2 is \\n', gradients['dW2'])\n",
    "print('db2 is \\n', gradients['db2'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should get:<br>\n",
    "\n",
    "dW3 is <br>\n",
    " [[ 0.02003701  0.0019043   0.01011729  0.0145757   0.00146444  0.00059863  0.        ]<br>\n",
    " [ 0.02154547  0.00203519  0.01085648  0.01567075  0.00156469  0.00060533   0.        ]<br>\n",
    " [-0.01718407 -0.00273711 -0.00499101 -0.00912135 -0.00207365  0.00059996   0.        ]<br>\n",
    " [-0.01141498 -0.00158622 -0.00607049 -0.00924709 -0.00119619  0.00060381   0.        ]<br>\n",
    " [ 0.01943173  0.0018421   0.00984543  0.01416368  0.00141676  0.00059682   0.        ]<br>\n",
    " [ 0.01045447  0.00063974  0.00637621  0.00863306  0.00050118  0.00060441   0.        ]<br>\n",
    " [-0.06338911 -0.00747251 -0.0242169  -0.03835708 -0.00581131  0.0006034   0.        ]<br>\n",
    " [ 0.01911373  0.001805    0.00703101  0.0120636   0.00138836 -0.00140535   0.        ]<br>\n",
    " [-0.01801603  0.0017357  -0.01489228 -0.02026076  0.00133528  0.00060264   0.        ]<br>\n",
    " [ 0.0194218   0.00183381  0.00594427  0.01187949  0.00141043 -0.00340965    0.        ]]<br>\n",
    "db3 is <br>\n",
    " [[ 0.10031756]<br>\n",
    " [ 0.00460183]<br>\n",
    " [-0.00142942]<br>\n",
    " [-0.0997827 ]<br>\n",
    " [ 0.09872663]<br>\n",
    " [ 0.00536378]<br>\n",
    " [-0.10124784]<br>\n",
    " [-0.00191121]<br>\n",
    " [-0.00359044]<br>\n",
    " [-0.00104818]]<br>\n",
    "dW2 is <br>\n",
    " [[ 4.94428956e-05  1.13215514e-02  5.44180380e-02]<br>\n",
    " [-4.81267081e-05 -2.96999448e-05 -1.81899582e-02]<br>\n",
    " [ 5.63424333e-05  4.77190073e-03  4.04810232e-02]<br>\n",
    " [ 1.49767478e-04 -1.89780927e-03 -7.91231369e-03]<br>\n",
    " [ 1.97866094e-04  1.22107085e-04  2.64140566e-02]<br>\n",
    " [ 0.00000000e+00 -3.75805770e-04  1.63906102e-05]<br>\n",
    " [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]]<br>\n",
    "db2 is <br>\n",
    " [[ 0.013979  ]<br>\n",
    " [-0.01329383]<br>\n",
    " [ 0.01275707]<br>\n",
    " [-0.01052957]<br>\n",
    " [ 0.03179224]<br>\n",
    " [-0.00039877]<br>\n",
    " [ 0.        ]]<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parameter Updates\n",
    "\n",
    "Now that we have calculated the gradients. let's do the last step which is updating the weights and biases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def update_parameters(parameters, gradients, learning_rate):\n",
    "\n",
    "    # parameters is the python dictionary containing the parameters W and b for all the layers\n",
    "    # gradients is the python dictionary containing your gradients, output of L_model_backward\n",
    "    \n",
    "    # returns updated weights after applying the gradient descent update\n",
    "\n",
    "    \n",
    "    L = len(parameters) // 2 # number of layers in the neural network\n",
    "\n",
    "    for l in range(L):\n",
    "        parameters[\"W\" + str(l+1)] = parameters[\"W\" + str(l+1)] - learning_rate * gradients[\"dW\"+ str(l+1)]\n",
    "        parameters[\"b\" + str(l+1)] = parameters[\"b\" + str(l+1)] - learning_rate * gradients[\"db\"+ str(l+1)]\n",
    "\n",
    "        \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having defined the bits and pieces of the feedforward and the backpropagation, let's now combine all that to form a model. The list `dimensions` has the number of neurons in each layer specified in it. For a neural network with 1 hidden layer with 45 neurons, you would specify the dimensions as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "dimensions = [784,300, 10] #  three-layer model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model\n",
    "\n",
    "### L_layer_model\n",
    "\n",
    "This is a composite function which takes the training data as input **X**, ground truth label **Y**, the **dimensions** as stated above, **learning_rate**, the number of iterations **num_iterations** and if you want to print the loss, **print_loss**. You need to use the final functions we have written for feedforward, computing the loss, backpropagation and updating the parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def L_layer_model(X, Y, dimensions, learning_rate = 0.1, num_iterations = 3000, print_loss=False):\n",
    "    \n",
    "    # X and Y are the input training datasets\n",
    "    # learning_rate, num_iterations are gradient descent optimization parameters\n",
    "    # returns updated parameters\n",
    "\n",
    "    np.random.seed(2)\n",
    "    losses = []                         # keep track of loss\n",
    "    \n",
    "    # Parameters initialization\n",
    "    parameters = initialize_parameters(dimensions)\n",
    " \n",
    "    for i in range(0, num_iterations):\n",
    "\n",
    "        # Forward propagation\n",
    "        HL, memories = L_layer_forward(X,parameters)\n",
    "        \n",
    "        # Compute loss\n",
    "        loss = compute_loss(HL,Y)\n",
    "    \n",
    "        # Backward propagation\n",
    "        gradients = L_layer_backward(HL,Y, memories)\n",
    " \n",
    "        # Update parameters.\n",
    "        parameters = update_parameters(parameters, gradients, learning_rate)\n",
    "                \n",
    "        # Printing the loss every 100 training example\n",
    "        if print_loss and i % 100 == 0:\n",
    "            print (\"Loss after iteration %i: %f\" %(i, loss))\n",
    "            losses.append(loss)\n",
    "            \n",
    "    # plotting the loss\n",
    "    plt.plot(np.squeeze(losses))\n",
    "    plt.ylabel('loss')\n",
    "    plt.xlabel('iterations (per tens)')\n",
    "    plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "    plt.show()\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since, it'll take a lot of time to train the model on 50,000 data points, we take a subset of 5,000 images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(784, 5000)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_set_x_new = train_set_x[:,0:5000]\n",
    "train_set_y_new = train_set_y[:,0:5000]\n",
    "train_set_x_new.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's call the function L_layer_model on the dataset we have created.This will take 10-20 mins to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss after iteration 0: 2.428008\n",
      "Loss after iteration 100: 0.369540\n",
      "Loss after iteration 200: 0.271613\n",
      "Loss after iteration 300: 0.223796\n",
      "Loss after iteration 400: 0.191662\n",
      "Loss after iteration 500: 0.167319\n",
      "Loss after iteration 600: 0.147755\n",
      "Loss after iteration 700: 0.131506\n",
      "Loss after iteration 800: 0.117633\n",
      "Loss after iteration 900: 0.105693\n",
      "Loss after iteration 1000: 0.095314\n",
      "Loss after iteration 1100: 0.086261\n",
      "Loss after iteration 1200: 0.078334\n",
      "Loss after iteration 1300: 0.071354\n",
      "Loss after iteration 1400: 0.065172\n",
      "Loss after iteration 1500: 0.059680\n",
      "Loss after iteration 1600: 0.054792\n",
      "Loss after iteration 1700: 0.050430\n",
      "Loss after iteration 1800: 0.046526\n",
      "Loss after iteration 1900: 0.043029\n",
      "Loss after iteration 2000: 0.039887\n",
      "Loss after iteration 2100: 0.037059\n",
      "Loss after iteration 2200: 0.034515\n",
      "Loss after iteration 2300: 0.032221\n",
      "Loss after iteration 2400: 0.030145\n",
      "Loss after iteration 2500: 0.028263\n",
      "Loss after iteration 2600: 0.026555\n",
      "Loss after iteration 2700: 0.024998\n",
      "Loss after iteration 2800: 0.023577\n",
      "Loss after iteration 2900: 0.022276\n",
      "Loss after iteration 3000: 0.021081\n",
      "Loss after iteration 3100: 0.019979\n",
      "Loss after iteration 3200: 0.018964\n",
      "Loss after iteration 3300: 0.018026\n",
      "Loss after iteration 3400: 0.017160\n",
      "Loss after iteration 3500: 0.016358\n",
      "Loss after iteration 3600: 0.015617\n",
      "Loss after iteration 3700: 0.014928\n",
      "Loss after iteration 3800: 0.014289\n",
      "Loss after iteration 3900: 0.013696\n",
      "Loss after iteration 4000: 0.013143\n",
      "Loss after iteration 4100: 0.012628\n",
      "Loss after iteration 4200: 0.012147\n",
      "Loss after iteration 4300: 0.011696\n",
      "Loss after iteration 4400: 0.011274\n",
      "Loss after iteration 4500: 0.010878\n",
      "Loss after iteration 4600: 0.010505\n",
      "Loss after iteration 4700: 0.010154\n",
      "Loss after iteration 4800: 0.009823\n",
      "Loss after iteration 4900: 0.009511\n",
      "Loss after iteration 5000: 0.009215\n",
      "Loss after iteration 5100: 0.008935\n",
      "Loss after iteration 5200: 0.008670\n",
      "Loss after iteration 5300: 0.008418\n",
      "Loss after iteration 5400: 0.008179\n",
      "Loss after iteration 5500: 0.007952\n",
      "Loss after iteration 5600: 0.007735\n",
      "Loss after iteration 5700: 0.007529\n",
      "Loss after iteration 5800: 0.007332\n",
      "Loss after iteration 5900: 0.007144\n",
      "Loss after iteration 6000: 0.006964\n",
      "Loss after iteration 6100: 0.006793\n",
      "Loss after iteration 6200: 0.006628\n",
      "Loss after iteration 6300: 0.006471\n",
      "Loss after iteration 6400: 0.006320\n",
      "Loss after iteration 6500: 0.006175\n",
      "Loss after iteration 6600: 0.006037\n",
      "Loss after iteration 6700: 0.005903\n",
      "Loss after iteration 6800: 0.005775\n",
      "Loss after iteration 6900: 0.005652\n",
      "Loss after iteration 7000: 0.005533\n",
      "Loss after iteration 7100: 0.005419\n",
      "Loss after iteration 7200: 0.005309\n",
      "Loss after iteration 7300: 0.005202\n",
      "Loss after iteration 7400: 0.005100\n",
      "Loss after iteration 7500: 0.005001\n",
      "Loss after iteration 7600: 0.004906\n",
      "Loss after iteration 7700: 0.004814\n",
      "Loss after iteration 7800: 0.004725\n",
      "Loss after iteration 7900: 0.004638\n",
      "Loss after iteration 8000: 0.004555\n",
      "Loss after iteration 8100: 0.004474\n",
      "Loss after iteration 8200: 0.004396\n",
      "Loss after iteration 8300: 0.004320\n",
      "Loss after iteration 8400: 0.004247\n",
      "Loss after iteration 8500: 0.004176\n",
      "Loss after iteration 8600: 0.004107\n",
      "Loss after iteration 8700: 0.004040\n",
      "Loss after iteration 8800: 0.003975\n",
      "Loss after iteration 8900: 0.003911\n",
      "Loss after iteration 9000: 0.003850\n",
      "Loss after iteration 9100: 0.003790\n",
      "Loss after iteration 9200: 0.003733\n",
      "Loss after iteration 9300: 0.003676\n",
      "Loss after iteration 9400: 0.003621\n",
      "Loss after iteration 9500: 0.003568\n",
      "Loss after iteration 9600: 0.003516\n",
      "Loss after iteration 9700: 0.003465\n",
      "Loss after iteration 9800: 0.003416\n",
      "Loss after iteration 9900: 0.003368\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "parameters = L_layer_model(train_set_x_new, train_set_y_new, dimensions, num_iterations = 10000, print_loss = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(X, y, parameters):\n",
    "    \n",
    "    # Performs forward propogation using the trained parameters and calculates the accuracy\n",
    "    \n",
    "    m = X.shape[1]\n",
    "    n = len(parameters) // 2 # number of layers in the neural network\n",
    "    \n",
    "    # Forward propagation\n",
    "    probas, caches = L_layer_forward(X, parameters)\n",
    "    \n",
    "    p = np.argmax(probas, axis = 0)\n",
    "    act = np.argmax(y, axis = 0)\n",
    "\n",
    "    print(\"Accuracy: \"  + str(round(np.sum((p == act)/m),3)))\n",
    "        \n",
    "    return p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see the accuray we get on the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 1.0\n"
     ]
    }
   ],
   "source": [
    "pred_train = predict(train_set_x_new, train_set_y_new, parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We get ~ 100% accuracy on the training data. Let's see the accuray on the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.938\n"
     ]
    }
   ],
   "source": [
    "pred_test = predict(test_set_x, test_set_y, parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is ~94%. You can train the model even longer and get better result. You can also try to change the network structure. \n",
    "<br>Below, you can see which all numbers are incorrectly identified by the neural network by changing the index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x24bb5c7e8c8>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "index  = 3474\n",
    "k = test_set_x[:,index]\n",
    "k = k.reshape((28, 28))\n",
    "plt.title('Label is {label}'.format(label=(pred_test[index], np.argmax(test_set_y, axis = 0)[index])))\n",
    "plt.imshow(k, cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}