exercise4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming Exercise 4:  Neural Networks Learning\n",
    "\n",
    "## Introduction\n",
    "\n",
    "In this exercise, you will implement the backpropagation algorithm for neural networks and apply it to the task of hand-written digit recognition. Before starting on the programming exercise, we strongly recommend watching the video lectures and completing the review questions for the associated topics.\n",
    "\n",
    "\n",
    "All the information you need for solving this assignment is in this notebook, and all the code you will be implementing will take place within this notebook. The assignment can be promptly submitted to the coursera grader directly from this notebook (code and instructions are included below).\n",
    "\n",
    "Before we begin with the exercises, we need to import all libraries required for this programming exercise. Throughout the course, we will be using [`numpy`](http://www.numpy.org/) for all arrays and matrix operations, [`matplotlib`](https://matplotlib.org/) for plotting, and [`scipy`](https://docs.scipy.org/doc/scipy/reference/) for scientific and numerical computation functions and tools. You can find instructions on how to install required libraries in the README file in the [github repository](https://github.com/dibgerge/ml-coursera-python-assignments)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# used for manipulating directory paths\n",
    "import os\n",
    "\n",
    "# Scientific and vector computation for python\n",
    "import numpy as np\n",
    "\n",
    "# Plotting library\n",
    "from matplotlib import pyplot\n",
    "\n",
    "# Optimization module in scipy\n",
    "from scipy import optimize\n",
    "\n",
    "# will be used to load MATLAB mat datafile format\n",
    "from scipy.io import loadmat\n",
    "\n",
    "# library written for this exercise providing additional functions for assignment submission, and others\n",
    "import utils\n",
    "\n",
    "# define the submission/grader object for this exercise\n",
    "grader = utils.Grader()\n",
    "\n",
    "# tells matplotlib to embed plots within the notebook\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Submission and Grading\n",
    "\n",
    "\n",
    "After completing each part of the assignment, be sure to submit your solutions to the grader. The following is a breakdown of how each part of this exercise is scored.\n",
    "\n",
    "\n",
    "| Section | Part                                             | Submission function | Points \n",
    "| :-      |:-                                                | :-                  | :-:    \n",
    "| 1       | [Feedforward and Cost Function](#section1)                    | [`nnCostFunction`](#nnCostFunction)   | 30     \n",
    "| 2       | [Regularized Cost Function](#section2)                        | [`nnCostFunction`](#nnCostFunction)   | 15     \n",
    "| 3       | [Sigmoid Gradient](#section3)                                 | [`sigmoidGradient`](#sigmoidGradient) | 5      \n",
    "| 4       | [Neural Net Gradient Function (Backpropagation)](#section4)   | [`nnCostFunction`](#nnCostFunction)   | 40     \n",
    "| 5       | [Regularized Gradient](#section5)                             | [`nnCostFunction`](#nnCostFunction)   |10     \n",
    "|         | Total Points                                     |    | 100    \n",
    "\n",
    "\n",
    "You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "At the end of each section in this notebook, we have a cell which contains code for submitting the solutions thus far to the grader. Execute the cell to see your score up to the current section. For all your work to be submitted properly, you must execute those cells at least once.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural Networks\n",
    "\n",
    "In the previous exercise, you implemented feedforward propagation for neural networks and used it to predict handwritten digits with the weights we provided. In this exercise, you will implement the backpropagation algorithm to learn the parameters for the neural network.\n",
    "\n",
    "We start the exercise by first loading the dataset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  training data stored in arrays X, y\n",
    "data = loadmat(os.path.join('Data', 'ex4data1.mat'))\n",
    "X, y = data['X'], data['y'].ravel()\n",
    "\n",
    "# set the zero digit to 0, rather than its mapped 10 in this dataset\n",
    "# This is an artifact due to the fact that this dataset was used in \n",
    "# MATLAB where there is no index 0\n",
    "y[y == 10] = 0\n",
    "\n",
    "# Number of training examples\n",
    "m = y.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Visualizing the data\n",
    "\n",
    "You will begin by visualizing a subset of the training set, using the function `displayData`, which is the same function we used in Exercise 3. It is provided in the `utils.py` file for this assignment as well. The dataset is also the same one you used in the previous exercise.\n",
    "\n",
    "There are 5000 training examples in `ex4data1.mat`, where each training example is a 20 pixel by 20 pixel grayscale image of the digit. Each pixel is represented by a floating point number indicating the grayscale intensity at that location. The 20 by 20 grid of pixels is “unrolled” into a 400-dimensional vector. Each\n",
    "of these training examples becomes a single row in our data matrix $X$. This gives us a 5000 by 400 matrix $X$ where every row is a training example for a handwritten digit image.\n",
    "\n",
    "$$ X = \\begin{bmatrix} - \\left(x^{(1)} \\right)^T - \\\\\n",
    "- \\left(x^{(2)} \\right)^T - \\\\\n",
    "\\vdots \\\\\n",
    "- \\left(x^{(m)} \\right)^T - \\\\\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "The second part of the training set is a 5000-dimensional vector `y` that contains labels for the training set. \n",
    "The following cell randomly selects 100 images from the dataset and plots them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 100 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Randomly select 100 data points to display\n",
    "rand_indices = np.random.choice(m, 100, replace=False)\n",
    "sel = X[rand_indices, :]\n",
    "\n",
    "utils.displayData(sel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Model representation\n",
    "\n",
    "Our neural network is shown in the following figure.\n",
    "\n",
    "![](Figures/neural_network.png)\n",
    "\n",
    "It has 3 layers - an input layer, a hidden layer and an output layer. Recall that our inputs are pixel values\n",
    "of digit images. Since the images are of size $20 \\times 20$, this gives us 400 input layer units (not counting the extra bias unit which always outputs +1). The training data was loaded into the variables `X` and `y` above.\n",
    "\n",
    "You have been provided with a set of network parameters ($\\Theta^{(1)}, \\Theta^{(2)}$) already trained by us. These are stored in `ex4weights.mat` and will be loaded in the next cell of this notebook into `Theta1` and `Theta2`. The parameters have dimensions that are sized for a neural network with 25 units in the second layer and 10 output units (corresponding to the 10 digit classes)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup the parameters you will use for this exercise\n",
    "input_layer_size  = 400  # 20x20 Input Images of Digits\n",
    "hidden_layer_size = 25   # 25 hidden units\n",
    "num_labels = 10          # 10 labels, from 0 to 9\n",
    "\n",
    "# Load the weights into variables Theta1 and Theta2\n",
    "weights = loadmat(os.path.join('Data', 'ex4weights.mat'))\n",
    "\n",
    "# Theta1 has size 25 x 401\n",
    "# Theta2 has size 10 x 26\n",
    "Theta1, Theta2 = weights['Theta1'], weights['Theta2']\n",
    "\n",
    "# swap first and last columns of Theta2, due to legacy from MATLAB indexing, \n",
    "# since the weight file ex3weights.mat was saved based on MATLAB indexing\n",
    "Theta2 = np.roll(Theta2, 1, axis=0)\n",
    "\n",
    "# Unroll parameters \n",
    "nn_params = np.concatenate([Theta1.ravel(), Theta2.ravel()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section1\"></a>\n",
    "### 1.3 Feedforward and cost function\n",
    "\n",
    "Now you will implement the cost function and gradient for the neural network. First, complete the code for the function `nnCostFunction` in the next cell to return the cost.\n",
    "\n",
    "Recall that the cost function for the neural network (without regularization) is:\n",
    "\n",
    "$$ J(\\theta) = \\frac{1}{m} \\sum_{i=1}^{m}\\sum_{k=1}^{K} \\left[ - y_k^{(i)} \\log \\left( \\left( h_\\theta \\left( x^{(i)} \\right) \\right)_k \\right) - \\left( 1 - y_k^{(i)} \\right) \\log \\left( 1 - \\left( h_\\theta \\left( x^{(i)} \\right) \\right)_k \\right) \\right]$$\n",
    "\n",
    "where $h_\\theta \\left( x^{(i)} \\right)$ is computed as shown in the neural network figure above, and K = 10 is the total number of possible labels. Note that $h_\\theta(x^{(i)})_k = a_k^{(3)}$ is the activation (output\n",
    "value) of the $k^{th}$ output unit. Also, recall that whereas the original labels (in the variable y) were 0, 1, ..., 9, for the purpose of training a neural network, we need to encode the labels as vectors containing only values 0 or 1, so that\n",
    "\n",
    "$$ y = \n",
    "\\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\\\vdots \\\\ 0 \\end{bmatrix}, \\quad\n",
    "\\begin{bmatrix} 0 \\\\ 1 \\\\ 0 \\\\ \\vdots \\\\ 0 \\end{bmatrix}, \\quad \\cdots  \\quad \\text{or} \\qquad\n",
    "\\begin{bmatrix} 0 \\\\ 0 \\\\ 0 \\\\ \\vdots \\\\ 1 \\end{bmatrix}.\n",
    "$$\n",
    "\n",
    "For example, if $x^{(i)}$ is an image of the digit 5, then the corresponding $y^{(i)}$ (that you should use with the cost function) should be a 10-dimensional vector with $y_5 = 1$, and the other elements equal to 0.\n",
    "\n",
    "You should implement the feedforward computation that computes $h_\\theta(x^{(i)})$ for every example $i$ and sum the cost over all examples. **Your code should also work for a dataset of any size, with any number of labels** (you can assume that there are always at least $K \\ge 3$ labels).\n",
    "\n",
    "<div class=\"alert alert-box alert-warning\">\n",
    "**Implementation Note:** The matrix $X$ contains the examples in rows (i.e., X[i,:] is the i-th training example $x^{(i)}$, expressed as a $n \\times 1$ vector.) When you complete the code in `nnCostFunction`, you will need to add the column of 1’s to the X matrix. The parameters for each unit in the neural network is represented in Theta1 and Theta2 as one row. Specifically, the first row of Theta1 corresponds to the first hidden unit in the second layer. You can use a for-loop over the examples to compute the cost.\n",
    "</div>\n",
    "<a id=\"nnCostFunction\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nnCostFunction(nn_params,\n",
    "                   input_layer_size,\n",
    "                   hidden_layer_size,\n",
    "                   num_labels,\n",
    "                   X, y, lambda_=0.0):\n",
    "    \"\"\"\n",
    "    Implements the neural network cost function and gradient for a two layer neural \n",
    "    network which performs classification. \n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    nn_params : array_like\n",
    "        The parameters for the neural network which are \"unrolled\" into \n",
    "        a vector. This needs to be converted back into the weight matrices Theta1\n",
    "        and Theta2.\n",
    "    \n",
    "    input_layer_size : int\n",
    "        Number of features for the input layer. \n",
    "    \n",
    "    hidden_layer_size : int\n",
    "        Number of hidden units in the second layer.\n",
    "    \n",
    "    num_labels : int\n",
    "        Total number of labels, or equivalently number of units in output layer. \n",
    "    \n",
    "    X : array_like\n",
    "        Input dataset. A matrix of shape (m x input_layer_size).\n",
    "    \n",
    "    y : array_like\n",
    "        Dataset labels. A vector of shape (m,).\n",
    "    \n",
    "    lambda_ : float, optional\n",
    "        Regularization parameter.\n",
    " \n",
    "    Returns\n",
    "    -------\n",
    "    J : float\n",
    "        The computed value for the cost function at the current weight values.\n",
    "    \n",
    "    grad : array_like\n",
    "        An \"unrolled\" vector of the partial derivatives of the concatenatation of\n",
    "        neural network weights Theta1 and Theta2.\n",
    "    \n",
    "    Instructions\n",
    "    ------------\n",
    "    You should complete the code by working through the following parts.\n",
    "    \n",
    "    - Part 1: Feedforward the neural network and return the cost in the \n",
    "              variable J. After implementing Part 1, you can verify that your\n",
    "              cost function computation is correct by verifying the cost\n",
    "              computed in the following cell.\n",
    "    \n",
    "    - Part 2: Implement the backpropagation algorithm to compute the gradients\n",
    "              Theta1_grad and Theta2_grad. You should return the partial derivatives of\n",
    "              the cost function with respect to Theta1 and Theta2 in Theta1_grad and\n",
    "              Theta2_grad, respectively. After implementing Part 2, you can check\n",
    "              that your implementation is correct by running checkNNGradients provided\n",
    "              in the utils.py module.\n",
    "    \n",
    "              Note: The vector y passed into the function is a vector of labels\n",
    "                    containing values from 0..K-1. You need to map this vector into a \n",
    "                    binary vector of 1's and 0's to be used with the neural network\n",
    "                    cost function.\n",
    "     \n",
    "              Hint: We recommend implementing backpropagation using a for-loop\n",
    "                    over the training examples if you are implementing it for the \n",
    "                    first time.\n",
    "    \n",
    "    - Part 3: Implement regularization with the cost function and gradients.\n",
    "    \n",
    "              Hint: You can implement this around the code for\n",
    "                    backpropagation. That is, you can compute the gradients for\n",
    "                    the regularization separately and then add them to Theta1_grad\n",
    "                    and Theta2_grad from Part 2.\n",
    "    \n",
    "    Note \n",
    "    ----\n",
    "    We have provided an implementation for the sigmoid function in the file \n",
    "    `utils.py` accompanying this assignment.\n",
    "    \"\"\"\n",
    "    # Reshape nn_params back into the parameters Theta1 and Theta2, the weight matrices\n",
    "    # for our 2 layer neural network\n",
    "    Theta1 = np.reshape(nn_params[:hidden_layer_size * (input_layer_size + 1)],\n",
    "                        (hidden_layer_size, (input_layer_size + 1)))\n",
    "\n",
    "    Theta2 = np.reshape(nn_params[(hidden_layer_size * (input_layer_size + 1)):],\n",
    "                        (num_labels, (hidden_layer_size + 1)))\n",
    "\n",
    "    # Setup some useful variables\n",
    "    m = y.size\n",
    "         \n",
    "    # You need to return the following variables correctly \n",
    "    J = 0\n",
    "    Theta1_grad = np.zeros(Theta1.shape)\n",
    "    Theta2_grad = np.zeros(Theta2.shape)\n",
    "\n",
    "    # ====================== YOUR CODE HERE ======================\n",
      "    \n",
    "    \n",
    "    Theta1_grad = np.zeros(Theta1.shape)\n",
    "    Theta2_grad = np.zeros(Theta2.shape)\n",
    "    for i in range(0,m):\n",
    "        ytemp=np.zeros((num_labels,))\n",
    "        ytemp[y[i]]=1\n",
    "        ytemp=ytemp.reshape(num_labels,1)\n",
    "        a_1=np.append(1,X[i,:])\n",
    "        a_1=a_1.reshape(input_layer_size+1,1)\n",
    "        z_2=np.matmul(Theta1,(a_1))\n",
    "        a_2=utils.sigmoid(z_2)\n",
    "        a_2=np.append(1,a_2)\n",
    "        a_2=a_2.reshape(hidden_layer_size+1,1)\n",
    "        z_3=np.matmul(Theta2,(a_2))\n",
    "        a_3=utils.sigmoid(z_3)\n",
    "        a_3=a_3.reshape(num_labels,1)\n",
    "        error3=a_3-ytemp\n",
    "        g_2=sigmoidGradient(np.append(1,z_2))\n",
    "        g_2=g_2.reshape(g_2.shape[0],1)\n",
    "        error2=np.multiply(np.matmul(np.transpose(Theta2),error3),g_2)\n",
    "        error2=error2[1:]\n",
    "        #error2=error2.reshape(25,1)\n",
    "        #a_1=a_1.reshape(401,1)\n",
    "        #error3=error3.reshape(10,1)\n",
    "        #a_2=a_2.reshape(26,1)\n",
    "        Theta2_grad=Theta2_grad+np.matmul(error3,np.transpose(a_2))\n",
    "        Theta1_grad=Theta1_grad+np.matmul(error2,np.transpose(a_1))\n",
    "    Theta2_gradwr=(Theta2_grad/m)\n",
    "    Theta1_gradwr=(Theta1_grad/m)\n",
    "    Theta2_grad=(Theta2_gradwr)+lambda_*Theta2/m\n",
    "    Theta1_grad=(Theta1_gradwr)+lambda_*Theta1/m\n",
    "    Theta2_grad[:,0]=Theta2_gradwr[:,0]\n",
    "    Theta1_grad[:,0]=Theta1_gradwr[:,0]\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    for i in range(0,m):\n",
    "        ytemp=np.zeros((num_labels,))\n",
    "        ytemp[y[i]]=1\n",
    "        a_1=np.append(1,X[i,:])\n",
    "        z_2=np.matmul(Theta1,(a_1))\n",
    "        a_2=utils.sigmoid(z_2)\n",
    "        a_2=np.append(1,a_2)\n",
    "        z_3=np.matmul(Theta2,(a_2))\n",
    "        a_3=utils.sigmoid(z_3)\n",
    "        for k in range(0,num_labels):\n",
    "            J+=ytemp[k]*math.log(a_3[k])+(1-ytemp[k])*math.log(1-a_3[k])        \n",
    "    J=J/(-1*m)\n",
    "    temp=(np.sum((np.multiply(Theta1[:,1:],Theta1[:,1:])))+np.sum((np.multiply(Theta2[:,1:],Theta2[:,1:]))))*lambda_/(2*m)\n",
    "    J=J+temp\n",
    "          \n",
    "\n",
    "    \n",
    "    \n",
    "    # ================================================================\n",
    "    # Unroll gradients\n",
    "    # grad = np.concatenate([Theta1_grad.ravel(order=order), Theta2_grad.ravel(order=order)])\n",
    "    grad = np.concatenate([Theta1_grad.ravel(), Theta2_grad.ravel()])\n",
    "\n",
    "    return J, grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-box alert-warning\">\n",
    "Use the following links to go back to the different parts of this exercise that require to modify the function `nnCostFunction`.<br>\n",
    "\n",
    "Back to:\n",
    "- [Feedforward and cost function](#section1)\n",
    "- [Regularized cost](#section2)\n",
    "- [Neural Network Gradient (Backpropagation)](#section4)\n",
    "- [Regularized Gradient](#section5)\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you are done, call your `nnCostFunction` using the loaded set of parameters for `Theta1` and `Theta2`. You should see that the cost is about 0.287629."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lambda_ = 0\n",
    "J, _ = nnCostFunction(nn_params, input_layer_size, hidden_layer_size,\n",
    "                   num_labels, X, y, lambda_)\n",
    "print('Cost at parameters (loaded from ex4weights): %.6f ' % J)\n",
    "print('The cost should be about                   : 0.287629.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*You should now submit your solutions.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grader = utils.Grader()\n",
    "grader[1] = nnCostFunction\n",
    "grader.grade()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section2\"></a>\n",
    "### 1.4 Regularized cost function\n",
    "\n",
    "The cost function for neural networks with regularization is given by:\n",
    "\n",
    "\n",
    "$$ J(\\theta) = \\frac{1}{m} \\sum_{i=1}^{m}\\sum_{k=1}^{K} \\left[ - y_k^{(i)} \\log \\left( \\left( h_\\theta \\left( x^{(i)} \\right) \\right)_k \\right) - \\left( 1 - y_k^{(i)} \\right) \\log \\left( 1 - \\left( h_\\theta \\left( x^{(i)} \\right) \\right)_k \\right) \\right] + \\frac{\\lambda}{2 m} \\left[ \\sum_{j=1}^{25} \\sum_{k=1}^{400} \\left( \\Theta_{j,k}^{(1)} \\right)^2 + \\sum_{j=1}^{10} \\sum_{k=1}^{25} \\left( \\Theta_{j,k}^{(2)} \\right)^2 \\right] $$\n",
    "\n",
    "You can assume that the neural network will only have 3 layers - an input layer, a hidden layer and an output layer. However, your code should work for any number of input units, hidden units and outputs units. While we\n",
    "have explicitly listed the indices above for $\\Theta^{(1)}$ and $\\Theta^{(2)}$ for clarity, do note that your code should in general work with $\\Theta^{(1)}$ and $\\Theta^{(2)}$ of any size. Note that you should not be regularizing the terms that correspond to the bias. For the matrices `Theta1` and `Theta2`, this corresponds to the first column of each matrix. You should now add regularization to your cost function. Notice that you can first compute the unregularized cost function $J$ using your existing `nnCostFunction` and then later add the cost for the regularization terms.\n",
    "\n",
    "[Click here to go back to `nnCostFunction` for editing.](#nnCostFunction)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you are done, the next cell will call your `nnCostFunction` using the loaded set of parameters for `Theta1` and `Theta2`, and $\\lambda = 1$. You should see that the cost is about 0.383770."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Weight regularization parameter (we set this to 1 here).\n",
    "lambda_ = 1\n",
    "J, _ = nnCostFunction(nn_params, input_layer_size, hidden_layer_size,\n",
    "                      num_labels, X, y, lambda_)\n",
    "\n",
    "print('Cost at parameters (loaded from ex4weights): %.6f' % J)\n",
    "print('This value should be about                 : 0.383770.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*You should now submit your solutions.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grader[2] = nnCostFunction\n",
    "grader.grade()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Backpropagation\n",
    "\n",
    "In this part of the exercise, you will implement the backpropagation algorithm to compute the gradient for the neural network cost function. You will need to update the function `nnCostFunction` so that it returns an appropriate value for `grad`. Once you have computed the gradient, you will be able to train the neural network by minimizing the cost function $J(\\theta)$ using an advanced optimizer such as `scipy`'s `optimize.minimize`.\n",
    "You will first implement the backpropagation algorithm to compute the gradients for the parameters for the (unregularized) neural network. After you have verified that your gradient computation for the unregularized case is correct, you will implement the gradient for the regularized neural network."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section3\"></a>\n",
    "### 2.1 Sigmoid Gradient\n",
    "\n",
    "To help you get started with this part of the exercise, you will first implement\n",
    "the sigmoid gradient function. The gradient for the sigmoid function can be\n",
    "computed as\n",
    "\n",
    "$$ g'(z) = \\frac{d}{dz} g(z) = g(z)\\left(1-g(z)\\right) $$\n",
    "\n",
    "where\n",
    "\n",
    "$$ \\text{sigmoid}(z) = g(z) = \\frac{1}{1 + e^{-z}} $$\n",
    "\n",
    "Now complete the implementation of `sigmoidGradient` in the next cell.\n",
    "<a id=\"sigmoidGradient\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoidGradient(z):\n",
    "    \"\"\"\n",
    "    Computes the gradient of the sigmoid function evaluated at z. \n",
    "    This should work regardless if z is a matrix or a vector. \n",
    "    In particular, if z is a vector or matrix, you should return\n",
    "    the gradient for each element.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    z : array_like\n",
    "        A vector or matrix as input to the sigmoid function. \n",
    "    \n",
    "    Returns\n",
    "    --------\n",
    "    g : array_like\n",
    "        Gradient of the sigmoid function. Has the same shape as z. \n",
    "    \n",
    "    Instructions\n",
    "    ------------\n",
    "    Compute the gradient of the sigmoid function evaluated at\n",
    "    each value of z (z can be a matrix, vector or scalar).\n",
    "    \n",
    "    Note\n",
    "    ----\n",
    "    We have provided an implementation of the sigmoid function \n",
    "    in `utils.py` file accompanying this assignment.\n",
    "    \"\"\"\n",
    "\n",
    "    g = np.zeros(z.shape)\n",
    "\n",
    "    # ====================== YOUR CODE HERE ======================\n",
    "    g=utils.sigmoid(z)\n",
    "    i = np.ones(z.shape)\n",
    "    g=np.multiply(g,i-g)\n",
    "\n",	    "\n",
    "\n",
    "\n",
    "\n",
    "    # =============================================================\n",
    "    return g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you are done, the following cell call `sigmoidGradient` on a given vector `z`. Try testing a few values by calling `sigmoidGradient(z)`. For large values (both positive and negative) of z, the gradient should be close to 0. When $z = 0$, the gradient should be exactly 0.25. Your code should also work with vectors and matrices. For a matrix, your function should perform the sigmoid gradient function on every element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = np.array([-1, -0.5, 0, 0.5, 1])\n",
    "g = sigmoidGradient(z)\n",
    "print('Sigmoid gradient evaluated at [-1 -0.5 0 0.5 1]:\\n  ')\n",
    "print(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*You should now submit your solutions.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grader[3] = sigmoidGradient\n",
    "grader.grade()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Random Initialization\n",
    "\n",
    "When training neural networks, it is important to randomly initialize the parameters for symmetry breaking. One effective strategy for random initialization is to randomly select values for $\\Theta^{(l)}$ uniformly in the range $[-\\epsilon_{init}, \\epsilon_{init}]$. You should use $\\epsilon_{init} = 0.12$. This range of values ensures that the parameters are kept small and makes the learning more efficient.\n",
    "\n",
    "<div class=\"alert alert-box alert-warning\">\n",
    "One effective strategy for choosing $\\epsilon_{init}$ is to base it on the number of units in the network. A good choice of $\\epsilon_{init}$ is $\\epsilon_{init} = \\frac{\\sqrt{6}}{\\sqrt{L_{in} + L_{out}}}$ where $L_{in} = s_l$ and $L_{out} = s_{l+1}$ are the number of units in the layers adjacent to $\\Theta^{l}$.\n",
    "</div>\n",
    "\n",
    "Your job is to complete the function `randInitializeWeights` to initialize the weights for $\\Theta$. Modify the function by filling in the following code:\n",
    "\n",
    "```python\n",
    "# Randomly initialize the weights to small values\n",
    "W = np.random.rand(L_out, 1 + L_in) * 2 * epsilon_init - epsilon_init\n",
    "```\n",
    "Note that we give the function an argument for $\\epsilon$ with default value `epsilon_init = 0.12`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def randInitializeWeights(L_in, L_out, epsilon_init=0.12):\n",
    "    \"\"\"\n",
    "    Randomly initialize the weights of a layer in a neural network.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    L_in : int\n",
    "        Number of incomming connections.\n",
    "    \n",
    "    L_out : int\n",
    "        Number of outgoing connections. \n",
    "    \n",
    "    epsilon_init : float, optional\n",
    "        Range of values which the weight can take from a uniform \n",
    "        distribution.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    W : array_like\n",
    "        The weight initialiatized to random values.  Note that W should\n",
    "        be set to a matrix of size(L_out, 1 + L_in) as\n",
    "        the first column of W handles the \"bias\" terms.\n",
    "        \n",
    "    Instructions\n",
    "    ------------\n",
    "    Initialize W randomly so that we break the symmetry while training\n",
    "    the neural network. Note that the first column of W corresponds \n",
    "    to the parameters for the bias unit.\n",
    "    \"\"\"\n",
    "\n",
    "    # You need to return the following variables correctly \n",
    "    W = np.zeros((L_out, 1 + L_in))\n",
    "\n",
    "    # ====================== YOUR CODE HERE ======================\n",
    "    W = np.random.rand(L_out, 1 + L_in) * 2 * epsilon_init - epsilon_init\n",
    "\n",
    "\n",
    "\n",
    "    # ============================================================\n",
    "    return W"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*You do not need to submit any code for this part of the exercise.*\n",
    "\n",
    "Execute the following cell to initialize the weights for the 2 layers in the neural network using the `randInitializeWeights` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Initializing Neural Network Parameters ...')\n",
    "\n",
    "initial_Theta1 = randInitializeWeights(input_layer_size, hidden_layer_size)\n",
    "initial_Theta2 = randInitializeWeights(hidden_layer_size, num_labels)\n",
    "\n",
    "# Unroll parameters\n",
    "initial_nn_params = np.concatenate([initial_Theta1.ravel(), initial_Theta2.ravel()], axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section4\"></a>\n",
    "### 2.4 Backpropagation\n",
    "\n",
    "![](Figures/ex4-backpropagation.png)\n",
    "\n",
    "Now, you will implement the backpropagation algorithm. Recall that the intuition behind the backpropagation algorithm is as follows. Given a training example $(x^{(t)}, y^{(t)})$, we will first run a “forward pass” to compute all the activations throughout the network, including the output value of the hypothesis $h_\\theta(x)$. Then, for each node $j$ in layer $l$, we would like to compute an “error term” $\\delta_j^{(l)}$ that measures how much that node was “responsible” for any errors in our output.\n",
    "\n",
    "For an output node, we can directly measure the difference between the network’s activation and the true target value, and use that to define $\\delta_j^{(3)}$ (since layer 3 is the output layer). For the hidden units, you will compute $\\delta_j^{(l)}$ based on a weighted average of the error terms of the nodes in layer $(l+1)$. In detail, here is the backpropagation algorithm (also depicted in the figure above). You should implement steps 1 to 4 in a loop that processes one example at a time. Concretely, you should implement a for-loop `for t in range(m)` and place steps 1-4 below inside the for-loop, with the $t^{th}$ iteration performing the calculation on the $t^{th}$ training example $(x^{(t)}, y^{(t)})$. Step 5 will divide the accumulated gradients by $m$ to obtain the gradients for the neural network cost function.\n",
    "\n",
    "1. Set the input layer’s values $(a^{(1)})$ to the $t^{th }$training example $x^{(t)}$. Perform a feedforward pass, computing the activations $(z^{(2)}, a^{(2)}, z^{(3)}, a^{(3)})$ for layers 2 and 3. Note that you need to add a `+1` term to ensure that the vectors of activations for layers $a^{(1)}$ and $a^{(2)}$ also include the bias unit. In `numpy`, if a 1 is a column matrix, adding one corresponds to `a_1 = np.concatenate([np.ones((m, 1)), a_1], axis=1)`.\n",
    "\n",
    "1. For each output unit $k$ in layer 3 (the output layer), set \n",
    "$$\\delta_k^{(3)} = \\left(a_k^{(3)} - y_k \\right)$$\n",
    "where $y_k \\in \\{0, 1\\}$ indicates whether the current training example belongs to class $k$ $(y_k = 1)$, or if it belongs to a different class $(y_k = 0)$. You may find logical arrays helpful for this task (explained in the previous programming exercise).\n",
    "\n",
    "1. For the hidden layer $l = 2$, set \n",
    "$$ \\delta^{(2)} = \\left( \\Theta^{(2)} \\right)^T \\delta^{(3)} * g'\\left(z^{(2)} \\right)$$\n",
    "Note that the symbol $*$ performs element wise multiplication in `numpy`.\n",
    "\n",
    "1. Accumulate the gradient from this example using the following formula. Note that you should skip or remove $\\delta_0^{(2)}$. In `numpy`, removing $\\delta_0^{(2)}$ corresponds to `delta_2 = delta_2[1:]`.\n",
    "\n",
    "1. Obtain the (unregularized) gradient for the neural network cost function by dividing the accumulated gradients by $\\frac{1}{m}$:\n",
    "$$ \\frac{\\partial}{\\partial \\Theta_{ij}^{(l)}} J(\\Theta) = D_{ij}^{(l)} = \\frac{1}{m} \\Delta_{ij}^{(l)}$$\n",
    "\n",
    "<div class=\"alert alert-box alert-warning\">\n",
    "**Python/Numpy tip**: You should implement the backpropagation algorithm only after you have successfully completed the feedforward and cost functions. While implementing the backpropagation alogrithm, it is often useful to use the `shape` function to print out the shapes of the variables you are working with if you run into dimension mismatch errors.\n",
    "</div>\n",
    "\n",
    "[Click here to go back and update the function `nnCostFunction` with the backpropagation algorithm](#nnCostFunction)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After you have implemented the backpropagation algorithm, we will proceed to run gradient checking on your implementation. The gradient check will allow you to increase your confidence that your code is\n",
    "computing the gradients correctly.\n",
    "\n",
    "### 2.4  Gradient checking \n",
    "\n",
    "In your neural network, you are minimizing the cost function $J(\\Theta)$. To perform gradient checking on your parameters, you can imagine “unrolling” the parameters $\\Theta^{(1)}$, $\\Theta^{(2)}$ into a long vector $\\theta$. By doing so, you can think of the cost function being $J(\\Theta)$ instead and use the following gradient checking procedure.\n",
    "\n",
    "Suppose you have a function $f_i(\\theta)$ that purportedly computes $\\frac{\\partial}{\\partial \\theta_i} J(\\theta)$; you’d like to check if $f_i$ is outputting correct derivative values.\n",
    "\n",
    "$$\n",
    "\\text{Let } \\theta^{(i+)} = \\theta + \\begin{bmatrix} 0 \\\\ 0 \\\\ \\vdots \\\\ \\epsilon \\\\ \\vdots \\\\ 0 \\end{bmatrix}\n",
    "\\quad \\text{and} \\quad \\theta^{(i-)} = \\theta - \\begin{bmatrix} 0 \\\\ 0 \\\\ \\vdots \\\\ \\epsilon \\\\ \\vdots \\\\ 0 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "So, $\\theta^{(i+)}$ is the same as $\\theta$, except its $i^{th}$ element has been incremented by $\\epsilon$. Similarly, $\\theta^{(i−)}$ is the corresponding vector with the $i^{th}$ element decreased by $\\epsilon$. You can now numerically verify $f_i(\\theta)$’s correctness by checking, for each $i$, that:\n",
    "\n",
    "$$ f_i\\left( \\theta \\right) \\approx \\frac{J\\left( \\theta^{(i+)}\\right) - J\\left( \\theta^{(i-)} \\right)}{2\\epsilon} $$\n",
    "\n",
    "The degree to which these two values should approximate each other will depend on the details of $J$. But assuming $\\epsilon = 10^{-4}$, you’ll usually find that the left- and right-hand sides of the above will agree to at least 4 significant digits (and often many more).\n",
    "\n",
    "We have implemented the function to compute the numerical gradient for you in `computeNumericalGradient` (within the file `utils.py`). While you are not required to modify the file, we highly encourage you to take a look at the code to understand how it works.\n",
    "\n",
    "In the next cell we will run the provided function `checkNNGradients` which will create a small neural network and dataset that will be used for checking your gradients. If your backpropagation implementation is correct,\n",
    "you should see a relative difference that is less than 1e-9.\n",
    "\n",
    "<div class=\"alert alert-box alert-success\">\n",
    "**Practical Tip**: When performing gradient checking, it is much more efficient to use a small neural network with a relatively small number of input units and hidden units, thus having a relatively small number\n",
    "of parameters. Each dimension of $\\theta$ requires two evaluations of the cost function and this can be expensive. In the function `checkNNGradients`, our code creates a small random model and dataset which is used with `computeNumericalGradient` for gradient checking. Furthermore, after you are confident that your gradient computations are correct, you should turn off gradient checking before running your learning algorithm.\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-box alert-success\">\n",
    "**Practical Tip:** Gradient checking works for any function where you are computing the cost and the gradient. Concretely, you can use the same `computeNumericalGradient` function to check if your gradient implementations for the other exercises are correct too (e.g., logistic regression’s cost function).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "utils.checkNNGradients(nnCostFunction)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Once your cost function passes the gradient check for the (unregularized) neural network cost function, you should submit the neural network gradient function (backpropagation).*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grader[4] = nnCostFunction\n",
    "grader.grade()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section5\"></a>\n",
    "### 2.5 Regularized Neural Network\n",
    "\n",
    "After you have successfully implemented the backpropagation algorithm, you will add regularization to the gradient. To account for regularization, it turns out that you can add this as an additional term *after* computing the gradients using backpropagation.\n",
    "\n",
    "Specifically, after you have computed $\\Delta_{ij}^{(l)}$ using backpropagation, you should add regularization using\n",
    "\n",
    "$$ \\begin{align} \n",
    "& \\frac{\\partial}{\\partial \\Theta_{ij}^{(l)}} J(\\Theta) = D_{ij}^{(l)} = \\frac{1}{m} \\Delta_{ij}^{(l)} & \\qquad \\text{for } j = 0 \\\\\n",
    "& \\frac{\\partial}{\\partial \\Theta_{ij}^{(l)}} J(\\Theta) = D_{ij}^{(l)} = \\frac{1}{m} \\Delta_{ij}^{(l)} + \\frac{\\lambda}{m} \\Theta_{ij}^{(l)} & \\qquad \\text{for } j \\ge 1\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "Note that you should *not* be regularizing the first column of $\\Theta^{(l)}$ which is used for the bias term. Furthermore, in the parameters $\\Theta_{ij}^{(l)}$, $i$ is indexed starting from 1, and $j$ is indexed starting from 0. Thus, \n",
    "\n",
    "$$\n",
    "\\Theta^{(l)} = \\begin{bmatrix}\n",
    "\\Theta_{1,0}^{(i)} & \\Theta_{1,1}^{(l)} & \\cdots \\\\\n",
    "\\Theta_{2,0}^{(i)} & \\Theta_{2,1}^{(l)} & \\cdots \\\\\n",
    "\\vdots &  ~ & \\ddots\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "[Now modify your code that computes grad in `nnCostFunction` to account for regularization.](#nnCostFunction)\n",
    "\n",
    "After you are done, the following cell runs gradient checking on your implementation. If your code is correct, you should expect to see a relative difference that is less than 1e-9."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Check gradients by running checkNNGradients\n",
    "lambda_ = 3\n",
    "utils.checkNNGradients(nnCostFunction, lambda_)\n",
    "\n",
    "# Also output the costFunction debugging values\n",
    "debug_J, _  = nnCostFunction(nn_params, input_layer_size,\n",
    "                          hidden_layer_size, num_labels, X, y, lambda_)\n",
    "\n",
    "print('\\n\\nCost at (fixed) debugging parameters (w/ lambda = %f): %f ' % (lambda_, debug_J))\n",
    "print('(for lambda = 3, this value should be about 0.576051)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grader[5] = nnCostFunction\n",
    "grader.grade()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6 Learning parameters using `scipy.optimize.minimize`\n",
    "\n",
    "After you have successfully implemented the neural network cost function\n",
    "and gradient computation, the next step we will use `scipy`'s minimization to learn a good set parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  After you have completed the assignment, change the maxiter to a larger\n",
    "#  value to see how more training helps.\n",
    "options= {'maxiter': 100}\n",
    "\n",
    "#  You should also try different values of lambda\n",
    "lambda_ = 1\n",
    "\n",
    "# Create \"short hand\" for the cost function to be minimized\n",
    "costFunction = lambda p: nnCostFunction(p, input_layer_size,\n",
    "                                        hidden_layer_size,\n",
    "                                        num_labels, X, y, lambda_)\n",
    "\n",
    "# Now, costFunction is a function that takes in only one argument\n",
    "# (the neural network parameters)\n",
    "res = optimize.minimize(costFunction,\n",
    "                        initial_nn_params,\n",
    "                        jac=True,\n",
    "                        method='TNC',\n",
    "                        options=options)\n",
    "\n",
    "# get the solution of the optimization\n",
    "nn_params = res.x\n",
    "        \n",
    "# Obtain Theta1 and Theta2 back from nn_params\n",
    "Theta1 = np.reshape(nn_params[:hidden_layer_size * (input_layer_size + 1)],\n",
    "                    (hidden_layer_size, (input_layer_size + 1)))\n",
    "\n",
    "Theta2 = np.reshape(nn_params[(hidden_layer_size * (input_layer_size + 1)):],\n",
    "                    (num_labels, (hidden_layer_size + 1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After the training completes, we will proceed to report the training accuracy of your classifier by computing the percentage of examples it got correct. If your implementation is correct, you should see a reported\n",
    "training accuracy of about 95.3% (this may vary by about 1% due to the random initialization). It is possible to get higher training accuracies by training the neural network for more iterations. We encourage you to try\n",
    "training the neural network for more iterations (e.g., set `maxiter` to 400) and also vary the regularization parameter $\\lambda$. With the right learning settings, it is possible to get the neural network to perfectly fit the training set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = utils.predict(Theta1, Theta2, X)\n",
    "print('Training Set Accuracy: %f' % (np.mean(pred == y) * 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Visualizing the Hidden Layer\n",
    "\n",
    "One way to understand what your neural network is learning is to visualize what the representations captured by the hidden units. Informally, given a particular hidden unit, one way to visualize what it computes is to find an input $x$ that will cause it to activate (that is, to have an activation value \n",
    "($a_i^{(l)}$) close to 1). For the neural network you trained, notice that the $i^{th}$ row of $\\Theta^{(1)}$ is a 401-dimensional vector that represents the parameter for the $i^{th}$ hidden unit. If we discard the bias term, we get a 400 dimensional vector that represents the weights from each input pixel to the hidden unit.\n",
    "\n",
    "Thus, one way to visualize the “representation” captured by the hidden unit is to reshape this 400 dimensional vector into a 20 × 20 image and display it (It turns out that this is equivalent to finding the input that gives the highest activation for the hidden unit, given a “norm” constraint on the input (i.e., $||x||_2 \\le 1$)). \n",
    "\n",
    "The next cell does this by using the `displayData` function and it will show you an image with 25 units,\n",
    "each corresponding to one hidden unit in the network. In your trained network, you should find that the hidden units corresponds roughly to detectors that look for strokes and other patterns in the input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "utils.displayData(Theta1[:, 1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Optional (ungraded) exercise\n",
    "\n",
    "In this part of the exercise, you will get to try out different learning settings for the neural network to see how the performance of the neural network varies with the regularization parameter $\\lambda$ and number of training steps (the `maxiter` option when using `scipy.optimize.minimize`). Neural networks are very powerful models that can form highly complex decision boundaries. Without regularization, it is possible for a neural network to “overfit” a training set so that it obtains close to 100% accuracy on the training set but does not as well on new examples that it has not seen before. You can set the regularization $\\lambda$ to a smaller value and the `maxiter` parameter to a higher number of iterations to see this for youself."
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}