MachineLearning-04.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Coursera: [Machine Learning](https://www.coursera.org/learn/machine-learning) - Week 4\n",
    "\n",
    "Created by Andrew Ng / Stanford University"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Content\n",
    "\n",
    "* [Neural Networks: Representation](#Neural-Networks:-Representation)\n",
    "   * Motivations\n",
    "      * Non-linear Hypotheses\n",
    "      * Neurons and the Brain\n",
    "   * Neural Networks\n",
    "      * Model Representation I\n",
    "      * Model Representation II\n",
    "   * Applications\n",
    "      * Examples and Intuitions I\n",
    "      * Examples and Intuitions II\n",
    "      * Multiclass Classification\n",
    "   * Review"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural Networks: Representation\n",
    "\n",
    "Welcome to week 4! This week, we are covering neural networks. Neural networks is a model inspired by how the brain works. It is widely used today in many applications: when your phone interprets and understand your voice commands, it is likely that a neural network is helping to understand your speech; when you cash a check, the machines that automatically read the digits also use neural networks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Motivations\n",
    "\n",
    "#### Non-linear Hypotheses\n",
    "-\n",
    "\n",
    "#### Neurons and the Brain\n",
    "-"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Neural Networks\n",
    "\n",
    "#### Model Representation I\n",
    "\n",
    "Let's examine how we will represent a hypothesis function using neural networks. At a very simple level, neurons are basically computational units that take inputs (**dendrites**) as electrical inputs (called \"spikes\") that are channeled to outputs (**axons**). In our model, our dendrites are like the input features $x_1\\cdots x_n$, and the output is the result of our hypothesis function. In this model our $x_0$ input node is sometimes called the \"bias unit.\" It is always equal to 1. In neural networks, we use the same logistic function as in classification, $\\frac{1}{1 + e^{-\\theta^Tx}}$, yet we sometimes call it a sigmoid (logistic) **activation** function. In this situation, our \"theta\" parameters are sometimes called \"weights\".\n",
    "\n",
    "Visually, a simplistic representation looks like:\n",
    "\n",
    "$\\begin{bmatrix}x_0 \\newline x_1 \\newline x_2 \\newline \\end{bmatrix}\\rightarrow\\begin{bmatrix}\\ \\ \\ \\newline \\end{bmatrix}\\rightarrow h_\\theta(x)$\n",
    "\n",
    "Our input nodes (layer 1), also known as the \"input layer\", go into another node (layer 2), which finally outputs the hypothesis function, known as the \"output layer\".\n",
    "\n",
    "We can have intermediate layers of nodes between the input and output layers called the \"hidden layers.\"\n",
    "\n",
    "In this example, we label these intermediate or \"hidden\" layer nodes $a^2_0 \\cdots a^2_n$ and call them \"activation units.\"\n",
    "\n",
    "$\\begin{align*}& a_i^{(j)} = \\text{\"activation\" of unit $i$ in layer $j$} \\newline& \\Theta^{(j)} = \\text{matrix of weights controlling function mapping from layer $j$ to layer $j+1$}\\end{align*}$\n",
    "\n",
    "If we had one hidden layer, it would look like:\n",
    "\n",
    "$\\begin{bmatrix}x_0 \\newline x_1 \\newline x_2 \\newline x_3\\end{bmatrix}\\rightarrow\\begin{bmatrix}a_1^{(2)} \\newline a_2^{(2)} \\newline a_3^{(2)} \\newline \\end{bmatrix}\\rightarrow h_\\theta(x)$\n",
    "\n",
    "The values for each of the \"activation\" nodes is obtained as follows:\n",
    "\n",
    "$\\begin{align*} a_1^{(2)} = g(\\Theta_{10}^{(1)}x_0 + \\Theta_{11}^{(1)}x_1 + \\Theta_{12}^{(1)}x_2 + \\Theta_{13}^{(1)}x_3) \\newline a_2^{(2)} = g(\\Theta_{20}^{(1)}x_0 + \\Theta_{21}^{(1)}x_1 + \\Theta_{22}^{(1)}x_2 + \\Theta_{23}^{(1)}x_3) \\newline a_3^{(2)} = g(\\Theta_{30}^{(1)}x_0 + \\Theta_{31}^{(1)}x_1 + \\Theta_{32}^{(1)}x_2 + \\Theta_{33}^{(1)}x_3) \\newline h_\\Theta(x) = a_1^{(3)} = g(\\Theta_{10}^{(2)}a_0^{(2)} + \\Theta_{11}^{(2)}a_1^{(2)} + \\Theta_{12}^{(2)}a_2^{(2)} + \\Theta_{13}^{(2)}a_3^{(2)}) \\newline \\end{align*}$\n",
    "\n",
    "This is saying that we compute our activation nodes by using a 3×4 matrix of parameters. We apply each row of the parameters to our inputs to obtain the value for one activation node. Our hypothesis output is the logistic function applied to the sum of the values of our activation nodes, which have been multiplied by yet another parameter matrix $\\Theta^{(2)}$ containing the weights for our second layer of nodes.\n",
    "\n",
    "Each layer gets its own matrix of weights, $\\Theta^{(j)}$.\n",
    "\n",
    "The dimensions of these matrices of weights is determined as follows:\n",
    "\n",
    "$\\text{If network has $s_j$ units in layer $j$ and $s_{j+1}$ units in layer $j+1$, then $\\Theta^{(j)}$ will be of dimension $s_{j+1} \\times (s_j + 1)$.}$\n",
    "\n",
    "The +1 comes from the addition in $\\Theta^{(j)}$ of the \"bias nodes,\" $x_0$ and $\\Theta_0^{(j)}$. In other words the output nodes will not include the bias nodes while the inputs will. The following image summarizes our model representation:\n",
    "\n",
    "![title](images/0rgjYLDeEeajLxLfjQiSjg_0c07c56839f8d6e8d7b0d09acedc88fd_Screenshot-2016-11-22-10.08.51.png)\n",
    "\n",
    "Example: If layer 1 has 2 input nodes and layer 2 has 4 activation nodes. Dimension of $\\Theta^{(1)}$ is going to be 4×3 where $s_j = 2$ and $s_{j+1} = 4$, so $s_{j+1} \\times (s_j + 1) = 4 \\times 3$.\n",
    "\n",
    "#### Model Representation II\n",
    "\n",
    "To re-iterate, the following is an example of a neural network:\n",
    "\n",
    "$\\begin{align*} a_1^{(2)} = g(\\Theta_{10}^{(1)}x_0 + \\Theta_{11}^{(1)}x_1 + \\Theta_{12}^{(1)}x_2 + \\Theta_{13}^{(1)}x_3) \\newline a_2^{(2)} = g(\\Theta_{20}^{(1)}x_0 + \\Theta_{21}^{(1)}x_1 + \\Theta_{22}^{(1)}x_2 + \\Theta_{23}^{(1)}x_3) \\newline a_3^{(2)} = g(\\Theta_{30}^{(1)}x_0 + \\Theta_{31}^{(1)}x_1 + \\Theta_{32}^{(1)}x_2 + \\Theta_{33}^{(1)}x_3) \\newline h_\\Theta(x) = a_1^{(3)} = g(\\Theta_{10}^{(2)}a_0^{(2)} + \\Theta_{11}^{(2)}a_1^{(2)} + \\Theta_{12}^{(2)}a_2^{(2)} + \\Theta_{13}^{(2)}a_3^{(2)}) \\newline \\end{align*}$\n",
    "\n",
    "In this section we'll do a vectorized implementation of the above functions. We're going to define a new variable $z_k^{(j)}$ that encompasses the parameters inside our $g$ function. In our previous example if we replaced by the variable $z$ for all the parameters we would get:\n",
    "\n",
    "$\\begin{align*}a_1^{(2)} = g(z_1^{(2)}) \\newline a_2^{(2)} = g(z_2^{(2)}) \\newline a_3^{(2)} = g(z_3^{(2)}) \\newline \\end{align*}$\n",
    "\n",
    "In other words, for layer $j=2$ and node $k$, the variable $z$ will be:\n",
    "\n",
    "$ z_k^{(2)} = \\Theta_{k,0}^{(1)}x_0 + \\Theta_{k,1}^{(1)}x_1 + \\cdots + \\Theta_{k,n}^{(1)}x_n$\n",
    "\n",
    "The vector representation of $x$ and $z^{j}$ is:\n",
    "\n",
    "$\\begin{align*}x = \\begin{bmatrix}x_0 \\newline x_1 \\newline\\cdots \\newline x_n\\end{bmatrix} &z^{(j)} = \\begin{bmatrix}z_1^{(j)} \\newline z_2^{(j)} \\newline\\cdots \\newline z_n^{(j)}\\end{bmatrix}\\end{align*}$\n",
    "\n",
    "Setting $x = a^{(1)}$, we can rewrite the equation as:\n",
    "\n",
    "$z^{(j)} = \\Theta^{(j-1)}a^{(j-1)}$\n",
    " \n",
    "We are multiplying our matrix $\\Theta^{(j-1)}$ with dimensions $s_j\\times (n+1)$ (where $s_j$ is the number of our activation nodes) by our vector $a^{(j-1)}$ with height $(n+1)$. This gives us our vector $z^{(j)}$ with height $s_js$. Now we can get a vector of our activation nodes for layer $j$ as follows:\n",
    "\n",
    "$a^{(j)} = g(z^{(j)})$\n",
    "\n",
    "Where our function $g$ can be applied element-wise to our vector $z^{(j)}$.\n",
    "\n",
    "We can then add a bias unit (equal to 1) to layer $j$ after we have computed $a^{(j)}$. This will be element $a_0^{(j)}$ and will be equal to 1. To compute our final hypothesis, let's first compute another $z$ vector:\n",
    "\n",
    "$z^{(j+1)} = \\Theta^{(j)}a^{(j)}$\n",
    "\n",
    "We get this final $z$ vector by multiplying the next theta matrix after $\\Theta^{(j-1)}$ with the values of all the activation nodes we just got. This last theta matrix $\\Theta^{(j)}$ will have only **one row** which is multiplied by one column $a^{(j)}$ so that our result is a single number. We then get our final result with:\n",
    "\n",
    "$h_\\Theta(x) = a^{(j+1)} = g(z^{(j+1)})$\n",
    "\n",
    "Notice that in this **last step**, between layer $j$ and layer $j+1$, we are doing **exactly the same thing** as we did in logistic regression. Adding all these intermediate layers in neural networks allows us to more elegantly produce interesting and more complex non-linear hypotheses."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Applications\n",
    "\n",
    "#### Examples and Intuitions I\n",
    "\n",
    "A simple example of applying neural networks is by predicting $x_1$ AND $x_2$, which is the logical 'and' operator and is only true if both $x_1$ and $x_2$ are 1.\n",
    "\n",
    "The graph of our functions will look like:\n",
    "\n",
    "$\\begin{align*}\\begin{bmatrix}x_0 \\newline x_1 \\newline x_2\\end{bmatrix} \\rightarrow\\begin{bmatrix}g(z^{(2)})\\end{bmatrix} \\rightarrow h_\\Theta(x)\\end{align*}$\n",
    "\n",
    "Remember that $x_0$ is our bias variable and is always 1.\n",
    "\n",
    "Let's set our first theta matrix as:\n",
    "\n",
    "$\\Theta^{(1)} = \\begin{bmatrix}−30 & 20 & 20\\end{bmatrix}$\n",
    "\n",
    "This will cause the output of our hypothesis to only be positive if both $x_1$ and $x_2$ are 1. In other words:\n",
    "\n",
    "$\\begin{align*}& h_\\Theta(x) = g(-30 + 20x_1 + 20x_2) \\newline \\newline & x_1 = 0 \\ \\ and \\ \\ x_2 = 0 \\ \\ then \\ \\ g(-30) \\approx 0 \\newline & x_1 = 0 \\ \\ and \\ \\ x_2 = 1 \\ \\ then \\ \\ g(-10) \\approx 0 \\newline & x_1 = 1 \\ \\ and \\ \\ x_2 = 0 \\ \\ then \\ \\ g(-10) \\approx 0 \\newline & x_1 = 1 \\ \\ and \\ \\ x_2 = 1 \\ \\ then \\ \\ g(10) \\approx 1\\end{align*}$\n",
    "\n",
    "So we have constructed one of the fundamental operations in computers by using a small neural network rather than using an actual AND gate. Neural networks can also be used to simulate all the other logical gates. The following is an example of the logical operator 'OR', meaning either $x_1$ is true or $x_2$ is true, or both:\n",
    "\n",
    "![title](images/f_ueJLGnEea3qApInhZCFg_a5ff8edc62c9a09900eae075e8502e34_Screenshot-2016-11-23-10.03.48.png)\n",
    "\n",
    "Where $g(z)$ is the following:\n",
    "\n",
    "![title](images/wMOiMrGnEeajLxLfjQiSjg_bbbdad80f5c95068bde7c9134babdd77_Screenshot-2016-11-23-10.07.24.png)\n",
    "\n",
    "#### Examples and Intuitions II\n",
    "\n",
    "The $Θ^{(1)}$ matrices for AND, NOR, and OR are:\n",
    "\n",
    "$\\begin{align*}AND:\\newline\\Theta^{(1)} &=\\begin{bmatrix}-30 & 20 & 20\\end{bmatrix} \\newline NOR:\\newline\\Theta^{(1)} &= \\begin{bmatrix}10 & -20 & -20\\end{bmatrix} \\newline OR:\\newline\\Theta^{(1)} &= \\begin{bmatrix}-10 & 20 & 20\\end{bmatrix} \\newline\\end{align*}$\n",
    "\n",
    "We can combine these to get the XNOR logical operator (which gives 1 if $x_1$ and $x_2$ are both 0 or both 1).\n",
    "\n",
    "$\\begin{align*}\\begin{bmatrix}x_0 \\newline x_1 \\newline x_2\\end{bmatrix} \\rightarrow\\begin{bmatrix}a_1^{(2)} \\newline a_2^{(2)} \\end{bmatrix} \\rightarrow\\begin{bmatrix}a^{(3)}\\end{bmatrix} \\rightarrow h_\\Theta(x)\\end{align*}$\n",
    "\n",
    "For the transition between the first and second layer, we'll use a $Θ^{(1)}$ matrix that combines the values for AND and NOR:\n",
    "\n",
    "$\\Theta^{(1)} =\\begin{bmatrix}-30 & 20 & 20 \\newline 10 & -20 & -20\\end{bmatrix}$\n",
    "\n",
    "For the transition between the second and third layer, we'll use a $Θ^{(2)}$ matrix that uses the value for OR:\n",
    "\n",
    "$\\Theta^{(2)} = \\begin{bmatrix}−10 & 20 & 20\\end{bmatrix}$\n",
    "\n",
    "Let's write out the values for all our nodes:\n",
    "\n",
    "$\\begin{align*}& a^{(2)} = g(\\Theta^{(1)} \\cdot x) \\newline& a^{(3)} = g(\\Theta^{(2)} \\cdot a^{(2)}) \\newline& h_\\Theta(x) = a^{(3)}\\end{align*}$\n",
    "\n",
    "And there we have the XNOR operator using a hidden layer with two nodes! The following summarizes the above algorithm:\n",
    "\n",
    "![title](images/rag_zbGqEeaSmhJaoV5QvA_52c04a987dcb692da8979a2198f3d8d7_Screenshot-2016-11-23-10.28.41.png)\n",
    "\n",
    "#### Multiclass Classification\n",
    "\n",
    "To classify data into multiple classes, we let our hypothesis function return a vector of values. Say we wanted to classify our data into one of four categories. We will use the following example to see how this classification is done. This algorithm takes as input an image and classifies it accordingly:\n",
    "\n",
    "![title](images/9Aeo6bGtEea4MxKdJPaTxA_4febc7ec9ac9dd0e4309bd1778171d36_Screenshot-2016-11-23-10.49.05.png)\n",
    "\n",
    "We can define our set of resulting classes as $y$:\n",
    "\n",
    "![title](images/KBpHLXqiEealOA67wFuqoQ_95654ff11df1261d935ab00553d724e5_Screenshot-2016-09-14-10.38.27.png)\n",
    "\n",
    "Each $y^{(i)}$ represents a different image corresponding to either a car, pedestrian, truck, or motorcycle. The inner layers, each provide us with some new information which leads to our final hypothesis function. The setup looks like:\n",
    "\n",
    "![title](images/VBxpV7GvEeamBAoLccicqA_3e7f67888330b131426ecffd27936f61_Screenshot-2016-11-23-10.59.19.png)\n",
    "\n",
    "Our resulting hypothesis for one set of inputs may look like:\n",
    "\n",
    "$h_\\Theta(x) =\\begin{bmatrix}0 \\newline 0 \\newline 1 \\newline 0 \\newline\\end{bmatrix}$\n",
    "\n",
    "In which case our resulting class is the third one down, or $h_\\Theta(x)_3$, which represents the motorcycle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Review\n",
    "\n",
    "[Lecture8.pdf](lectures/Lecture8.pdf)"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}