diff --git a/exercise12.ipynb b/exercise12.ipynb new file mode 100644 index 000000000..0e0c768e3 --- /dev/null +++ b/exercise12.ipynb @@ -0,0 +1,1447 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Programming Exercise 1: Linear Regression\n", + "\n", + "## Introduction\n", + "\n", + "In this exercise, you will implement linear regression and get to see it work on data. Before starting on this programming exercise, we strongly recommend watching the video lectures and completing the review questions for the associated topics.\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, and [`matplotlib`](https://matplotlib.org/) for plotting.\n", + "\n", + "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": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (utils.py, line 7)", + "output_type": "error", + "traceback": [ + "Traceback \u001b[1;36m(most recent call last)\u001b[0m:\n", + " File \u001b[0;32m\"C:\\Users\\DELL\\anaconda3\\lib\\site-packages\\IPython\\core\\interactiveshell.py\"\u001b[0m, line \u001b[0;32m3331\u001b[0m, in \u001b[0;35mrun_code\u001b[0m\n exec(code_obj, self.user_global_ns, self.user_ns)\n", + "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m12\u001b[1;36m, in \u001b[1;35m\u001b[1;36m\u001b[0m\n\u001b[1;33m import utils\u001b[0m\n", + "\u001b[1;36m File \u001b[1;32m\"C:\\Users\\DELL\\Documents\\utils.py\"\u001b[1;36m, line \u001b[1;32m7\u001b[0m\n\u001b[1;33m \u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "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", + "from mpl_toolkits.mplot3d import Axes3D # needed to plot 3-D surfaces\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", + "After completing each part of the assignment, be sure to submit your solutions to the grader.\n", + "\n", + "For this programming exercise, you are only required to complete the first part of the exercise to implement linear regression with one variable. The second part of the exercise, which is optional, covers linear regression with multiple variables. The following is a breakdown of how each part of this exercise is scored.\n", + "\n", + "**Required Exercises**\n", + "\n", + "| Section | Part |Submitted Function | Points \n", + "|---------|:- |:- | :-: \n", + "| 1 | [Warm up exercise](#section1) | [`warmUpExercise`](#warmUpExercise) | 10 \n", + "| 2 | [Compute cost for one variable](#section2) | [`computeCost`](#computeCost) | 20 \n", + "| 3 | [Gradient descent for one variable](#section3) | [`gradientDescent`](#gradientDescent) | 20 \n", + "| 4 | [Feature normalization](#section4) | [`featureNormalize`](#featureNormalize) | 10 |\n", + "| 5 | [Compute cost for multiple variables](#section5) | [`computeCostMulti`](#computeCostMulti) | 20 |\n", + "| 6 | [Gradient descent for multiple variables](#section5) | [`gradientDescentMulti`](#gradientDescentMulti) |10 |\n", + "| 7 | [Normal Equations](#section7) | [`normalEqn`](#normalEqn) | 10 |\n", + "| | Total Points | | 100 \n", + "\n", + "You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n", + "\n", + "
\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. They must also be re-executed everytime the submitted function is updated.\n", + "
\n", + "\n", + "\n", + "## Debugging\n", + "\n", + "Here are some things to keep in mind throughout this exercise:\n", + "\n", + "- Python array indices start from zero, not one (contrary to OCTAVE/MATLAB). \n", + "\n", + "- There is an important distinction between python arrays (called `list` or `tuple`) and `numpy` arrays. You should use `numpy` arrays in all your computations. Vector/matrix operations work only with `numpy` arrays. Python lists do not support vector operations (you need to use for loops).\n", + "\n", + "- If you are seeing many errors at runtime, inspect your matrix operations to make sure that you are adding and multiplying matrices of compatible dimensions. Printing the dimensions of `numpy` arrays using the `shape` property will help you debug.\n", + "\n", + "- By default, `numpy` interprets math operators to be element-wise operators. If you want to do matrix multiplication, you need to use the `dot` function in `numpy`. For, example if `A` and `B` are two `numpy` matrices, then the matrix operation AB is `np.dot(A, B)`. Note that for 2-dimensional matrices or vectors (1-dimensional), this is also equivalent to `A@B` (requires python >= 3.5)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1 Simple python and `numpy` function\n", + "\n", + "The first part of this assignment gives you practice with python and `numpy` syntax and the homework submission process. In the next cell, you will find the outline of a `python` function. Modify it to return a 5 x 5 identity matrix by filling in the following code:\n", + "\n", + "```python\n", + "A = np.eye(5)\n", + "```\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def warmUpExercise():\n", + " \"\"\"\n", + " Example function in Python which computes the identity matrix.\n", + " \n", + " Returns\n", + " -------\n", + " A : array_like\n", + " The 5x5 identity matrix.\n", + " \n", + " Instructions\n", + " ------------\n", + " Return the 5x5 identity matrix.\n", + " \"\"\" \n", + " # ======== YOUR CODE HERE ======\n", + " A = np.eye(5) # modify this line\n", + " \n", + " # ==============================\n", + " return A" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The previous cell only defines the function `warmUpExercise`. We can now run it by executing the following cell to see its output. You should see output similar to the following:\n", + "\n", + "```python\n", + "array([[ 1., 0., 0., 0., 0.],\n", + " [ 0., 1., 0., 0., 0.],\n", + " [ 0., 0., 1., 0., 0.],\n", + " [ 0., 0., 0., 1., 0.],\n", + " [ 0., 0., 0., 0., 1.]])\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 0., 0., 0., 0.],\n", + " [0., 1., 0., 0., 0.],\n", + " [0., 0., 1., 0., 0.],\n", + " [0., 0., 0., 1., 0.],\n", + " [0., 0., 0., 0., 1.]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "warmUpExercise()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1 Submitting solutions\n", + "\n", + "After completing a part of the exercise, you can submit your solutions for grading by first adding the function you modified to the grader object, and then sending your function to Coursera for grading. \n", + "\n", + "The grader will prompt you for your login e-mail and submission token. You can obtain a submission token from the web page for the assignment. You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n", + "\n", + "Execute the next cell to grade your solution to the first part of this exercise.\n", + "\n", + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'grader' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# appends the implemented function in part 1 to the grader object\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mgrader\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mwarmUpExercise\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;31m# send the added functions to coursera grader for getting a grade on this part\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mgrader\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgrade\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mNameError\u001b[0m: name 'grader' is not defined" + ] + } + ], + "source": [ + "# appends the implemented function in part 1 to the grader object\n", + "grader[1] = warmUpExercise\n", + "\n", + "# send the added functions to coursera grader for getting a grade on this part\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2 Linear regression with one variable\n", + "\n", + "Now you will implement linear regression with one variable to predict profits for a food truck. Suppose you are the CEO of a restaurant franchise and are considering different cities for opening a new outlet. The chain already has trucks in various cities and you have data for profits and populations from the cities. You would like to use this data to help you select which city to expand to next. \n", + "\n", + "The file `Data/ex1data1.txt` contains the dataset for our linear regression problem. The first column is the population of a city (in 10,000s) and the second column is the profit of a food truck in that city (in $10,000s). A negative value for profit indicates a loss. \n", + "\n", + "We provide you with the code needed to load this data. The dataset is loaded from the data file into the variables `x` and `y`:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Read comma separated data\n", + "data = np.loadtxt(os.path.join('Data', 'ex1data1.txt'), delimiter=',')\n", + "X, y = data[:, 0], data[:, 1]\n", + "\n", + "\n", + "m = y.size # number of training examples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.1 Plotting the Data\n", + "\n", + "Before starting on any task, it is often useful to understand the data by visualizing it. For this dataset, you can use a scatter plot to visualize the data, since it has only two properties to plot (profit and population). Many other problems that you will encounter in real life are multi-dimensional and cannot be plotted on a 2-d plot. There are many plotting libraries in python (see this [blog post](https://blog.modeanalytics.com/python-data-visualization-libraries/) for a good summary of the most popular ones). \n", + "\n", + "In this course, we will be exclusively using `matplotlib` to do all our plotting. `matplotlib` is one of the most popular scientific plotting libraries in python and has extensive tools and functions to make beautiful plots. `pyplot` is a module within `matplotlib` which provides a simplified interface to `matplotlib`'s most common plotting tasks, mimicking MATLAB's plotting interface.\n", + "\n", + "
\n", + "You might have noticed that we have imported the `pyplot` module at the beginning of this exercise using the command `from matplotlib import pyplot`. This is rather uncommon, and if you look at python code elsewhere or in the `matplotlib` tutorials, you will see that the module is named `plt`. This is used by module renaming by using the import command `import matplotlib.pyplot as plt`. We will not using the short name of `pyplot` module in this class exercises, but you should be aware of this deviation from norm.\n", + "
\n", + "\n", + "\n", + "In the following part, your first job is to complete the `plotData` function below. Modify the function and fill in the following code:\n", + "\n", + "```python\n", + " pyplot.plot(x, y, 'ro', ms=10, mec='k')\n", + " pyplot.ylabel('Profit in $10,000')\n", + " pyplot.xlabel('Population of City in 10,000s')\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def plotData(x, y):\n", + " \"\"\"\n", + " Plots the data points x and y into a new figure. Plots the data \n", + " points and gives the figure axes labels of population and profit.\n", + " \n", + " Parameters\n", + " ----------\n", + " x : array_like\n", + " Data point values for x-axis.\n", + "\n", + " y : array_like\n", + " Data point values for y-axis. Note x and y should have the same size.\n", + " \n", + " Instructions\n", + " ------------\n", + " Plot the training data into a figure using the \"figure\" and \"plot\"\n", + " functions. Set the axes labels using the \"xlabel\" and \"ylabel\" functions.\n", + " Assume the population and revenue data have been passed in as the x\n", + " and y arguments of this function. \n", + " \n", + " Hint\n", + " ----\n", + " You can use the 'ro' option with plot to have the markers\n", + " appear as red circles. Furthermore, you can make the markers larger by\n", + " using plot(..., 'ro', ms=10), where `ms` refers to marker size. You \n", + " can also set the marker edge color using the `mec` property.\n", + " \"\"\"\n", + " fig = pyplot.figure() # open a new figure\n", + " \n", + " # ====================== YOUR CODE HERE ======================= \n", + " fig=pyplot.plot(x, y, 'ro', ms=10, mec='k')\n", + " pyplot.ylabel('Profit in $10,000')\n", + " pyplot.xlabel('Population of City in 10,000s')\n", + " pyplot.show()\n", + " \n", + "\n", + " # =============================================================\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now run the defined function with the loaded data to visualize the data. The end result should look like the following figure:\n", + "\n", + "![](Figures/dataset1.png)\n", + "\n", + "Execute the next cell to visualize the data." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plotData(X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To quickly learn more about the `matplotlib` plot function and what arguments you can provide to it, you can type `?pyplot.plot` in a cell within the jupyter notebook. This opens a separate page showing the documentation for the requested function. You can also search online for plotting documentation. \n", + "\n", + "To set the markers to red circles, we used the option `'or'` within the `plot` function." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "?pyplot.plot" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 2.2 Gradient Descent\n", + "\n", + "In this part, you will fit the linear regression parameters $\\theta$ to our dataset using gradient descent.\n", + "\n", + "#### 2.2.1 Update Equations\n", + "\n", + "The objective of linear regression is to minimize the cost function\n", + "\n", + "$$ J(\\theta) = \\frac{1}{2m} \\sum_{i=1}^m \\left( h_{\\theta}(x^{(i)}) - y^{(i)}\\right)^2$$\n", + "\n", + "where the hypothesis $h_\\theta(x)$ is given by the linear model\n", + "$$ h_\\theta(x) = \\theta^Tx = \\theta_0 + \\theta_1 x_1$$\n", + "\n", + "Recall that the parameters of your model are the $\\theta_j$ values. These are\n", + "the values you will adjust to minimize cost $J(\\theta)$. One way to do this is to\n", + "use the batch gradient descent algorithm. In batch gradient descent, each\n", + "iteration performs the update\n", + "\n", + "$$ \\theta_j = \\theta_j - \\alpha \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta(x^{(i)}) - y^{(i)}\\right)x_j^{(i)} \\qquad \\text{simultaneously update } \\theta_j \\text{ for all } j$$\n", + "\n", + "With each step of gradient descent, your parameters $\\theta_j$ come closer to the optimal values that will achieve the lowest cost J($\\theta$).\n", + "\n", + "
\n", + "**Implementation Note:** We store each example as a row in the the $X$ matrix in Python `numpy`. To take into account the intercept term ($\\theta_0$), we add an additional first column to $X$ and set it to all ones. This allows us to treat $\\theta_0$ as simply another 'feature'.\n", + "
\n", + "\n", + "\n", + "#### 2.2.2 Implementation\n", + "\n", + "We have already set up the data for linear regression. In the following cell, we add another dimension to our data to accommodate the $\\theta_0$ intercept term. Do NOT execute this cell more than once." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "#### 2.2.3 Computing the cost $J(\\theta)$\n", + "\n", + "As you perform gradient descent to learn minimize the cost function $J(\\theta)$, it is helpful to monitor the convergence by computing the cost. In this section, you will implement a function to calculate $J(\\theta)$ so you can check the convergence of your gradient descent implementation. \n", + "\n", + "Your next task is to complete the code for the function `computeCost` which computes $J(\\theta)$. As you are doing this, remember that the variables $X$ and $y$ are not scalar values. $X$ is a matrix whose rows represent the examples from the training set and $y$ is a vector whose each elemennt represent the value at a given row of $X$.\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Add a column of ones to X. The numpy function stack joins arrays along a given axis. \n", + "# The first axis (axis=0) refers to rows (training examples) \n", + "# and second axis (axis=1) refers to columns (features).\n", + "X = np.stack([np.ones(m), X], axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def computeCost(X, y, theta):\n", + " \"\"\"\n", + " Compute cost for linear regression. Computes the cost of using theta as the\n", + " parameter for linear regression to fit the data points in X and y.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The input dataset of shape (m x n+1), where m is the number of examples,\n", + " and n is the number of features. We assume a vector of one's already \n", + " appended to the features so we have n+1 columns.\n", + " \n", + " y : array_like\n", + " The values of the function at each data point. This is a vector of\n", + " shape (m, ).\n", + " \n", + " theta : array_like\n", + " The parameters for the regression function. This is a vector of \n", + " shape (n+1, ).\n", + " \n", + " Returns\n", + " -------\n", + " J : float\n", + " The value of the regression cost function.\n", + " \n", + " Instructions\n", + " ------------\n", + " Compute the cost of a particular choice of theta. \n", + " You should set J to the cost.\n", + " \"\"\"\n", + " \n", + " # initialize some useful values\n", + " m = y.size # number of training examples\n", + " \n", + " # You need to return the following variables correctly\n", + " J = 0\n", + " \n", + " # ====================== YOUR CODE HERE =====================\n", + " c = X*theta\n", + " for i in range(y.size):\n", + " new = (sum(c[i])-y[i])**2\n", + " J = J + new\n", + " J = J /(2*m)\n", + " \n", + " # ===========================================================\n", + " return J" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you have completed the function, the next step will run `computeCost` two times using two different initializations of $\\theta$. You will see the cost printed to the screen." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "With theta = [0, 0] \n", + "Cost computed = 32.07\n", + "Expected cost value (approximately) 32.07\n", + "\n", + "With theta = [-1, 2]\n", + "Cost computed = 54.24\n", + "Expected cost value (approximately) 54.24\n" + ] + } + ], + "source": [ + "J = computeCost(X, y, theta=np.array([0.0, 0.0]))\n", + "print('With theta = [0, 0] \\nCost computed = %.2f' % J)\n", + "print('Expe​([0.0, 0.0]))cted cost value (approximately) 32.07\\n')\n", + "\n", + "# further testing of the cost function\n", + "J = computeCost(X, y, theta=np.array([-1, 2]))\n", + "print('With theta = [-1, 2]\\nCost computed = %.2f' % J)\n", + "print('Expected cost value (approximately) 54.24')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions by executing the following cell.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[2] = computeCost\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "#### 2.2.4 Gradient descent\n", + "\n", + "Next, you will complete a function which implements gradient descent.\n", + "The loop structure has been written for you, and you only need to supply the updates to $\\theta$ within each iteration. \n", + "\n", + "As you program, make sure you understand what you are trying to optimize and what is being updated. Keep in mind that the cost $J(\\theta)$ is parameterized by the vector $\\theta$, not $X$ and $y$. That is, we minimize the value of $J(\\theta)$ by changing the values of the vector $\\theta$, not by changing $X$ or $y$. [Refer to the equations in this notebook](#section2) and to the video lectures if you are uncertain. A good way to verify that gradient descent is working correctly is to look at the value of $J(\\theta)$ and check that it is decreasing with each step. \n", + "\n", + "The starter code for the function `gradientDescent` calls `computeCost` on every iteration and saves the cost to a `python` list. Assuming you have implemented gradient descent and `computeCost` correctly, your value of $J(\\theta)$ should never increase, and should converge to a steady value by the end of the algorithm.\n", + "\n", + "
\n", + "**Vectors and matrices in `numpy`** - Important implementation notes\n", + "\n", + "A vector in `numpy` is a one dimensional array, for example `np.array([1, 2, 3])` is a vector. A matrix in `numpy` is a two dimensional array, for example `np.array([[1, 2, 3], [4, 5, 6]])`. However, the following is still considered a matrix `np.array([[1, 2, 3]])` since it has two dimensions, even if it has a shape of 1x3 (which looks like a vector).\n", + "\n", + "Given the above, the function `np.dot` which we will use for all matrix/vector multiplication has the following properties:\n", + "- It always performs inner products on vectors. If `x=np.array([1, 2, 3])`, then `np.dot(x, x)` is a scalar.\n", + "- For matrix-vector multiplication, so if $X$ is a $m\\times n$ matrix and $y$ is a vector of length $m$, then the operation `np.dot(y, X)` considers $y$ as a $1 \\times m$ vector. On the other hand, if $y$ is a vector of length $n$, then the operation `np.dot(X, y)` considers $y$ as a $n \\times 1$ vector.\n", + "- A vector can be promoted to a matrix using `y[None]` or `[y[np.newaxis]`. That is, if `y = np.array([1, 2, 3])` is a vector of size 3, then `y[None, :]` is a matrix of shape $1 \\times 3$. We can use `y[:, None]` to obtain a shape of $3 \\times 1$.\n", + "
\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def gradientDescent(X, y, theta, alpha, num_iters):\n", + " \"\"\"\n", + " Performs gradient descent to learn `theta`. Updates theta by taking `num_iters`\n", + " gradient steps with learning rate `alpha`.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The input dataset of shape (m x n+1).\n", + " \n", + " y : arra_like\n", + " Value at given features. A vector of shape (m, ).\n", + " \n", + " theta : array_like\n", + " Initial values for the linear regression parameters. \n", + " A vector of shape (n+1, ).\n", + " \n", + " alpha : float\n", + " The learning rate.\n", + " \n", + " num_iters : int\n", + " The number of iterations for gradient descent. \n", + " \n", + " Returns\n", + " -------\n", + " theta : array_like\n", + " The learned linear regression parameters. A vector of shape (n+1, ).\n", + " \n", + " J_history : list\n", + " A python list for the values of the cost function after each iteration.\n", + " \n", + " Instructions\n", + " ------------\n", + " Peform a single gradient step on the parameter vector theta.\n", + "\n", + " While debugging, it can be useful to print out the values of \n", + " the cost function (computeCost) and gradient here.\n", + " \"\"\"\n", + " # Initialize some useful values\n", + " m = y.shape[0] # number of training examples\n", + " \n", + " # make a copy of theta, to avoid changing the original array, since numpy arrays\n", + " # are passed by reference to functions\n", + " theta = theta.copy()\n", + " \n", + " J_history = [] # Use a python list to save cost in every iteration\n", + " K=0\n", + " for i in range(num_iters):\n", + " \n", + " # ==================== YOUR CODE HERE =================================\n", + " #theta = theta - K*np.ones(2)\n", + " f = X*theta\n", + " #print(f)\n", + " P = 0\n", + " for j in range(y.size):\n", + " l = (sum(f[j])-y[j])*X[j,1]\n", + " P = P+l\n", + " K = (alpha*P)/m\n", + " theta = theta - K*np.ones(2)\n", + " #print(theta)\n", + " \n", + " \n", + "\n", + " # =====================================================================\n", + " \n", + " # save the cost J in every iteration\n", + " J_history.append(computeCost(X, y, theta))\n", + " \n", + " return theta, J_history" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After you are finished call the implemented `gradientDescent` function and print the computed $\\theta$. We initialize the $\\theta$ parameters to 0 and the learning rate $\\alpha$ to 0.01. Execute the following cell to check your code." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Theta found by gradient descent: 0.7294, 0.7294\n", + "Expected theta values (approximately): [-3.6303, 1.1664]\n" + ] + } + ], + "source": [ + "# initialize fitting parameters\n", + "theta = np.zeros(2)\n", + "\n", + "# some gradient descent settings\n", + "iterations = 10\n", + "alpha = 0.01\n", + "\n", + "theta, J_history = gradientDescent(X ,y, theta, alpha, iterations)\n", + "print('Theta found by gradient descent: {:.4f}, {:.4f}'.format(*theta))\n", + "print('Expected theta values (approximately): [-3.6303, 1.1664]')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use your final parameters to plot the linear fit. The results should look like the following figure.\n", + "\n", + "![](Figures/regression_result.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD4CAYAAADxeG0DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAbiElEQVR4nO3deXhU9dn/8fctqyiIbC4gBlBQoCIYqQgqgiDgWrXPr1QfFa2p1dr6+GjFQsHiRlttta3VUgXUUtSqrbYiirSuPIIEQRZlUVCjrFZAQYTA/fsjQ8wMmWSYzMw5Z+bzui6uzHzPd3JuJocPd8425u6IiEh07RN0ASIiUjcKchGRiFOQi4hEnIJcRCTiFOQiIhFXP5cra9WqlRcVFeVylSIikVdaWrrB3VsnW57TIC8qKmLu3Lm5XKWISOSZ2Qc1LdeuFRGRiFOQi4hEnIJcRCTicrqPvDo7duygrKyMbdu2BV2KVNG4cWPatWtHgwYNgi5FRGoReJCXlZXRtGlTioqKMLOgyxHA3fn0008pKyujQ4cOQZcjIrUIfNfKtm3baNmypUI8RMyMli1b6rckkYgIPMgBhXgI6WciEh2hCHIRkXz1/vovOPfe19m2Y2fW1lHwQf7pp59y7LHHcuyxx3LwwQfTtm3byufbt29P6XuMGDGCpUuX1jjn3nvvZcqUKZkoOc6LL77IueeeW+OcefPmMX369IyvW0SSc3eumlLKgLteZv5HG1nw0casrSvwg51Ba9myJfPnzwfg5ptvZv/99+f666+Pm+PuuDv77FP9/3uTJk2qdT1XX3113YtN07x581i0aBFDhgwJrAaRQrKwbBNn/f61yue/+X89+GbHlllbX8F35MmsWLGC7t27c+WVV9KrVy9Wr15NSUkJxcXFdOvWjXHjxlXO7devH/Pnz6e8vJzmzZszcuRIevToQZ8+fVi3bh0Ao0eP5u67766cP3LkSHr37k2XLl2YNWsWAFu2bOH888+nR48eDB8+nOLi4sr/ZKp69tln6dKlC/369ePpp5+uHH/jjTfo06cPPXv2pG/fvixfvpwvv/yScePGMWXKFI499lieeOKJaueJSN3t2uWcf9+syhBvtX8jlt46hG/1bJfV9YaqI//5Pxaz5JPNGf2eXQ9txtizuqX12iVLljBp0iTuv/9+AMaPH0+LFi0oLy/n1FNP5YILLqBr165xr9m0aROnnHIK48eP57rrrmPixImMHDlyj+/t7syZM4dnnnmGcePGMX36dH73u99x8MEH8+STT7JgwQJ69eq1x+u2bt3K97//fV5++WU6duzIBRdcULns6KOP5rXXXqNevXpMnz6d0aNH89hjjzFmzBgWLVpU+R/Jpk2bqp0nIul7fcUGLnxgduXzySOOp3+XNjlZd6iCPGw6derE8ccfX/l86tSpPPjgg5SXl/PJJ5+wZMmSPYJ83333ZejQoQAcd9xxvPrqq9V+7/POO69yzqpVqwB47bXXuPHGGwHo0aMH3brt+R/QkiVL6Ny5M506dQLgwgsv5OGHHwZg48aNXHzxxbz33ns1/r1SnScitduxcxf9f/USH2/8EoBuhzbjmR/2o94+uTvzK1RBnm7nnC377bdf5ePly5dzzz33MGfOHJo3b85FF11U7XnWDRs2rHxcr149ysvLq/3ejRo12mNOqh+EnezUwFGjRnH66adz1VVXsWLFiqT7xFOdJyI1e/bt1Vz9l3mVz5+66kR6tT8w53VoH3mKNm/eTNOmTWnWrBmrV6/m+eefz/g6+vXrx+OPPw7AwoULWbJkyR5zunbtyrJly1i5ciXuztSpUyuXbdq0ibZt2wIwefLkyvGmTZvy+eef1zpPRFKzdXs5R46aVhniA45qw8o7hgUS4qAgT1mvXr3o2rUr3bt354orrqBv374ZX8c111zDxx9/zDHHHMNdd91F9+7dOeCAA+LmNGnShPvvv5+hQ4dy0kkn0bFjx8plN954IzfccMMetQ0YMIAFCxbQs2dPnnjiiaTzRKR2j7zxAV3HPM+OnRW/Qc/4n5OZeOnxgV5EZ6n+Op8JxcXFnvjBEu+88w5HH310zmoIs/LycsrLy2ncuDHLly9n8ODBLF++nPr1g9kDpp+NyNc+27KdnrfMqHw+vPdh3HHeMTlZt5mVuntxsuWh2kde6L744gsGDhxIeXk57s4f//jHwEJcRL5294vLuPvFr0/TfX3kANo23zfAiuIpJUKkefPmlJaWBl2GiMTM+/AzzvvDrMrnPxp4JNcN6hxgRdULRZC7u27SFDK53OUmEkZFI5+Nez7vZ4NosV/DJLODVevBTjObaGbrzGxRwvg1ZrbUzBab2S/TLaBx48Z8+umnCo4Q2X0/8saNGwddikjOPb94TVyId2q9H6vGnxHaEIfUOvLJwO+Bh3cPmNmpwDnAMe7+lZmlfflSu3btKCsrY/369el+C8mC3Z8QJFIo3J0ON02LG5szaiBtmoa/oak1yN39FTMrShj+ATDe3b+KzVmXbgENGjTQp9CISKAemrWKsc8srnw+uOtBTLg46UkioZPuPvLOwElmdhuwDbje3d+sbqKZlQAlAO3bt09zdSIimVe+cxdHjHoubmzxz09nv0ahOHyYsnQvCKoPHAicANwAPG5Jjla6+wR3L3b34tatW6e5OhGRzLrt2SVxIV5yckdWjT8jciEO6XfkZcBTXnGEco6Z7QJaAdrRLSKhtuWrcrqNjb/FxorbhlK/XnQvdE83yP8ODABeMrPOQENgQ8aqEhHJgisensuMJWsrn487pxsX9ykKrqAMqTXIzWwq0B9oZWZlwFhgIjAxdkriduAS1/mDIhJS6z7fRu/bZsaNrbxjWN5cv5LKWSvDkyy6KMO1iIhk3IA7X+L9DVsqn0/47+MY3O3gACvKvOjt1RcRScGMJWu54uH4m/StGn9GQNVkl4JcRPJO4uX1T/6gD8cd3iKgarJPQS4ieePef6/gV88vjRvL1y68KgW5iOSFxC78oct6c0rnwrh2RUEuIpF21ZRSpi1cEzdWCF14VQpyEYmkXbucjj+Nv8nVi9edwhFt9g+oouAoyEUkcr55+4us3fxV3FihdeFVKchFJDK2bi+n65j4y+vf+tkgDgzxvcJzQUEuIpGQeDATCrsLr0pBLiKhtnrTl/S5419xY8tuHUrD+tG9yVWmKchFJLQSu/BjD2vO36/uG1A14aUgF5HQeevDz/hWlU+vh/y6yVWmKchFJFQSu/BLTyzi5rO7BVRNNCjIRSQUnp7/MT9+dH7cmA5mpkZBLiKBS+zC7zjvGwzvrc/4TZWCXEQC8/N/LGbS66vixtSF7z0FuYgEIrELn3rFCfTp1DKgaqJNQS4iOaULezJPQS4iOVG+cxdHjHoubuzpq/vS47DmAVWUPxTkIpJ16sKzS0EuIlnzny3b6XXLjLixN0edRuumjQKqKD8pyEUkK9SF506td50xs4lmts7MFlWz7HozczNrlZ3yRCRqFn28aY8QX3brUIV4FqXSkU8Gfg88XHXQzA4DBgEfZr4sEYkideHBqDXI3f0VMyuqZtFvgJ8AT2e4JhGJmL+/9THXPqbL64OS1j5yMzsb+NjdF9R2NzIzKwFKANq31yW3IvkmsQvvdmgznv3RSQFVU5j2OsjNrAkwChicynx3nwBMACguLva9XZ+IhNPNzyxm8qxVcWPqwoORTkfeCegA7O7G2wHzzKy3u6/JZHEiEk6JXfgVJ3Vg1BldA6pG9jrI3X0h0Gb3czNbBRS7+4YM1iUiITTo1y+zfN0XcWPqwoNXa5Cb2VSgP9DKzMqAse7+YLYLE5FwSezCf//dnpx5zKEBVSNVpXLWyvBalhdlrBoRCR2dUhh+urJTRKq1vXwXnUfH3+TquR+fxNGHNAuoIklGQS4ie1AXHi0KchGptG7zNnrfPjNubP6YQTRv0jCgiiQVCnIRAdSFR5mCXKTAlX7wGeffNytubMVtQ6lfr9Z76klIKMhFCpi68PygIBcpQI/O+ZCRTy2MG1OAR5eCXKTAJHbhJ3ZqyV+uOCGgaiQTFOQiBeKGvy7gr6VlcWPqwvODglykACR24deediTXntY5oGok0xTkInmszx0zWb1pW9yYuvD8oyAXyUPuToebpsWNPXBxMad1PSigiiSbFOQieUanFBYeBblInvhy+06OHjM9buzF607hiDb7B1SR5IqCXCQPqAsvbApykQgr+2wr/X7x77ixt28eTLPGDQKqSIKgIBeJKHXhspuCXCRiZr23ge/+aXbc2Pu3D2OffSygiiRoCnKRCEnswhvUM5bfNiygaiQsFOQiEfDgayu55Z9L4sa0G0V2U5CLhFxiFz6o60H86eLigKqRMFKQi4TUVVNKmbZwTdyYunCpjoJcJIQSu/CfDjuKkpM7BVSNhF2tQW5mE4EzgXXu3j029ivgLGA78B4wwt03ZrNQkULQfezzfPFVedyYunCpTSofyjcZGJIwNgPo7u7HAMuAmzJcl0hB2bXLKRr5bFyI//nybyrEJSW1duTu/oqZFSWMvVDl6RvABZktS6Rw6MIeqatM7CO/DHgs2UIzKwFKANq3b5+B1Ynkhy++Kqf72Ofjxl79yakc1qJJQBVJVNUpyM1sFFAOTEk2x90nABMAiouLvS7rE8kX6sIlk9IOcjO7hIqDoAPdXQEtkoKVG7Zw6p0vxY0tGXc6TRrqBDJJX1pbj5kNAW4ETnH3rZktSSQ/qQuXbEnl9MOpQH+glZmVAWOpOEulETDDzADecPcrs1inSGT9e+k6Rkx6M25s5R3DiP3bEamzVM5aGV7N8INZqEUk7yR24a32b8jc0YMCqkbylXbMiWTBlNkfMOpvi+LGtBtFskVBLpJhiV34D/p34sYhRwVUjRQCBblIhtz01NtMnfNR3Ji6cMkFBblIBiR24b8b3pOzehwaUDVSaBTkInUw4K6XeH/9lrgxdeGSawpykTTs3OV0+um0uLF/XtOP7m0PCKgiKWQKcpG9pAt7JGwU5CIp+nzbDr5x8wtxY2+OOo3WTRsFVJFIBQW5SArUhUuYKchFarBs7ecM/s0rcWNLbx1Co/r1AqpIZE8KcpEk1IVLVCjIRRJMW7iaq6bMixvTTa4kzBTkIlUkduEdW+3Hv67vH0wxIilSkIsAv5j+Lve99F7cmHajSFQoyKXgJXbhF53QnlvP/UZA1YjsPQW5FKxv/eF13vpwY9yYunCJIgW5FKTELvzOb/fgguPaBVSNSN0oyKWg6JRCyUcKcikI28t30Xn0c3Fjz/ywL8e0ax5QRSKZoyCXvKcuXPKdglzy1rrN2+h9+8y4sdk/HchBzRoHVJFIdijIJS+pC5dCUmuQm9lE4Exgnbt3j421AB4DioBVwH+5+2fZK1MkNW+u+g/fvv//4saW3TqUhvX3CagikexLZeueDAxJGBsJzHT3I4GZsecigSoa+eweIb5q/BkKccl7tXbk7v6KmRUlDJ8D9I89fgh4Cbgxg3WJpOy3M5fz6xnL4sa0G0UKSbr7yA9y99UA7r7azNokm2hmJUAJQPv27dNcnUj1tC9cJAcHO919AjABoLi42LO9PikM5983i9IP4g/LKMClUKUb5GvN7JBYN34IsC6TRYnUJLEL79+lNZNH9A6oGpHgpRvkzwCXAONjX5/OWEUiSWg3ikj1Ujn9cCoVBzZbmVkZMJaKAH/czC4HPgS+nc0ipbC5Ox1umhY3NvqMo/neSR0DqkgkXFI5a2V4kkUDM1yLyB7UhYvUTld2Sih9uX0nR4+ZHjf21yv7cHxRi4AqEgkvBbmEjrpwkb2jIJfQWLVhC/3vfClubM6ogbRpqptcidREQS6hoC5cJH0KcgnUjCVrueLhuXFjK24bSv16uj+KSKoU5BIYdeEimaEgl5y78pFSpi9eEzemABdJn4JcckpduEjmKcglJxTgItmjI0qSdYkhftTBTRXiIhmkjlyyRl24SG4oyCXjqrvJ1XWDOvOjgUcGVJFIflOQS0apCxfJPQW5ZMSmrTvoMe6FuLFHS07ghI4tA6pIpHAoyKXO1IWLBEtBLmlb/Mkmzvjta3Fjc0efRqv9GwVUkUhhUpBLWtSFi4SHglz2yqNzPmTkUwvjxt6/fRj77GMBVSQiCnJJmbpwkXBSkEutrppSyrSFusmVSFgpyKVG6sJFwk9BLtVSgItEh26aJXtIDPEzvnGIQlwkxOrUkZvZ/wDfAxxYCIxw922ZKExyT124SDSl3ZGbWVvgR0Cxu3cH6gHfyVRhkjs7d/keIX7D6V0U4iIRUdd95PWBfc1sB9AE+KTuJUkuqQsXib60g9zdPzazO4EPgS+BF9z9hcR5ZlYClAC0b98+3dVJhq3bvI3et8+MG3vyB3047vAWAVUkIulKO8jN7EDgHKADsBH4q5ld5O5/rjrP3ScAEwCKi4u9DrVKhqgLF8kvddm1chqw0t3XA5jZU8CJwJ9rfJUEZuY7a7n8oblxY/PHDKJ5k4YBVSQimVCXIP8QOMHMmlCxa2UgMLfml0hQ1IWL5K+67COfbWZPAPOAcuAtYrtQJDxG/W0hU2Z/GDe28o5hmOkmVyL5ok5nrbj7WGBshmqRDFMXLlIYdIl+HlKAixQWXaKfZxTiIoVHHXmeUICLFC515HkgMcSbNa6vEBcpIOrII0xduIiAOvJI2rZj5x4hfumJRQpxkQKljjxi1IWLSCIFeUS8u2YzQ+5+NW7sL9/7Jice0SqgikQkLBTkEaAuXERqoiAPsT+8tIJfTl8aN7ZgzGAOaNIgoIpEJIwU5CGlLlxEUqUgD5nqAlw3uRKRmijIQ0RduIikQ0EeAgpwEakLXRAUMIW4iNSVOvKAKMBFJFPUkQdAIS4imaSOPIcU4CKSDerIc2Dj1u17hPjgrgcpxEUkI9SRZ5m6cBHJNgV5ljz79mqu/su8uLFJlx7PqUe1CagiEclXCvIsUBcuIrlUpyA3s+bAA0B3wIHL3P3/MlFYFA25+xXeXfN53JhuciUi2VbXjvweYLq7X2BmDYEmGagpktSFi0hQ0g5yM2sGnAxcCuDu24HtmSkrOhTgIhK0upx+2BFYD0wys7fM7AEz2y9DdUWCQlxEwqAuu1bqA72Aa9x9tpndA4wEflZ1kpmVACUA7du3r8PqwkMBLiJhUpeOvAwoc/fZsedPUBHscdx9grsXu3tx69at67C6cFCIi0jYpN2Ru/saM/vIzLq4+1JgILAkc6WFiwJcRMKqrmetXANMiZ2x8j4wou4lhYu70+GmaXuMK8RFJCzqFOTuPh8ozlAtoaMuXESiQDfNqkbZZ1v3CPFTu7RWiItIKOkS/QTqwkUkahTkMZNeX8nP/xF/rPaRy3tz0pHRP9NGRPKbghx14SISbQUd5NUF+DvjhrBvw3oBVCMikp6CDXJ14SKSLwouyBXgIpJvCur0Q4W4iOSjgujIFeAiks/yviNXiItIvsvbjlwBLiKFIu868l27XCEuIgUlrzpyBbiIFKK86MjXbt62R4hfM+AIhbiIFITId+TqwkWk0EU2yGet2MB3H5gdN/byDf05vGVBff6ziEg0g1xduIjI1yIV5C8sXkPJI6VxY+/dPox6+1hAFYmIBC8yQa4uXESkepEI8v99fEHccwW4iMjXInH64ZnHHALA2LO6KsRFRBJEoiPvrw8+FhFJKhIduZkOZoqIJFPnIDezemb2lpn9MxMFiYjI3slER/5j4J0MfB8A3D1T30pEpCDUKcjNrB1wBvBAZsrRbhQRkb1V1478buAnwK5kE8ysxMzmmtnc9evX13F1IiKSKO0gN7MzgXXuXlrTPHef4O7F7l7cunXrdFcnIiJJ1KUj7wucbWargEeBAWb254xUJSIiKUs7yN39Jndv5+5FwHeAf7n7RRmrTEREUpLTC4JKS0s3mNkHab68FbAhk/VkmerNvqjVrHqzK2r1Quo1H17TQovK6X5mNtfdi4OuI1WqN/uiVrPqza6o1QuZqzkSV3aKiEhyCnIRkYiLUpBPCLqAvaR6sy9qNave7IpavZChmiOzj1xERKoXpY5cRESqoSAXEYm40AW5ma0ys4VmNt/M5laz3Mzst2a2wszeNrNeQdQZq6VLrM7dfzab2bUJc/qb2aYqc8bkuMaJZrbOzBZVGWthZjPMbHns64FJXntJbM5yM7sk4Jp/ZWbvxn7mfzOz5kleW+P2k8N6bzazj6v83Iclee0QM1sa255HBljvY1VqXWVm85O8Noj39zAz+7eZvWNmi83sx7HxUG7HNdSbvW3Y3UP1B1gFtKph+TDgOcCAE4DZQdccq6sesAY4PGG8P/DPAOs6GegFLKoy9ktgZOzxSOAX1byuBfB+7OuBsccHBljzYKB+7PEvqqs5le0nh/XeDFyfwjbzHtARaAgsALoGUW/C8ruAMSF6fw8BesUeNwWWAV3Duh3XUG/WtuHQdeQpOAd42Cu8ATQ3s0OCLgoYCLzn7uleuZoV7v4K8J+E4XOAh2KPHwLOrealpwMz3P0/7v4ZMAMYkrVCq6iuZnd/wd3LY0/fANrlopZUJHmPU9EbWOHu77v7diruWXRORourRk31WsV9pP8LmJrtOlLl7qvdfV7s8edUfP5BW0K6HSerN5vbcBiD3IEXzKzUzEqqWd4W+KjK87LYWNC+Q/KNv4+ZLTCz58ysWy6LSuIgd18NFRsd0KaaOWF9nwEuo+K3surUtv3k0g9jv0ZPTPJrfxjf45OAte6+PMnyQN9fMysCegKzicB2nFBvVRndhsP44ct93f0TM2sDzDCzd2MdxG7VffJEoOdQmllD4GzgpmoWz6Nid8sXsf2kfweOzGV9aQrd+wxgZqOAcmBKkim1bT+5ch9wCxXv2S1U7K64LGFOGN/j4dTcjQf2/prZ/sCTwLXuvtlS+xCawN7jxHqrjGd8Gw5dR+7un8S+rgP+RsWvn1WVAYdVed4O+CQ31SU1FJjn7msTF7j7Znf/IvZ4GtDAzFrlusAEa3fvjop9XVfNnNC9z7EDVWcCF3psZ2KiFLafnHD3te6+0913AX9KUkeo3mMzqw+cBzyWbE5Q76+ZNaAiFKe4+1Ox4dBux0nqzdo2HKogN7P9zKzp7sdUHBxYlDDtGeBiq3ACsGn3r1cBStrFmNnBsf2OmFlvKt7zT3NYW3WeAXYfvb8EeLqaOc8Dg83swNhugcGxsUCY2RDgRuBsd9+aZE4q209OJBy3+VaSOt4EjjSzDrHf6r5Dxc8mKKcB77p7WXULg3p/Y/9+HgTecfdfV1kUyu04Wb1Z3YazefQ2jaO9Hak4cr8AWAyMio1fCVwZe2zAvVQc7V8IFAdccxMqgvmAKmNV6/1h7O+ygIoDHCfmuL6pwGpgBxXdyeVAS2AmsDz2tUVsbjHwQJXXXgasiP0ZEXDNK6jY1zk/9uf+2NxDgWk1bT8B1ftIbPt8m4rAOSSx3tjzYVSc1fBekPXGxifv3m6rzA3D+9uPit0hb1f5+Q8L63ZcQ71Z24Z1ib6ISMSFateKiIjsPQW5iEjEKchFRCJOQS4iEnEKchGRiFOQi4hEnIJcRCTi/j/c6pZBmytGYAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot the linear fit\n", + "plotData(X[:, 1], y)\n", + "pyplot.plot(X[:, 1], np.dot(X, theta), '-')\n", + "pyplot.legend(['Training data', 'Linear regression']);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Your final values for $\\theta$ will also be used to make predictions on profits in areas of 35,000 and 70,000 people.\n", + "\n", + "
\n", + "Note the way that the following lines use matrix multiplication, rather than explicit summation or looping, to calculate the predictions. This is an example of code vectorization in `numpy`.\n", + "
\n", + "\n", + "
\n", + "Note that the first argument to the `numpy` function `dot` is a python list. `numpy` can internally converts **valid** python lists to numpy arrays when explicitly provided as arguments to `numpy` functions.\n", + "
\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For population = 35,000, we predict a profit of 32823.53\n", + "\n", + "For population = 70,000, we predict a profit of 58352.94\n", + "\n" + ] + } + ], + "source": [ + "# Predict values for population sizes of 35,000 and 70,000\n", + "predict1 = np.dot([1, 3.5], theta)\n", + "print('For population = 35,000, we predict a profit of {:.2f}\\n'.format(predict1*10000))\n", + "\n", + "predict2 = np.dot([1, 7], theta)\n", + "print('For population = 70,000, we predict a profit of {:.2f}\\n'.format(predict2*10000))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions by executing the next cell.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[3] = gradientDescent\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.4 Visualizing $J(\\theta)$\n", + "\n", + "To understand the cost function $J(\\theta)$ better, you will now plot the cost over a 2-dimensional grid of $\\theta_0$ and $\\theta_1$ values. You will not need to code anything new for this part, but you should understand how the code you have written already is creating these images.\n", + "\n", + "In the next cell, the code is set up to calculate $J(\\theta)$ over a grid of values using the `computeCost` function that you wrote. After executing the following cell, you will have a 2-D array of $J(\\theta)$ values. Then, those values are used to produce surface and contour plots of $J(\\theta)$ using the matplotlib `plot_surface` and `contourf` functions. The plots should look something like the following:\n", + "\n", + "![](Figures/cost_function.png)\n", + "\n", + "The purpose of these graphs is to show you how $J(\\theta)$ varies with changes in $\\theta_0$ and $\\theta_1$. The cost function $J(\\theta)$ is bowl-shaped and has a global minimum. (This is easier to see in the contour plot than in the 3D surface plot). This minimum is the optimal point for $\\theta_0$ and $\\theta_1$, and each step of gradient descent moves closer to this point." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# grid over which we will calculate J\n", + "theta0_vals = np.linspace(-10, 10, 100)\n", + "theta1_vals = np.linspace(-1, 4, 100)\n", + "\n", + "# initialize J_vals to a matrix of 0's\n", + "J_vals = np.zeros((theta0_vals.shape[0], theta1_vals.shape[0]))\n", + "\n", + "# Fill out J_vals\n", + "for i, theta0 in enumerate(theta0_vals):\n", + " for j, theta1 in enumerate(theta1_vals):\n", + " J_vals[i, j] = computeCost(X, y, [theta0, theta1])\n", + " \n", + "# Because of the way meshgrids work in the surf command, we need to\n", + "# transpose J_vals before calling surf, or else the axes will be flipped\n", + "J_vals = J_vals.T\n", + "\n", + "# surface plot\n", + "fig = pyplot.figure(figsize=(12, 5))\n", + "ax = fig.add_subplot(121, projection='3d')\n", + "ax.plot_surface(theta0_vals, theta1_vals, J_vals, cmap='viridis')\n", + "pyplot.xlabel('theta0')\n", + "pyplot.ylabel('theta1')\n", + "pyplot.title('Surface')\n", + "\n", + "# contour plot\n", + "# Plot J_vals as 15 contours spaced logarithmically between 0.01 and 100\n", + "ax = pyplot.subplot(122)\n", + "pyplot.contour(theta0_vals, theta1_vals, J_vals, linewidths=2, cmap='viridis', levels=np.logspace(-2, 3, 20))\n", + "pyplot.xlabel('theta0')\n", + "pyplot.ylabel('theta1')\n", + "pyplot.plot(theta[0], theta[1], 'ro', ms=10, lw=2)\n", + "pyplot.title('Contour, showing minimum')\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optional Exercises\n", + "\n", + "If you have successfully completed the material above, congratulations! You now understand linear regression and should able to start using it on your own datasets.\n", + "\n", + "For the rest of this programming exercise, we have included the following optional exercises. These exercises will help you gain a deeper understanding of the material, and if you are able to do so, we encourage you to complete them as well. You can still submit your solutions to these exercises to check if your answers are correct.\n", + "\n", + "## 3 Linear regression with multiple variables\n", + "\n", + "In this part, you will implement linear regression with multiple variables to predict the prices of houses. Suppose you are selling your house and you want to know what a good market price would be. One way to do this is to first collect information on recent houses sold and make a model of housing prices.\n", + "\n", + "The file `Data/ex1data2.txt` contains a training set of housing prices in Portland, Oregon. The first column is the size of the house (in square feet), the second column is the number of bedrooms, and the third column is the price\n", + "of the house. \n", + "\n", + "\n", + "### 3.1 Feature Normalization\n", + "\n", + "We start by loading and displaying some values from this dataset. By looking at the values, note that house sizes are about 1000 times the number of bedrooms. When features differ by orders of magnitude, first performing feature scaling can make gradient descent converge much more quickly." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Load data\n", + "data = np.loadtxt(os.path.join('Data', 'ex1data2.txt'), delimiter=',')\n", + "X = data[:, :2]\n", + "y = data[:, 2]\n", + "m = y.size\n", + "\n", + "# print out some data points\n", + "print('{:>8s}{:>8s}{:>10s}'.format('X[:,0]', 'X[:, 1]', 'y'))\n", + "print('-'*26)\n", + "for i in range(10):\n", + " print('{:8.0f}{:8.0f}{:10.0f}'.format(X[i, 0], X[i, 1], y[i]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Your task here is to complete the code in `featureNormalize` function:\n", + "- Subtract the mean value of each feature from the dataset.\n", + "- After subtracting the mean, additionally scale (divide) the feature values by their respective “standard deviations.”\n", + "\n", + "The standard deviation is a way of measuring how much variation there is in the range of values of a particular feature (most data points will lie within ±2 standard deviations of the mean); this is an alternative to taking the range of values (max-min). In `numpy`, you can use the `std` function to compute the standard deviation. \n", + "\n", + "For example, the quantity `X[:, 0]` contains all the values of $x_1$ (house sizes) in the training set, so `np.std(X[:, 0])` computes the standard deviation of the house sizes.\n", + "At the time that the function `featureNormalize` is called, the extra column of 1’s corresponding to $x_0 = 1$ has not yet been added to $X$. \n", + "\n", + "You will do this for all the features and your code should work with datasets of all sizes (any number of features / examples). Note that each column of the matrix $X$ corresponds to one feature.\n", + "\n", + "
\n", + "**Implementation Note:** When normalizing the features, it is important\n", + "to store the values used for normalization - the mean value and the standard deviation used for the computations. After learning the parameters\n", + "from the model, we often want to predict the prices of houses we have not\n", + "seen before. Given a new x value (living room area and number of bedrooms), we must first normalize x using the mean and standard deviation that we had previously computed from the training set.\n", + "
\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def featureNormalize(X):\n", + " \"\"\"\n", + " Normalizes the features in X. returns a normalized version of X where\n", + " the mean value of each feature is 0 and the standard deviation\n", + " is 1. This is often a good preprocessing step to do when working with\n", + " learning algorithms.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The dataset of shape (m x n).\n", + " \n", + " Returns\n", + " -------\n", + " X_norm : array_like\n", + " The normalized dataset of shape (m x n).\n", + " \n", + " Instructions\n", + " ------------\n", + " First, for each feature dimension, compute the mean of the feature\n", + " and subtract it from the dataset, storing the mean value in mu. \n", + " Next, compute the standard deviation of each feature and divide\n", + " each feature by it's standard deviation, storing the standard deviation \n", + " in sigma. \n", + " \n", + " Note that X is a matrix where each column is a feature and each row is\n", + " an example. You needto perform the normalization separately for each feature. \n", + " \n", + " Hint\n", + " ----\n", + " You might find the 'np.mean' and 'np.std' functions useful.\n", + " \"\"\"\n", + " # You need to set these values correctly\n", + " X_norm = X.copy()\n", + " mu = np.zeros(X.shape[1])\n", + " sigma = np.zeros(X.shape[1])\n", + "\n", + " # =========================== YOUR CODE HERE =====================\n", + "\n", + " \n", + " # ================================================================\n", + " return X_norm, mu, sigma" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Execute the next cell to run the implemented `featureNormalize` function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# call featureNormalize on the loaded data\n", + "X_norm, mu, sigma = featureNormalize(X)\n", + "\n", + "print('Computed mean:', mu)\n", + "print('Computed standard deviation:', sigma)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should not submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[4] = featureNormalize\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After the `featureNormalize` function is tested, we now add the intercept term to `X_norm`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Add intercept term to X\n", + "X = np.concatenate([np.ones((m, 1)), X_norm], axis=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.2 Gradient Descent\n", + "\n", + "Previously, you implemented gradient descent on a univariate regression problem. The only difference now is that there is one more feature in the matrix $X$. The hypothesis function and the batch gradient descent update\n", + "rule remain unchanged. \n", + "\n", + "You should complete the code for the functions `computeCostMulti` and `gradientDescentMulti` to implement the cost function and gradient descent for linear regression with multiple variables. If your code in the previous part (single variable) already supports multiple variables, you can use it here too.\n", + "Make sure your code supports any number of features and is well-vectorized.\n", + "You can use the `shape` property of `numpy` arrays to find out how many features are present in the dataset.\n", + "\n", + "
\n", + "**Implementation Note:** In the multivariate case, the cost function can\n", + "also be written in the following vectorized form:\n", + "\n", + "$$ J(\\theta) = \\frac{1}{2m}(X\\theta - \\vec{y})^T(X\\theta - \\vec{y}) $$\n", + "\n", + "where \n", + "\n", + "$$ X = \\begin{pmatrix}\n", + " - (x^{(1)})^T - \\\\\n", + " - (x^{(2)})^T - \\\\\n", + " \\vdots \\\\\n", + " - (x^{(m)})^T - \\\\ \\\\\n", + " \\end{pmatrix} \\qquad \\mathbf{y} = \\begin{bmatrix} y^{(1)} \\\\ y^{(2)} \\\\ \\vdots \\\\ y^{(m)} \\\\\\end{bmatrix}$$\n", + "\n", + "the vectorized version is efficient when you are working with numerical computing tools like `numpy`. If you are an expert with matrix operations, you can prove to yourself that the two forms are equivalent.\n", + "
\n", + "\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def computeCostMulti(X, y, theta):\n", + " \"\"\"\n", + " Compute cost for linear regression with multiple variables.\n", + " Computes the cost of using theta as the parameter for linear regression to fit the data points in X and y.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The dataset of shape (m x n+1).\n", + " \n", + " y : array_like\n", + " A vector of shape (m, ) for the values at a given data point.\n", + " \n", + " theta : array_like\n", + " The linear regression parameters. A vector of shape (n+1, )\n", + " \n", + " Returns\n", + " -------\n", + " J : float\n", + " The value of the cost function. \n", + " \n", + " Instructions\n", + " ------------\n", + " Compute the cost of a particular choice of theta. You should set J to the cost.\n", + " \"\"\"\n", + " # Initialize some useful values\n", + " m = y.shape[0] # number of training examples\n", + " \n", + " # You need to return the following variable correctly\n", + " J = 0\n", + " \n", + " # ======================= YOUR CODE HERE ===========================\n", + "\n", + " \n", + " # ==================================================================\n", + " return J\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[5] = computeCostMulti\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def gradientDescentMulti(X, y, theta, alpha, num_iters):\n", + " \"\"\"\n", + " Performs gradient descent to learn theta.\n", + " Updates theta by taking num_iters gradient steps with learning rate alpha.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The dataset of shape (m x n+1).\n", + " \n", + " y : array_like\n", + " A vector of shape (m, ) for the values at a given data point.\n", + " \n", + " theta : array_like\n", + " The linear regression parameters. A vector of shape (n+1, )\n", + " \n", + " alpha : float\n", + " The learning rate for gradient descent. \n", + " \n", + " num_iters : int\n", + " The number of iterations to run gradient descent. \n", + " \n", + " Returns\n", + " -------\n", + " theta : array_like\n", + " The learned linear regression parameters. A vector of shape (n+1, ).\n", + " \n", + " J_history : list\n", + " A python list for the values of the cost function after each iteration.\n", + " \n", + " Instructions\n", + " ------------\n", + " Peform a single gradient step on the parameter vector theta.\n", + "\n", + " While debugging, it can be useful to print out the values of \n", + " the cost function (computeCost) and gradient here.\n", + " \"\"\"\n", + " # Initialize some useful values\n", + " m = y.shape[0] # number of training examples\n", + " \n", + " # make a copy of theta, which will be updated by gradient descent\n", + " theta = theta.copy()\n", + " \n", + " J_history = []\n", + " \n", + " for i in range(num_iters):\n", + " # ======================= YOUR CODE HERE ==========================\n", + "\n", + " \n", + " # =================================================================\n", + " \n", + " # save the cost J in every iteration\n", + " J_history.append(computeCostMulti(X, y, theta))\n", + " \n", + " return theta, J_history" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[6] = gradientDescentMulti\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.2.1 Optional (ungraded) exercise: Selecting learning rates\n", + "\n", + "In this part of the exercise, you will get to try out different learning rates for the dataset and find a learning rate that converges quickly. You can change the learning rate by modifying the following code and changing the part of the code that sets the learning rate.\n", + "\n", + "Use your implementation of `gradientDescentMulti` function and run gradient descent for about 50 iterations at the chosen learning rate. The function should also return the history of $J(\\theta)$ values in a vector $J$.\n", + "\n", + "After the last iteration, plot the J values against the number of the iterations.\n", + "\n", + "If you picked a learning rate within a good range, your plot look similar as the following Figure. \n", + "\n", + "![](Figures/learning_rate.png)\n", + "\n", + "If your graph looks very different, especially if your value of $J(\\theta)$ increases or even blows up, adjust your learning rate and try again. We recommend trying values of the learning rate $\\alpha$ on a log-scale, at multiplicative steps of about 3 times the previous value (i.e., 0.3, 0.1, 0.03, 0.01 and so on). You may also want to adjust the number of iterations you are running if that will help you see the overall trend in the curve.\n", + "\n", + "
\n", + "**Implementation Note:** If your learning rate is too large, $J(\\theta)$ can diverge and ‘blow up’, resulting in values which are too large for computer calculations. In these situations, `numpy` will tend to return\n", + "NaNs. NaN stands for ‘not a number’ and is often caused by undefined operations that involve −∞ and +∞.\n", + "
\n", + "\n", + "
\n", + "**MATPLOTLIB tip:** To compare how different learning learning rates affect convergence, it is helpful to plot $J$ for several learning rates on the same figure. This can be done by making `alpha` a python list, and looping across the values within this list, and calling the plot function in every iteration of the loop. It is also useful to have a legend to distinguish the different lines within the plot. Search online for `pyplot.legend` for help on showing legends in `matplotlib`.\n", + "
\n", + "\n", + "Notice the changes in the convergence curves as the learning rate changes. With a small learning rate, you should find that gradient descent takes a very long time to converge to the optimal value. Conversely, with a large learning rate, gradient descent might not converge or might even diverge!\n", + "Using the best learning rate that you found, run the script\n", + "to run gradient descent until convergence to find the final values of $\\theta$. Next,\n", + "use this value of $\\theta$ to predict the price of a house with 1650 square feet and\n", + "3 bedrooms. You will use value later to check your implementation of the normal equations. Don’t forget to normalize your features when you make this prediction!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "Instructions\n", + "------------\n", + "We have provided you with the following starter code that runs\n", + "gradient descent with a particular learning rate (alpha). \n", + "\n", + "Your task is to first make sure that your functions - `computeCost`\n", + "and `gradientDescent` already work with this starter code and\n", + "support multiple variables.\n", + "\n", + "After that, try running gradient descent with different values of\n", + "alpha and see which one gives you the best result.\n", + "\n", + "Finally, you should complete the code at the end to predict the price\n", + "of a 1650 sq-ft, 3 br house.\n", + "\n", + "Hint\n", + "----\n", + "At prediction, make sure you do the same feature normalization.\n", + "\"\"\"\n", + "# Choose some alpha value - change this\n", + "alpha = 0.1\n", + "num_iters = 400\n", + "\n", + "# init theta and run gradient descent\n", + "theta = np.zeros(3)\n", + "theta, J_history = gradientDescentMulti(X, y, theta, alpha, num_iters)\n", + "\n", + "# Plot the convergence graph\n", + "pyplot.plot(np.arange(len(J_history)), J_history, lw=2)\n", + "pyplot.xlabel('Number of iterations')\n", + "pyplot.ylabel('Cost J')\n", + "\n", + "# Display the gradient descent's result\n", + "print('theta computed from gradient descent: {:s}'.format(str(theta)))\n", + "\n", + "# Estimate the price of a 1650 sq-ft, 3 br house\n", + "# ======================= YOUR CODE HERE ===========================\n", + "# Recall that the first column of X is all-ones. \n", + "# Thus, it does not need to be normalized.\n", + "\n", + "price = 0 # You should change this\n", + "\n", + "# ===================================================================\n", + "\n", + "print('Predicted price of a 1650 sq-ft, 3 br house (using gradient descent): ${:.0f}'.format(price))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You do not need to submit any solutions for this optional (ungraded) part.*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.3 Normal Equations\n", + "\n", + "In the lecture videos, you learned that the closed-form solution to linear regression is\n", + "\n", + "$$ \\theta = \\left( X^T X\\right)^{-1} X^T\\vec{y}$$\n", + "\n", + "Using this formula does not require any feature scaling, and you will get an exact solution in one calculation: there is no “loop until convergence” like in gradient descent. \n", + "\n", + "First, we will reload the data to ensure that the variables have not been modified. Remember that while you do not need to scale your features, we still need to add a column of 1’s to the $X$ matrix to have an intercept term ($\\theta_0$). The code in the next cell will add the column of 1’s to X for you." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Load data\n", + "data = np.loadtxt(os.path.join('Data', 'ex1data2.txt'), delimiter=',')\n", + "X = data[:, :2]\n", + "y = data[:, 2]\n", + "m = y.size\n", + "X = np.concatenate([np.ones((m, 1)), X], axis=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Complete the code for the function `normalEqn` below to use the formula above to calculate $\\theta$. \n", + "\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def normalEqn(X, y):\n", + " \"\"\"\n", + " Computes the closed-form solution to linear regression using the normal equations.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The dataset of shape (m x n+1).\n", + " \n", + " y : array_like\n", + " The value at each data point. A vector of shape (m, ).\n", + " \n", + " Returns\n", + " -------\n", + " theta : array_like\n", + " Estimated linear regression parameters. A vector of shape (n+1, ).\n", + " \n", + " Instructions\n", + " ------------\n", + " Complete the code to compute the closed form solution to linear\n", + " regression and put the result in theta.\n", + " \n", + " Hint\n", + " ----\n", + " Look up the function `np.linalg.pinv` for computing matrix inverse.\n", + " \"\"\"\n", + " theta = np.zeros(X.shape[1])\n", + " \n", + " # ===================== YOUR CODE HERE ============================\n", + "\n", + " \n", + " # =================================================================\n", + " return theta" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[7] = normalEqn\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Optional (ungraded) exercise: Now, once you have found $\\theta$ using this\n", + "method, use it to make a price prediction for a 1650-square-foot house with\n", + "3 bedrooms. You should find that gives the same predicted price as the value\n", + "you obtained using the model fit with gradient descent (in Section 3.2.1)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate the parameters from the normal equation\n", + "theta = normalEqn(X, y);\n", + "\n", + "# Display normal equation's result\n", + "print('Theta computed from the normal equations: {:s}'.format(str(theta)));\n", + "\n", + "# Estimate the price of a 1650 sq-ft, 3 br house\n", + "# ====================== YOUR CODE HERE ======================\n", + "\n", + "price = 0 # You should change this\n", + "\n", + "# ============================================================\n", + "\n", + "print('Predicted price of a 1650 sq-ft, 3 br house (using normal equations): ${:.0f}'.format(price))" + ] + } + ], + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/exercise2.ipynb b/exercise2.ipynb new file mode 100644 index 000000000..e08a77bb2 --- /dev/null +++ b/exercise2.ipynb @@ -0,0 +1,1188 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Programming Exercise 2: Logistic Regression\n", + "\n", + "## Introduction\n", + "\n", + "In this exercise, you will implement logistic regression and apply it to two different datasets. Before starting on the programming exercise, we strongly recommend watching the video lectures and completing the review questions for the associated topics.\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, and [`matplotlib`](https://matplotlib.org/) for plotting. In this assignment, we will also use [`scipy`](https://docs.scipy.org/doc/scipy/reference/), which contains scientific and numerical computation functions and tools. \n", + "\n", + "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", + "# 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 | [Sigmoid Function](#section1) | [`sigmoid`](#sigmoid) | 5 \n", + "| 2 | [Compute cost for logistic regression](#section2) | [`costFunction`](#costFunction) | 30 \n", + "| 3 | [Gradient for logistic regression](#section2) | [`costFunction`](#costFunction) | 30 \n", + "| 4 | [Predict Function](#section4) | [`predict`](#predict) | 5 \n", + "| 5 | [Compute cost for regularized LR](#section5) | [`costFunctionReg`](#costFunctionReg) | 15 \n", + "| 6 | [Gradient for regularized LR](#section5) | [`costFunctionReg`](#costFunctionReg) | 15 \n", + "| | Total Points | | 100 \n", + "\n", + "\n", + "\n", + "You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n", + "\n", + "
\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. They must also be re-executed everytime the submitted function is updated.\n", + "
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1 Logistic Regression\n", + "\n", + "In this part of the exercise, you will build a logistic regression model to predict whether a student gets admitted into a university. Suppose that you are the administrator of a university department and\n", + "you want to determine each applicant’s chance of admission based on their results on two exams. You have historical data from previous applicants that you can use as a training set for logistic regression. For each training example, you have the applicant’s scores on two exams and the admissions\n", + "decision. Your task is to build a classification model that estimates an applicant’s probability of admission based the scores from those two exams. \n", + "\n", + "The following cell will load the data and corresponding labels:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Load data\n", + "# The first two columns contains the exam scores and the third column\n", + "# contains the label.\n", + "data = np.loadtxt(os.path.join('Data', 'ex2data1.txt'), delimiter=',')\n", + "X, y = data[:, 0:2], data[:, 2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1 Visualizing the data\n", + "\n", + "Before starting to implement any learning algorithm, it is always good to visualize the data if possible. We display the data on a 2-dimensional plot by calling the function `plotData`. You will now complete the code in `plotData` so that it displays a figure where the axes are the two exam scores, and the positive and negative examples are shown with different markers.\n", + "\n", + "To help you get more familiar with plotting, we have left `plotData` empty so you can try to implement it yourself. However, this is an optional (ungraded) exercise. We also provide our implementation below so you can\n", + "copy it or refer to it. If you choose to copy our example, make sure you learn\n", + "what each of its commands is doing by consulting the `matplotlib` and `numpy` documentation.\n", + "\n", + "```python\n", + "# Find Indices of Positive and Negative Examples\n", + "pos = y == 1\n", + "neg = y == 0\n", + "\n", + "# Plot Examples\n", + "pyplot.plot(X[pos, 0], X[pos, 1], 'k*', lw=2, ms=10)\n", + "pyplot.plot(X[neg, 0], X[neg, 1], 'ko', mfc='y', ms=8, mec='k', mew=1)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def plotData(X, y):\n", + " \"\"\"\n", + " Plots the data points X and y into a new figure. Plots the data \n", + " points with * for the positive examples and o for the negative examples.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " An Mx2 matrix representing the dataset. \n", + " \n", + " y : array_like\n", + " Label values for the dataset. A vector of size (M, ).\n", + " \n", + " Instructions\n", + " ------------\n", + " Plot the positive and negative examples on a 2D plot, using the\n", + " option 'k*' for the positive examples and 'ko' for the negative examples. \n", + " \"\"\"\n", + " # Create New Figure\n", + " fig = pyplot.figure()\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " pyplot.plot(X[y==1, 0], X[y==1, 1], 'k*', lw=2, ms=10)\n", + " pyplot.plot(X[y==0, 0], X[y==0, 1], 'ko', mfc='y', ms=8, mec='k', mew=1)\n", + " \n", + " # ============================================================" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we call the implemented function to display the loaded data:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEGCAYAAACKB4k+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO2de3hU5bXwf2sGyBCDQSC1UqJQoV65SWyl7YGEYKVfOQXb2gO13o6XeuspDfVyKocYxK9VqLY+52gLUpG0X/Bo2wge28MdrNrWYL1bSy2ICMpFiaTIJWF9f8yekISZZGYysy8z6/c877Nn7z177zV7ZvZ63/Wui6gqhmEYhgEQ8loAwzAMwz+YUjAMwzBaMaVgGIZhtGJKwTAMw2jFlIJhGIbRSg+vBegOAwYM0MGDB3sthmEYRqDYuHHjblUtibcv0Eph8ODBNDQ0eC2GYRhGoBCRtxLtM/ORYRiG0YopBcMwDKOVrCkFEfm5iOwUkVfabOsnIitFZJOzPMHZLiJyn4j8TUReEpFzsiWXYRiGkZhsjhQWA5M6bLsVWK2qw4DVzjrAF4FhTrsGeCCLchmGYRgJyJpSUNUNwPsdNk8BHnZePwxMbbN9iUb5A9BXRE7KlmzdoampiTlzqiktLSEcDlFaWsKcOdU0NTV5LZphGEa3cdv76ERV3QGgqjtE5GPO9k8Ab7d53zZn246OJxCRa4iOJjj55JOzK20HmpqaKC8/j+LiN6muPsCQIbB5827q6u5m2bJfsW7dHygqKnJVJsMwjEzil4lmibMtbvpWVV2gqmWqWlZSEtfNNmvcc888iovfZNasAwwdCuEwDB0Ks2YdoLj4Te65Z56r8hiGYWQat5XCezGzkLPc6WzfBpS2ed8gYLvLsnXJwoX3M336AaSDChOBadMO8OCD2Z0KaWxs5MILL6SxsTGr1zH8hX3vhpu4rRSWAZc5ry8DHm+z/VLHC+k8oDFmZvIT27fvYciQ+PuGDInuzybLli2jvr6e5cuXZ/U6hr+w791wk2y6pNYBzwKnicg2EbkS+CFwvohsAs531gGeBP4O/A1YCFyfLbm6w8CB/dm8Of6+zZuj+7PJz3/+83ZLwx287qnb9264STa9j6ar6kmq2lNVB6nqIlXdo6qVqjrMWb7vvFdV9QZVPVVVh6uqL3NXXH319dTVRehYrE4Vli6NcNVV12X0ehMnTkREWtszzzwDwNNPP91u+8SJEzN63XynoxJwu6cetO/da6VpZBa/TDQHgqqqm2hsPJW5cyNs2gTNzbBpE8ydG6Gx8VSqqm7K6PVuu+02CgsLW9cPHTrUbglQWFjIrFmzMnrdfKejEnC7p56J793NB7WZt3IMVQ1sGzNmjLrNvn37tKZmtpaWlmg4HNLS0hKtqZmt+/bty8r11qxZo4WFhUrUG6tdKyws1LVr12bluvlM3759293nXr16tVvGWmVlZdZk6O73vmTJEgW0trY2azLGKC8vV0ArKiqyfi0jMwANmuC56vmDvTvNC6XgBcuXL9dIJNLuwRCJRHT58uVei5YTVFZWtru3PXr0iPswdlshd+d7z+aDuuP98kJpGt2jM6Vg5qME+Clyee/evfTo0YNQKETv3r0JhUL06NGDvXv3ui5LLtLRXNPc3Nzp+wsLC/mf//kfysvLsypXKt+7m/MQZtbMcRJpiyC0bI0U9u3bp2PGnKUTJkR04UJ01Sp04UJ0woSIjhlzVtZMRYkoLy/XUCiko0eP1hUrVujo0aM1FArZcD2DdGauwaMRWirfezLyZ3J0Y2bNYIONFFLDb5HLxcXFzJs3j4aGBs4//3yee+457r77bo4//nhX5chlKioqeOSRR4hEIsfs82qElsr3XlFRwRNPPNGuB9+WTI9uEt2vSCTCI488kvVRlJFFEmmLILRsjRQGDRqgCxeia9ce2xYsQEtLS7JyXcNbamtrtaioSEOhkPbu3bu153vKKacEZoTm5vxTx/sVCoW0qKjIlclto3tgI4XU8Dpy2fCGRYsWsX//fkaOHMnjjz/e2iMfMmRIYEZobs4/dbxfI0eOZP/+/RZkF3BMKcTB68hlwxs6mmvef/995s+fT3FxMQDhcJiZM2dSX1/vsaSJcfNBbWbN3ESiI4lgUlZWpg0NmQ9+njOnmvXr72bWrPbJ71SjgWrjx9/M7Nk1Gb+uYSRLY2Mjl19+OYsXL25VWgBTp05l3LhxzJgxg1AoREtLCz/+8Y956qmnfK3MDHcRkY2qWhZ3nymFY2lbN2HatFjdhGgqi8bGU61uguE5tbW1XHrppdTW1vLNb37Ta3GMgNGZUjDzURyKiopYt+4PjB9/M3fcUcKkSSHuuKOE8eNvNoVg+AJLkmdkCxspGEYAmDhxIqtXr25d79WrF4cOHWpdxqisrGTVqlVeiBiXRGYuw1tspGAYASeoUcSWLC94mFIwjADgdnBapjAzV/AwpWAYASEIUcSJcjCtW7fOl7UgjGMxpWAYAcLvyRETmbnazl360cxlHMWUgmEEiGwGp2WiME9QzVzGUUwpGEaAyGYUcaYmhe+88072798fd9/+/fupqKgwE5KPMZdUw8hj2rqMTp06lXXr1lFRUcGaNWvSPufatWuZNGlSO8+ojtiIwVt855IqIt8RkVdE5FURmeFs6yciK0Vkk7M8wQvZDH9gxeCzz8SJE+nbty/19fX07ds3Y4V5KioqOOOMMxLuN4Xgb1xXCiJyNnA18GlgJDBZRIYBtwKrVXUYsNpZN/IU82/PPrfddhuh0NFHQCZjHwYPHsyVV155jKdUKBTyjaeUER8vRgpnAH9Q1f2q2gysBy4EpgAPO+95GJjqgWxGB7zqsZt/e3Zo6zI6YcKEdkqhI93p0dfX11NeXn6Mp1RhYaFvPKVSIZ9Grl4ohVeAcSLSX0QKgf8DlAInquoOAGf5sXgHi8g1ItIgIg27du1yTeh8xa0eu5s1hvOZZOtR9+zZs9s9+lyqt5BPI1fXlYKqvg7cBawEfge8CHReKb398QtUtUxVy0pKSrIkpRHDrR57UNM4BI2uXEYBRISCgoJu9+hzqd5CXo1cE5Vkc6sB/xe4HngDOMnZdhLwRlfHZqscZz5TWVnZrpRjr1692i1jrbKyMuPXtmLw7hGvbKeI6Jw5c3T06NEqIjpgwADdu3ev16K6zt69e3XAgAGe/Q/cAL+V4xSRjznLk4GvAHXAMuAy5y2XAY97IVuQyYTd08seexDSOOQKbSOjQ6EQIsJxxx3HkCFDeO655/iXf/kXdu/enRfmko4sW7aM3bt306tXr9Zt+TRy9Sp47Vci8hqwHLhBVT8AfgicLyKbgPOddSMFMmH39Doi1e9pHHKFtvb+3/3ud4waNarV3h8Oh3n33XeBPDGXdCD2mc8880xP/geeT2onGkIEoZn5qD3l5eUKaEVFRbfPFc+8EIlEdPny5RmQNDHl5eUaCoV09OjRumLFCh09erSGQqGMfCbjKFOmTNEf/ehH2tLSoqqqEyZMyGlzSWckazJ163+wZMkSBbS2tjZr18Bv5iMjM2TTY8erHrsXk5Oe98w8oL6+nqqqqlaX1FmzZuXtRH8yJlOIFjZy43/g+aR2Im0RhJbvI4XOJmZjLd0J2nzqsbvRMwsCy5Yt03A4nJcT/V39l4YOHZq1/4EXzh10MlLw/MHenZbvSkE1ex47Hc0Lzc3NOn/+fJ0yZUoGpfcHmTS7ZYK9e/fq1KlTXff8iSnHnj17um429APxTKahUEivvPLKrP4Pstm5S4QphRzHK/t/UPHS7TYZvBq5xJRjOBzWUCikvXv31lAopEVFRXkxiqqtrdWioiJPPrvb7tidKQWbU8gBzGMnNfweKOeWTbm8vDzunFRLSwtHjhzho48+4siRIzQ1NeWFF5KXEdh+csc2pZAD5FI6ATfw2u22I16l+Bg7dmy79XiprgsLC7n22msDGYWcKl5HYPumc5doCBGEZuajKPlk/88kfjG7eWFTVj1qLgqFQnk5uew33HTuwOYUDONYvLQhd8QNm3KiuZQePXq47otvHIubnTtTCoYRB7+53WZ75JLMiASiOZDyZXI5X+lMKdicgpG3eG1D7ki2bcpdzaWICPPmzWuX8sLIQxJpiyA0GykYuYRbI5d4I5IePXro448/rqo2J5UPYCMFw/A/bo1c4o1IIpEIH374IQDhcJiZM2dSX1+f0esawUCiSiOYlJWVaUNDg9diGEagqKioYMOGDYwcOZK77rqLW265hRdffJHx48ezZs0ar8UzXEBENqpqWbx9NlIwjDzDb3Mphr+wkYJhGEaeYSMFw8gy+Zh+28hNTCkYRgbIRNU7w/ADphQMIwN4XhjFMDKEKQXDSAOvktgZRrYxpWAYaeD39NuGkS6eKAUR+a6IvCoir4hInYhERGSIiPxRRDaJyCMi0ssL2QwjGfyWftswMoXrSkFEPgH8G1CmqmcDYWAacBdwr6oOAz4ArnRbNsNIBT8VRjGMTOGV+agH0FtEegCFwA5gAvCYs/9hYKpHsgWKpqYm5sypprS0hHA4RGlpCXPmVNPU1OS1aHmBbwqjYG6xRmZwXSmo6jvAfGArUWXQCGwE9qpqs/O2bcAn4h0vIteISIOINOzatcsNkX1LU1MT5eXnsX793VRX72bFCqW6ejfr199Nefl5phhcwE9V78wt1sgEXpiPTgCmAEOAgcBxwBfjvDVuqLWqLlDVMlUtKykpyZ6gAeCee+ZRXPwms2YdYOhQCIdh6FCYNesAxcVvcs8987wWMeeJpYxYvXo1999/P6tWrfIsZYS5xRqZwAvz0URgs6ruUtXDwK+BzwJ9HXMSwCBguweypYTXppuFC+9n+vQDiLTfLgLTph3gwQcfcEWOfKa+vp6qqiqeeOIJ6uvrefLJJ13LMGpusUY28EIpbAXOE5FCERGgEngNWAt8zXnPZcDjHsiWNH4w3WzfvochQ+LvGzIkut9wBy966eYW60+CPrfjxZzCH4lOKD8PvOzIsAC4BagSkb8B/YFFbsuWCn4w3Qwc2J/Nm+Pv27w5ut/IDn7opZtbrD8J+tyOJ95Hqlqtqqer6tmqeomqHlTVv6vqp1V1qKpepKoHvZAtWfxgurn66uupq4vQMdGtKixdGuGqq67Lugz5il966bngFhv0nnVHgj63YxHNaeIH001V1U00Np7K3LkRNm2C5mbYtAnmzo3Q2HgqVVU3ZV2GfMVPvXQ/ucWmQ9B71n4YNWYSUwppkk3TTbIT2EVFRaxb9wfGj7+ZO+4oYdKkEHfcUcL48Tezbt0fKCoqSluG7uLH3l+mZfJLL91PbrHpEPSetV9GjZnClEKaZMt0k+oEdlFREbNn17B1606am1vYunUns2fXeKoQwJ+9v2zI5Ideul8qqSWrdHOtZ+2nUWNGUNXAtjFjxqhX7Nu3T8eMOUsnTIjoggXoypXoggXohAkRHTPmLN23b19a562pma0TJkR0zRp07dqjbc2a6LlramZn+JNkh/LycgW0oqLCa1FayYZM5eXlGgqFdPTo0bpixQodPXq0hkIhX31ut1iyZIkCWltb2+n71qxZo4WFhUo0FiluKyws1LVr17ojeIZYvny5RiKRdp8jEono8uXLvRbtGIAGTfBctZFCGjQ1NXHPPfN49913Wbv2ADNmCF/8ItTUDOi26cYPE9jp4Mfenxsy+aWX7geSNQPlXM/awQ+jxoyQSFsEoXkxUmg7Qli4EF21Cl24sPsjhBihkOiqVe1HCbG2ciUaDocy9Ekyix97f36UKZeorKxsdy979erVbhlrlZWVcY8PUs86GYI0asRGCpkj2/EJQY098GPvz48y5RLJTLCGw2FmzJgR9/ic6Vk75MqosUulICKfEpHVIvKKsz5CRIIxjZ4Fsm3eCXLsgV+8cfwuU67QldLt1asXLS0tCR/yQfea6kgs5UkoFH2shsNh11KeZJJkRgoLgX8HDgOo6ktE6x/kJdmOTwh67IEfe39+lClX6EzpfupTnwISzzHkSs8610hGKRSq6p86bGuO+848INvmHT/HHiSDH3t/ycjkx7iKoBBTum05cOAAf/nLX4DEE/u50rPONZJRCrtF5FScVNYi8jWidRDykmTMO93NnurX2INk8GPvLxmZOsYwmJJInpjSHTp0KAUFBa3bm5ujfcegBnHlLYlmoGMN+CSwCtgPvAP8Hjilq+PcaF57H8WLT9ixY0dWvZOM7NAxhiFZn3tDdcqUKfqjH/1IW1paOvX4Mk+vzLF3716dOnWq7t27N63j6cT7qCuFEAK+7rw+DujT2fvdbl4Fr+3bt09ramZraWmJhsMhLS0t0Zqa2a3bcyH4LNdJ1p3yhBNO8FrUwJFrrqZ+pLudls6UQqfmI1U9AtzovP6Hqu7LxOgk6HRm3glq8Fm+kYw7JcC+ffsCmXrBS2xiP/tkM19UMnMKK0XkeyJSKiL9Yi3jkuQIfsieanRNV+6UMWJ2cTB7eLL40dkg6LiZMSAZpfCvwA3ABmCj0xq6feUcJdPeSV6X/MxlErlTxsMC3ZLHj84GQcfNTKyiHd1oAkRZWZk2NPhLP82ZU8369Xcza1Z7E5JqNNZg/PibmT27JqlzxTKmFhe/yfTpBxgyJKpY6uqiMQtBcFH1O7/4xS+47rrr2L9/PwUFBRw8eJAjR460e08kEuHRRx9l8uTJHklpGLB27VomT57M/v37j9mXaqdFRDaqalm8fclENPcUkX8TkcecdqOI9EzqynlIJoPP/FDyM9fpaOooLS1t3Wf28PaYm663uBWdn4z56AFgDHC/08Y424w4ZDL4zCats09HU8fgwYNbt7e1hy9YsCCnHojpPOD9WCMjXYKq4FyZxE/klhRrwIvJbPOieVlPwQ2CmjG1K7rrY51N2vrcq6o2Nzfr/Pnz9ZxzzsmpuIV0XBr9WCMjXYIah5KpTKx0M0tqixPRDICIfBJoSVcJichpIvJCm/ahiMxwvJpWisgmZ3lCutfIFYKaMbUr/NzjTJR6ITZJmiseNMm4NPqxRkamCGoJUFcm8RNpi1gDKoGtwDpgPbAFqOjquGQaEAbeBU4B7gZudbbfCtzV1fG5PlLI1UC4IPQ4u1srwG+k83mSqUfRu3fvQEQpB+X77GwUnckRNulGNOvRh3cBMAIYCRQkc0yS5/0C8LTz+g3gJOf1ScAbXR2f60ohWyU/3SYof8i25FqBnnQ/T1fHff/73/fmA6VIUL7PzsxamTR5dUspEI1R6Ntm/QTg+q6OS6YBPwdudF7v7bDvgwTHXEM0TqLh5JNP7vbN8TudpdQICkH5Q3Yk1/L4pPt54qWtCIVCvh/tdSQI32dno+hMjrC7qxReiLPtz10dl8R5ewG7gRM1BaXQtuX6SCGXCMIfMh65lscnnc9TW1ur4XA47nfn59FePPz2fSY7is70CLszpZDMRHNI5KhTpIiEnQd6d/ki8LyqvuesvyciJznXOAnYmYFrGD4hqBXQci2PTzqfZ9GiRRw5cgTp6BtN8NJi++37TDYHV6J92bjnySiF/wX+W0QqRWQCUAf8LgPXnu6cK8Yy4DLn9WXA4xm4huEj/PaHTIZcy+OTzucpLi5m/vz5rFy5MvD1rv32fXaVg6ugoKBdjYq2ZO2eJxpC6FEzTgi4FngM+BXwLSDc1XFdnLMQ2AMUt9nWH1gNbHKW/bo6j5mPgkWmfKzdJFHcwpQpUzyWLD26+3n8Zn5JFb9+n53d12zcc7rrfaRHH9z9gBGpHJPNZkohWPj1D+klfg7ki0dtba0WFRVpKBTS3r17aygU0qKiosAFgfmNzu5rNu55t5QC0fiE4x2FsJVoltR7ujrOjWZKITVinkyDBg3QUEh00KABgfNkyjWCFlkbxNFeEOjsvmbjnnemFJKZUyhW1Q+BrwAPqeoYIHghjHlOLOPq+vV3U129mxUrlOrq3axffzfl5edZKm6PCFpkbS6mxfZDHqTO7qvr9zyRtog14GWiwWQrgHOdbS91dZwbzUYKyZOr0dFBI4iBfLlONkZrfjcL0s2RwhyiHkh/U9XnnNxHmzKrmoxsYxlX/YGbxVKM5MjGaM3P+b26okuloKqPquoIVb3eWf+7qn41+6LlD25UV8uVMqF+GOp3h65cEIPi2hlk3Ej0FzSzYFuSGSkYWcQtW3+uZFwNcg8sRlAD+XKFbIzWcimjrCkFj3GrutrVV19PXV2E6JTQUVRh6dIIV111XUauk22C3ANrSxAD+XKFbIzWcsosmGiyIQgtFyaaBw0aoAsXxi+ks2ABWlpakpHrBDXjaq5OzJprp/dkOigsSPm9SHeiWUROd9JbFHXYPimzqil/ccvWn8kyoW6SUz2wNuSia2fQyPRoLWfMgom0BfBvRGsc1BMtrDOlzb7nEx3nZrORQn4QpB6YERyyMVoLSsQ3aY4UrgbGqOpUoBz4DxH5jrPv2HSJRlrkiq0/GdL1ssqZHpjhK7IxWvNbwr10EO34NIrtEHlNVc9ss15ENCnea8AEVR3ljoiJKSsr04aGBq/F6BYx76Pi4jeZNu0AQ4ZEvYGWLo3Q2Hiqr007qdD2c06ffvRz1tUl9zl/8YtfcN1117F//34KCgo4ePAghYWFPPDAA3zzm9908ZMYRmKmTp3KuHHjmDFjBqFQiJaWFn784x/z1FNPUV9f77V4rYjIRlUti7sz0RACWAOM6rCtB7AEaEl0nJstF8xHqrlRXa0ruhtRbROzhpE56MR81NlIYRDQrKrvxtn3OVV9OiMqqxvkwkghXygtLaG6ejdDhx67b9MmuOOOErZuTVxXKSg9MMMIAp2NFBIqhSBgSiE4hMMhVqxQwuFj9zU3w6RJIZqbW9wXzDDykM6UggWvGa6QKxHVmSDoqToMb3Drd2NKwXCFfPKy6opcSNVhuI9bv5uklYKIHC8i/WItm0IZuUdV1U00Np7K3LkRXn4ZFi+Giy6Cykr4058Oc+jQobyp6ZArqToMd3Hrd9OlUhCRb4nIe8BLRKuubQTMkI872U1zhVhE9XnnzeC228L89a/wgx/AypVw770tPPvsj3O22E8uJUsz3MOr300yI4XvAWep6mBVHeK0T2ZUigBilcyipKIYi4qKKCjoxbnn9uTOO8lKAkA/2utzNVWHkV28+t0koxTeBPZn8qIi0ldEHhORv4jI6yIy1jFLrRSRTc7yhExeM9O4ld3Uz6SjGLNd7MeP9nqroWCkg1e/m2SUwr8Dz4jIz0Tkvljr5nV/AvxOVU8HRgKvA7cCq1V1GLDaWfctVsksPcWY7QSAfrXXW6oOIx28+N0koxR+RjS6+Q8cnVPYmO4FReR4YBywCEBVD6nqXmAK8LDztoeBqeleww1ypZJZd0hHMWbaNTVI9nqroWCkg9u/m2SUQrOqVqnqQ6r6cKx145qfBHYBD4nIn0XkQRE5DjhRVXcAOMuPxTtYRK4RkQYRadi1a1c3xOge5nefnmLMtGtqkOz1uZAszXAft383ySiFtc6D+KQMuaT2AM4BHlDV0cA/SMFUpKoLVLVMVctKSkq6IUb3ML/79BRjW9fUTZui0cybNsHcudHEeFVVN6UkQ5Ds9VZDwUgHt383Xaa5EJF4f3tN1wNJRD4O/EFVBzvr/0RUKQwFylV1h4icBKxT1dM6O5eXaS7yJbtpZ8yZU8369Xcza1Z7E5Jq9CE/fvzNzJ5dc8xxTU1N3HPPPB588AG2b9/DwIH9ueqq66iquinte/bEE09w0UUXceDAgdZtkUiERx99lMmTJ6d1TsPIVbqV5qKNG+qQTLikOgn23haR2AO/kmg67mXAZc62y4DH072GGwS1klkmSbfXX1RUxOzZNWzdupPm5ha2bt3J7Nk13bpnZq/PP/zofpwTJEqf2rYBZwNfBy6NtWSO6+R8o4gGwL1EtLLbCUB/ol5Hm5xlv67Okyups4OMX9J+W2rt/GPJkiUK+K6qWRAgndTZMUSkmmjltTOBJ4EvAr9X1a9lVj2ljmVJNWJYau3cpLGxkcsvv5zFixdTXFzcbl9FRQXr1q2joqKCNWvWeCRhMEmryI4e7dW/TNTM9KKzfiKwvKvj3Gg2UkiPWO9+0KABGgqJDho0IOeK+hi5QdvRQGVlZbv63L169Wq3jLXKykqvxfY9pFmjOcZHqnoEaHZiDHYSdSs1Aoil5zCCRNtgxCC5HweZZJRCg4j0BRYSDVp7HvhTVqUysoal5zD8TGfBiBMmTGD//sQZd/zkfhxkUqq8JiKDgeNV9aVsCZQKNqeQOt0ti2kY2WTt2rVMnjy504d/QUEBR44c4fDhw63bzP04NbrlkioiV8Zeq+oW4FVn8tkIIJaew/AzyQQjzpw5k4KCAnM/zhLJmI8qReRJJ6L5bKI5kPpkWS4jS1h6DsPvdJUE7plnnrF0IVkkmeC1bxBNUPcyUZfUGar6vWwLZmQHS89hBIHOghEtXUh2SSZOYRhHlcIZRKOPq1Q1ozUW0sHmFFLH0nMYQaCiooINGzYwcuRI7rrrLm655RZefPFFxo8fbzEJGaBbcwrAcuA/VPVbwHiiEcfPZVA+w0UsPYcRBGw04B3JjBSOV9UPO2wbpqqbsipZEthIwTAMI3XSGimIyM0AqvqhiFzUYfcVGZTPMIw4WMI3wws6Mx9Na/P63zvsm5QFWQzDaIMf600buU9nSkESvI63bhgZp6mpiTlzqiktLSEcDlFaWsKcOdV5k4rDr/WmjdymM6WgCV7HWzfyjGw/sP2So8lNxRSketNG7pJwollEWoiWyhSgNxBzQRUgoqo9XZGwE2yi2RvaurVOn37UrbWuLnNurelWdcskbnzOtiST4sHy+xiZIK2JZlUNq+rxqtpHVXs4r2PrnisEwzvcSKq3cOH9TJ/eXiEAiMC0aQd48MEHun2NrnA7eWCQ6k0buUsycQqG0Q43Hth+yNHkhWLqKsWDKQQj25hSMFLGjQe2H3I0eaWYrN604SWmFIyUceOB7XWOpqamJvr27e2JYlq0aJElfDM8w5SCkTKdPbDr6iIMG3ZGt711qqpuorHxVObOjbBpEzQ3R+s9zJ0bneStqropg5+oPbEJ5hNOOEhtLa4rJkvxYHhJSkV2Mi9dOXMAABtASURBVHZRkS3APqAFaFbVMhHpBzwCDAa2AF9X1Q86O0+q3kdNTU3cc888Fi68n+3b9zBwYH+uvvp6qqpuspw/KZAoqV5dXYQ//1kZMQIuueRgt711Yt/Xgw8+0Pp9XXXVdVn/vmKeTzNnHmDmTDjxRLj4Ylo/T21tD/bvP81yRRmBpTPvIy+VQpmq7m6z7W7gfVX9oYjcCpygqrd0dp5UlILb7oW5TrwH9rBhZ9Dc/Eduv/2gZ26kmaBtdbqPPoJHH4Xf/hZ27oT+/eHw4ULefvs9+70YgSUoSuENoFxVd4jIScA6VT2ts/OkohT84Pee63RV6nPOnAG8/fYu9wVLkXA4xIoVSjh87L7mZpg0KURzc4v7guURjY2NXH755SxevJji4mKvxck5ups6OxsosEJENorINc62E1V1B4Cz/Fi8A0XkGhFpEJGGXbuSf8D4we891+nKW+edd3YHIkWFHzyf8h3L++QdXimFz6nqOcAXgRtEZFyyB6rqAlUtU9WykpKSpC/oB7/3XKerh2mfPmQ84CsbeO35ZFjeJy/xRCmo6nZnuRP4DfBp4D3HbISz3JnJa1rvL/tcffX1PPRQfG+dX/4SKioIxIjMS88nv5LtNN6W98k/uK4UROQ4EekTew18AXgFWAZc5rztMuDxTF7Xen/Zp6rqJp5/HmpqaPcwramB996DK68MxojMqtMdS7bNObfddlu79B6HDh1qt4Romo9Zs2Zl5fpGG1TV1QZ8EnjRaa8Ctznb+wOriZb7XA306+pcY8aM0WTZt2+fjhlzlk6YENEFC9CVK9EFC9AJEyI6ZsxZum/fvqTPlej8NTWzddCgARoKiQ4aNEBramZ3+7xBY+DA/jplCvrxj6OhUHR5xRXok09G73dpaYnXIhppUF5eroBWVFRk7Rpr1qzRwsJCJTrn2K4VFhbq2rVrs3btfANo0ETP6EQ7gtBSUQqqRx/cpaUlGg6HtLS0JCMP7rYKZ+FCdNUqdOHCzCmcIFFTM1snTIjomjXo2rXR9uSTUcXQpw8qQt4qzER43aHYu3evTp06Vffu3du6rbKyst1DuVevXu2WsVZZWZlRWZYvX66RSKTdNSKRiC5fvjyj18l3TClkmXgPwrVr0TVrooqhpma21yK6RscR2bJl6Cc/iX7+8+S9woyHHzoUS5YsUUBra2tbt3XWa89m7722tlaLioo0FApp7969NRQKaVFRUTvZjO7TmVKwNBcZwNxdj9LRHv+Vr8DHPw5z5uBK+umg4XZ67njE8/TxKo13ruV9CmKdbVMKGcDcXdtTVFTE7Nk1vPba3ykq6s1f/woTJ8K0abBkSTRKOB8VZjy86FAk6+lz5513up7G26u8T9l6eAcx3sKUQgYwd9djiaUVOeOMj/jBD2DFCpg7F/7+d6iqiiqGfFSYHfGiQ5GKp4/babzr6+upqqoiFIo+msLhMDNnzqS+vj4r14uRrYd3EOMtTClkAHN3PZaYWeTOO9ubjaqrownmHn00fxVmW7zoUKRiGuquOSco5pNMPbxzId7ClEIGsGCnY+nMLHLxxdEEc/mqMNviVYci2Qpv3TXn+NV8kq2Hd07EWySagQ5C84v3kWr23F2DSigkumpVe2+sWFu5Muqaat5H2Y+f6Qw3PH3ciG9Ih2x6VwUh3gJzST1KJnzCvfYrDwKDBg3QhQvjK4UFC9D+/Qvtfjl41aEoLy/XUCiko0eP1hUrVujo0aM1FAp16wGerfiGeLEU3SWbD2+/x1uYUnDIhE+4H/zKg4DFbvifKVOm6I9+9CNtaWlRVdXm5madP3++TpkyJe1zZqsHHi+WIhMkenifd9553VJAfo+3MKXgkOqDKt6IYMKEcTpuXIE97LrAS7OI4S3Z6IFnywwV7+FdUFDQbQWUjVFYJulMKeTVRHMqPuExl8r16++muno3K1Yo1dW7OXBgA9u2HeTAga7Pkc9YUrnOaWpqYs6c6m7XsvYjyU5id4ZbXjzxvKsOHjwIdM8TKdB1thNpiyC0VEcKXU1+hsOh1vd2NqoYPz6ay6ercxj+x4v5oXwwQSZjPuns3ruVZmPKlCk6dOjQducNhUKu5HnyEmykECUVn/BkXCq7OofhbxKNBtevv5vy8vOy1mv3Q2qLbNNVfENX9/7cc891Jc1GfX09CxYsaHedI0eOAAFzI80geaUUUvEJ7yrSdGeHEkDxzmH4G68ezvmQK6sr80ky9z4TZqhk8CrPk1/JK6WQSpBZV6OKoiIsUC3gePVw9kOurGzPaXSVriLZe+9Wmg23FFAQyCulkMrkZ2ejirq6CGVl42wCNeB49XD2OleWV2aztiR7793Mmup2nie/kldKAY5m8Ny6dSfNzS1s3bqT2bNrjnmYdzaq+PDDU3n88f/p8hyGv3H74Rzrne/fv59rrmmfNRbcM0H6YU4j2XvvphdPrqXtTpe8UwrJYi6VuY+beYfa9s7vums/K1dGs8a++WY0a+zLL7tngvTDnMbVV1/P//t/iUfisXvvZtbUQLuRZhDRjt9KgCgrK9OGhgavxTACSuxBXVz8JtOmHWDIkGgvdenS6MM5k8p/zpxq1q+/m1mz2j+MVeG22+D11wv57ne/R1XVTVnvcITDIVasUMLhY/c1N8OkSSGam1uyKsO7777LGWcM5qyzDnLZZbTe+4cfhldfLeD117fw8Y9/PKsy5DMislFVy+Lts5GCkbe4ORrsrHd+xRXQp89xrpkgvZ7TAFiw4AFGjIBPfQpmz4YLLoguP/UpGDEiut/wBs9GCiISBhqAd1R1sogMAZYC/YDngUtU9VBn57CRghEU/NA7j9HZqGXu3Ajjx9/M7Nk1WZWhtLSE6urdDB167L5Nm+COO0rYunXnsTuNjODXkcJ3gNfbrN8F3Kuqw4APgCs9kcoIBEFLE+GH3nkMP9T/8INbrhGfHl5cVEQGAV8C7gSqRESACcA3nLc8DNwOpDyGPHz4MNu2beNAx+REhmdEIhEGDRpEz549M3K+tnMB1dWxuYDd1NXdzbJlv/KlI0B0Ujt+79ztoMeY2eyee+Zxxx0PsH37HgYO7M9VV13nypwGxJRk/JFCEDIDNDU1cc8981i48P7W+3f11de7dv+yiSfmIxF5DPgB0Af4HnA58AdVHersLwV+q6pnxzn2GuAagJNPPnnMW2+91W7/5s2b6dOnD/3790c6GnAN11FV9uzZw759+xiSqGuYIn4wf6SKm5PaQSCI32GMtt/l9OlHv8u6uuB8l74yH4nIZGCnqm5suznOW+NqK1VdoKplqlpWUlJyzP4DBw6YQvARIkL//v0zOnLzg0tlqpiLc3v8YMJKl3TiPIJk7nR9pCAiPwAuAZqBCHA88BvgAuDjqtosImOB21X1gs7OFW+i+fXXX+eMM85ISabGxkYuv/xyFi9eTHFxcUrHGsmRzveSCD9N2hrpEzPBPPigNyasdEl1ktyPIwtfjRRU9d9VdZCqDgamAWtU9WJgLfA1522XAY+7JZNfi4sb8fHTpK2RPslmF/AbqU6S+yGCPBX8FKdwC9FJ578B/YFFbl04FsaeyXD23/zmN4gIf/nLX+Luv/zyy3nssceSPt/27dv52teiOvOFF17gySefbN23bt261iIkqTB48GB2796d8nFe42YksmF0JNVOSdDMnZ4qBVVdp6qTndd/V9VPq+pQVb1IVQ9m67puVHWqq6vj85//PEuXLs2IzAMHDmxVIplSCkElyPZoI/ik2ikJmvutn0YKrnHbbbe1y50eK6aRqaIaTU1NPP300yxatKhVKagqN954I2eeeSZf+tKX2NmmIMPgwYP5/ve/z9ixYykrK+P555/nggsu4NRTT+WnP/0pAFu2bOHss8/m0KFDzJ49m0ceeYRRo0Zx11138dOf/pR7772XUaNG8dRTT7Fr1y6++tWvcu6553Luuefy9NNPA7Bnzx6+8IUvMHr0aL71rW8R1BQnNmlreEmqnZLAmTsTlWQLQotXjvO1117rtAxdjGwUF49RW1ur//qv/6qqqmPHjtWNGzfqr371K504caI2NzfrO++8o8XFxfroo4+qquopp5yi999/v6qqzpgxQ4cPH64ffvih7ty5U0tKSlRVdfPmzXrWWWepqupDDz2kN9xwQ+v1qqurdd68ea3r06dP16eeekpVVd966y09/fTTVVX129/+ttbU1Kiq6hNPPKGA7tq1K+3PmQrJfi+GEQRipURLS0s0HA5paWlJwjKunZX2nTAhojU1s12Xn07KcXoSvOYHYkU1LrroonbukpkoqlFXV8eMGTMAmDZtGnV1dRw+fJjp06cTDocZOHAgEyZMaHfMl7/8ZQCGDx9OU1MTffr0oU+fPkQikZTzua9atYrXXnutdf3DDz9k3759bNiwgV//+tcAfOlLX+KEE05I+zMaRj4TmyRPJpaiquomli37FXPnxo9R8Zu5M2+VArQvqlFQUMDBgwe7XVRjz549rFmzhldeeQURoaWlBRHhwgsv7DR2oqCgAKBVlhihUIjm5uaUZDhy5AjPPvssvXv3PmZfUOM3cjmC1Mht/BBBngp5OacQIxtFNR577DEuvfRS3nrrLbZs2cLbb7/NkCFD6NevH0uXLqWlpYUdO3awdu3atK/Rp08f9u3bl3D9C1/4Av/5n//Zuv7CCy8AMG7cOH75y18C8Nvf/pYPPvggbRncxA+VwgyjOwTJ/TavlUI2imrU1dVx4YUXttv21a9+lXfffZdhw4YxfPhwrrvuOsaPH5/2NSoqKnjttdcYNWoUjzzyCP/8z//Mb37zm9aJ5vvuu4+GhgZGjBjBmWee2TpZXV1dzYYNGzjnnHNYsWIFJ598ctoyuEnQ/LwNI8jkXJGdTEbOGpmjO9+LpVk2jMziq4hmw0iVoPl5G0aQMaVg+J7A+XkbRoAxpWD4HktrYRjuYUrB8D2W1sIw3MOUguF7LK2FYbhHXiuFIBW+yHeC5OdtGEEmb5VCNgOiRISZM2e2rs+fP5/bb7+902Pq6+vbpaZIh1RTYS9btowf/vCHca+/ePFitm/fntL1Y0n7DMMILnmrFLIZEFVQUMCvf/3rlB7QmVAKqfLlL3+ZW2+9Ne7101EKhmEEn7xVCtksfNGjRw+uueYa7r333mP2vfXWW1RWVjJixAgqKyvZunUrzzzzDMuWLeOmm25i1KhRvPnmm+2OWb58OZ/5zGcYPXo0EydO5L333gMSp8LesmULp59+OldddRVnn302F198MatWreJzn/scw4YN409/+hMQffDfeOONx1z/rrvuoqGhgYsvvphRo0bx0UcfsXHjRsaPH8+YMWO44IIL2LFjBwAbN25k5MiRjB07lv/6r/9K+54ZhuETEqVPDULrTursUEh01ar2qWxjbeVKNBwOJXWeeBx33HHa2Niop5xyiu7du1fnzZun1dXVqqo6efJkXbx4saqqLlq0SKdMmaKqqpdddllrKu2OvP/++3rkyBFVVV24cKFWVVWpauJU2Js3b9ZwOKwvvfSStrS06DnnnKNXXHGFHjlyROvr61uv2TYFd8frjx8/Xp977jlVVT106JCOHTtWd+7cqaqqS5cu1SuuuEJVVYcPH67r1q1TVdXvfe97rem9O2Kpsw3DP9BJ6uy8HSlkOyDq+OOP59JLL+W+++5rt/3ZZ5/lG9/4BgCXXHIJv//977s817Zt27jgggsYPnw48+bN49VXXwVgw4YNfPOb3wSOTYU9ZMgQhg8fTigU4qyzzqKyshIRYfjw4WzZsiWlz/LGG2/wyiuvcP755zNq1Cjmzp3Ltm3baGxsZO/eva15nC655JKUzmt4izlaGPHIW6XgRkDUjBkzWLRoEf/4xz8SvieZVNbf/va3ufHGG3n55Zf52c9+1q7+Q6LjO6bfbpuaO9VU3KrKWWedxQsvvMALL7zAyy+/zIoVK1DVwKbizncs86yRiLxVCm4ERPXr14+vf/3rLFq0qHXbZz/72dYSnb/85S/5/Oc/Dxyb/rotjY2NfOITnwDg4Ycfbt2eyVTYnaXjPu2009i1axfPPvssAIcPH+bVV1+lb9++FBcXt452YrIY/scyzxqJcF0piEhERP4kIi+KyKsiUuNsHyIifxSRTSLyiIj0yqYcbgVEzZw5s50X0n333cdDDz3EiBEjqK2t5Sc/+QkQrdA2b948Ro8efcxE8+23385FF13EP/3TPzFgwIDW7ZlMhd3x+pdffjnXXnsto0aNoqWlhccee4xbbrmFkSNHMmrUKJ555hkAHnroIW644QbGjh0bt6iP4U+y6WhhBBvXU2dL1N5wnKo2iUhP4PfAd4Aq4NequlREfgq8qKqd/jItdXZwsO/FX4TDIVasUMLhY/c1N8OkSSGam1vcF8xwBV+lznYmv2MGy55OU2AC8Jiz/WFgqtuyGUa+YJlnjUR4MqcgImEReQHYCawE3gT2qmpsBnQb8IkEx14jIg0i0rBr1y53BDaMHMMyzxqJ8EQpqGqLqo4CBgGfBuLZFeLatVR1gaqWqWpZSUlJovNnTFaj+9j34T8s86yRCE+9j1R1L7AOOA/oKyI9nF2DgLRyLEQiEfbs2WMPIp+gquzZs4dIJOK1KEYbLPOskQgvJppLgMOquldEegMrgLuAy4BftZlofklV7+/sXPEmmg8fPsy2bdva+fIb3hKJRBg0aBA9e/b0WhTDMOh8orlHvI1Z5iTgYREJEx2p/LeqPiEirwFLRWQu8GdgUWcnSUTPnj0Zkqigr2EYhtEprisFVX0JGB1n+9+Jzi8YhmEYHpG3Ec2GYRjGsZhSMAzDMFpxfaI5k4jILuCtNA8fACRfBcd7giRvkGQFkzebBElWCJa83ZH1FFWN69MfaKXQHUSkIdHsux8JkrxBkhVM3mwSJFkhWPJmS1YzHxmGYRitmFIwDMMwWslnpbDAawFSJEjyBklWMHmzSZBkhWDJmxVZ83ZOwTAMwziWfB4pGIZhGB0wpWAYhmG0khdKwS8lQFPBqTnxZxF5wln3s6xbRORlEXlBRBqcbf1EZKUj70oROcFrOQFEpK+IPCYifxGR10VkrI9lPc25p7H2oYjM8Ku8ACLyXec/9oqI1Dn/PV/+dkXkO46cr4rIDGebb+6tiPxcRHaKyCtttsWVT6LcJyJ/E5GXROScdK+bF0oBOAhMUNWRwChgkoicRzQ7672qOgz4ALjSQxk78h3g9TbrfpYVoEJVR7Xxm74VWO3Iu9pZ9wM/AX6nqqcDI4neY1/KqqpvOPd0FDAG2A/8Bp/KKyKfAP4NKFPVs4EwMA0f/nZF5GzgaqL51kYCk0VkGP66t4uBSR22JZLvi8Awp10DpF9kW1XzqgGFwPPAZ4hGA/Zwto8F/tdr+RxZBjlf+ATgCUD8KqsjzxZgQIdtbwAnOa9PAt7wgZzHA5txHCz8LGsc2b8APO1neYlWS3wb6Ec02eYTwAV+/O0CFwEPtln/D+Bmv91bYDDwSpv1uPIBPwOmx3tfqi1fRgrdKgHqAT8m+gM94qz3x7+yQrRK3goR2Sgi1zjbTlTVHQDO8mOeSXeUTwK7gIcc09yDInIc/pS1I9OAOue1L+VV1XeA+cBWYAfQCGzEn7/dV4BxItJfRAqB/wOU4tN724ZE8sUUcoy073PeKAXtRglQNxGRycBOVd3YdnOct3ouaxs+p6rnEB3C3iAi47wWKAE9gHOAB1R1NPAPfGJ66QzHBv9l4FGvZekMx749BRgCDASOI/qb6Ijnv11VfZ2oWWsl8DvgRaC504P8TcaeEXmjFGJoFkqAZpjPAV8WkS3AUqImpB/jT1kBUNXtznInUZv3p4H3ROQkAGe50zsJW9kGbFPVPzrrjxFVEn6UtS1fBJ5X1fecdb/KOxHYrKq7VPUw8Gvgs/j0t6uqi1T1HFUdB7wPbMK/9zZGIvm2ER3pxEj7PueFUhCREhHp67zuTfTH+zqwFvia87bLgMe9kfAoqvrvqjpIVQcTNRmsUdWL8aGsACJynIj0ib0mavt+BVhGVE7wibyq+i7wtoic5myqBF7Dh7J2YDpHTUfgX3m3AueJSKGICEfvr19/ux9zlicDXyF6j/16b2Mkkm8ZcKnjhXQe0BgzM6WM1xM+Lk3WjCBa4vMlog+s2c72TwJ/Av5GdGhe4LWsHeQuB57ws6yOXC867VXgNmd7f6KT5ZucZT+vZXXkGgU0OL+FeuAEv8rqyFsI7AGK22zzs7w1wF+c/1ktUODj3+5TRJXWi0Cl3+4tUSW1AzhMdCRwZSL5iJqP/ovoXOnLRD3A0rqupbkwDMMwWskL85FhGIaRHKYUDMMwjFZMKRiGYRitmFIwDMMwWjGlYBiGYbRiSsHISUSkpUOGUdcil+NltzSMoGAuqUZOIiJNqlrk0bXHAU3AEo1mC3XjmmFVbXHjWkZuYyMFI28QkWIReSMW0ezk+7/aef2AiDRIm3obzvYtIvJ/ReRZZ/85IvK/IvKmiFwb7zqquoFo2oTOZLnIyeX/oohscLaFRWS+RGtTvCQi33a2VzoJ/F52RiEFbWSbLSK/By4SkVNF5HdOYsKnROT0TNw3I7/o0fVbDCOQ9Hay4sb4gao+IiI3AotF5CfACaq60Nl/m6q+LyJhYLWIjFDVl5x9b6vqWBG5l2iO+88BEaIR3D9NU77ZwAWq+k4sBQvRPPhDgNGq2uwUVIk416xU1b+KyBLgOqL5sAAOqOrnAURkNXCtqm4Skc8A9xPNnWUYSWNKwchVPtJoVtx2qOpKEbmIaEqAkW12fd1J+92DaJ76M4mmwoBoXhmIpg8oUtV9wD4ROSAifTWaZDFVniaqnP6baOI4iObk+qk6aaYdJTWSaJK5vzrveRi4gaNK4REAESkimnzu0WjaISCaYsIwUsKUgpFXiEiIaNr0j4gWg9kmIkOA7wHnquoHIrKY6EggxkFneaTN69h6Wv8hVb3W6c1/CXhBREYRzV/TcZIvXkrktvzDWYaI1i04RhEaRirYnIKRb3yXaIbc6cDPRaQn0Yps/wAaReRE4tcAyCgicqqq/lFVZxOtTFYKrACujaWZFpF+RJPLDRaRoc6hlwDrO55PVT8ENjujoFjN3pEd32cYXWFKwchVendwSf2hiHwKuAqYqapPARuAWar6ItEsuq8CPydq2kkbEakDngVOE5FtIhKvJvE8Z+L4FUeOF4EHiaaffklEXgS+oaoHgCuImoVeJjo6STSPcTFwpXPsq0QL3hhGSphLqmEYhtGKjRQMwzCMVkwpGIZhGK2YUjAMwzBaMaVgGIZhtGJKwTAMw2jFlIJhGIbRiikFwzAMo5X/D2r06iWZghgyAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plotData(X, y)\n", + "# add axes labels\n", + "pyplot.xlabel('Exam 1 score')\n", + "pyplot.ylabel('Exam 2 score')\n", + "pyplot.legend(['Admitted', 'Not admitted'])\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 1.2 Implementation\n", + "\n", + "#### 1.2.1 Warmup exercise: sigmoid function\n", + "\n", + "Before you start with the actual cost function, recall that the logistic regression hypothesis is defined as:\n", + "\n", + "$$ h_\\theta(x) = g(\\theta^T x)$$\n", + "\n", + "where function $g$ is the sigmoid function. The sigmoid function is defined as: \n", + "\n", + "$$g(z) = \\frac{1}{1+e^{-z}}$$.\n", + "\n", + "Your first step is to implement this function `sigmoid` so it can be\n", + "called by the rest of your program. When you are finished, try testing a few\n", + "values by calling `sigmoid(x)` in a new cell. For large positive values of `x`, the sigmoid should be close to 1, while for large negative values, the sigmoid should be close to 0. Evaluating `sigmoid(0)` should give you exactly 0.5. Your code should also work with vectors and matrices. **For a matrix, your function should perform the sigmoid function on every element.**\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def sigmoid(z):\n", + " \"\"\"\n", + " Compute sigmoid function given the input z.\n", + " \n", + " Parameters\n", + " ----------\n", + " z : array_like\n", + " The input to the sigmoid function. This can be a 1-D vector \n", + " or a 2-D matrix. \n", + " \n", + " Returns\n", + " -------\n", + " g : array_like\n", + " The computed sigmoid function. g has the same shape as z, since\n", + " the sigmoid is computed element-wise on z.\n", + " \n", + " Instructions\n", + " ------------\n", + " Compute the sigmoid of each value of z (z can be a matrix, vector or scalar).\n", + " \"\"\"\n", + " # convert input to a numpy array\n", + " z = np.array(z)\n", + " \n", + " # You need to return the following variables correctly \n", + " g = np.zeros(z.shape)\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " \n", + " #print(z.size)\n", + " #for i in range(z.size):\n", + " g = 1/(1+np.exp((-1)*z))\n", + " \n", + "\n", + "\n", + " # =============================================================\n", + " return g" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell evaluates the sigmoid function at `z=0`. You should get a value of 0.5. You can also try different values for `z` to experiment with the sigmoid function." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "g( 0 ) = 0.5\n" + ] + } + ], + "source": [ + "# Test the implementation of sigmoid function here\n", + "z = 0\n", + "g = sigmoid(z)\n", + "\n", + "print('g(', z, ') = ', g)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After completing a part of the exercise, you can submit your solutions for grading by first adding the function you modified to the submission object, and then sending your function to Coursera for grading. \n", + "\n", + "The submission script will prompt you for your login e-mail and submission token. You can obtain a submission token from the web page for the assignment. You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n", + "\n", + "Execute the following cell to grade your solution to the first part of this exercise.\n", + "\n", + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise linear-regression\n", + "\n" + ] + } + ], + "source": [ + "# appends the implemented function in part 1 to the grader object\n", + "grader[1] = sigmoid\n", + "\n", + "# send the added functions to coursera grader for getting a grade on this part\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "#### 1.2.2 Cost function and gradient\n", + "\n", + "Now you will implement the cost function and gradient for logistic regression. Before proceeding we add the intercept term to X. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Setup the data matrix appropriately, and add ones for the intercept term\n", + "m, n = X.shape\n", + "\n", + "# Add intercept term to X\n", + "X = np.concatenate([np.ones((m, 1)), X], axis=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, complete the code for the function `costFunction` to return the cost and gradient. Recall that the cost function in logistic regression is\n", + "\n", + "$$ J(\\theta) = \\frac{1}{m} \\sum_{i=1}^{m} \\left[ -y^{(i)} \\log\\left(h_\\theta\\left( x^{(i)} \\right) \\right) - \\left( 1 - y^{(i)}\\right) \\log \\left( 1 - h_\\theta\\left( x^{(i)} \\right) \\right) \\right]$$\n", + "\n", + "and the gradient of the cost is a vector of the same length as $\\theta$ where the $j^{th}$\n", + "element (for $j = 0, 1, \\cdots , n$) is defined as follows:\n", + "\n", + "$$ \\frac{\\partial J(\\theta)}{\\partial \\theta_j} = \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left( x^{(i)} \\right) - y^{(i)} \\right) x_j^{(i)} $$\n", + "\n", + "Note that while this gradient looks identical to the linear regression gradient, the formula is actually different because linear and logistic regression have different definitions of $h_\\theta(x)$.\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "def costFunction(theta, X, y):\n", + " \"\"\"\n", + " Compute cost and gradient for logistic regression. \n", + " \n", + " Parameters\n", + " ----------\n", + " theta : array_like\n", + " The parameters for logistic regression. This a vector\n", + " of shape (n+1, ).\n", + " \n", + " X : array_like\n", + " The input dataset of shape (m x n+1) where m is the total number\n", + " of data points and n is the number of features. We assume the \n", + " intercept has already been added to the input.\n", + " \n", + " y : arra_like\n", + " Labels for the input. This is a vector of shape (m, ).\n", + " \n", + " Returns\n", + " -------\n", + " J : float\n", + " The computed value for the cost function. \n", + " \n", + " grad : array_like\n", + " A vector of shape (n+1, ) which is the gradient of the cost\n", + " function with respect to theta, at the current values of theta.\n", + " \n", + " Instructions\n", + " ------------\n", + " Compute the cost of a particular choice of theta. You should set J to \n", + " the cost. Compute the partial derivatives and set grad to the partial\n", + " derivatives of the cost w.r.t. each parameter in theta.\n", + " \"\"\"\n", + " # Initialize some useful values\n", + " m = y.size # number of training examples\n", + "\n", + " # You need to return the following variables correctly \n", + " J = 0\n", + " grad = np.zeros(theta.shape)\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " #theta = np.zeros(n+1)\n", + " z=(-1)*(np.log(sigmoid((-1)*X.dot(theta))))*(y)\n", + " p=(np.ones(m)-y)*np.log(np.ones(m)-sigmoid((-1)*X.dot(theta)))\n", + " J=np.sum(z-p)/m\n", + " #for i in range(n+1):\n", + " grad=((sigmoid((-1)*np.dot(X,theta))-y).T.dot(X))/m\n", + " # =============================================================\n", + " return J, grad" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0. 0. 0. 1. 1. 0. 1. 1. 1. 1. 0. 0. 1. 1. 0. 1. 1. 0. 1. 1. 0. 1. 0. 0.\n", + " 1. 1. 1. 0. 0. 0. 1. 1. 0. 1. 0. 0. 0. 1. 0. 0. 1. 0. 1. 0. 0. 0. 1. 1.\n", + " 1. 1. 1. 1. 1. 0. 0. 0. 1. 0. 1. 1. 1. 0. 0. 0. 0. 0. 1. 0. 1. 1. 0. 1.\n", + " 1. 1. 1. 1. 1. 1. 0. 0. 1. 1. 1. 1. 1. 1. 0. 1. 1. 0. 1. 1. 0. 1. 1. 1.\n", + " 1. 1. 1. 1.]\n", + "4.7271537117484845\n", + "[ -0.24290299 -26.58466729 -25.17248178]\n" + ] + } + ], + "source": [ + "theta = np.array([-24,0.2,0.2])\n", + "print(y)\n", + "z=(-1)*(np.log(sigmoid((-1)*X.dot(theta))))*(y)\n", + "p=(np.ones(m)-y)*np.log(np.ones(m)-sigmoid((-1)*np.dot(X,theta)))\n", + "print(np.sum(z-p)/m)\n", + "grad = ((sigmoid((-1)*(np.dot(X,theta)))-y).dot(X))/m\n", + "print(grad)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you are done call your `costFunction` using two test cases for $\\theta$ by executing the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost at initial theta (zeros): 0.693\n", + "Expected cost (approx): 0.693\n", + "\n", + "Gradient at initial theta (zeros):\n", + "\t[-0.1000, -12.0092, -11.2628]\n", + "Expected gradients (approx):\n", + "\t[-0.1000, -12.0092, -11.2628]\n", + "\n", + "Cost at test theta: 4.727\n", + "Expected cost (approx): 0.218\n", + "\n", + "Gradient at test theta:\n", + "\t[-0.243, -26.585, -25.172]\n", + "Expected gradients (approx):\n", + "\t[0.043, 2.566, 2.647]\n" + ] + } + ], + "source": [ + "# Initialize fitting parameters\n", + "initial_theta = np.zeros(n+1)\n", + "\n", + "cost, grad = costFunction(initial_theta, X, y)\n", + "\n", + "print('Cost at initial theta (zeros): {:.3f}'.format(cost))\n", + "print('Expected cost (approx): 0.693\\n')\n", + "\n", + "print('Gradient at initial theta (zeros):')\n", + "print('\\t[{:.4f}, {:.4f}, {:.4f}]'.format(*grad))\n", + "print('Expected gradients (approx):\\n\\t[-0.1000, -12.0092, -11.2628]\\n')\n", + "\n", + "# Compute and display cost and gradient with non-zero theta\n", + "test_theta = np.array([-24, 0.2, 0.2])\n", + "cost, grad = costFunction(test_theta, X, y)\n", + "\n", + "print('Cost at test theta: {:.3f}'.format(cost))\n", + "print('Expected cost (approx): 0.218\\n')\n", + "\n", + "print('Gradient at test theta:')\n", + "print('\\t[{:.3f}, {:.3f}, {:.3f}]'.format(*grad))\n", + "print('Expected gradients (approx):\\n\\t[0.043, 2.566, 2.647]')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise linear-regression\n", + "\n" + ] + } + ], + "source": [ + "grader[2] = costFunction\n", + "grader[3] = costFunction\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 1.2.3 Learning parameters using `scipy.optimize`\n", + "\n", + "In the previous assignment, you found the optimal parameters of a linear regression model by implementing gradient descent. You wrote a cost function and calculated its gradient, then took a gradient descent step accordingly. This time, instead of taking gradient descent steps, you will use the [`scipy.optimize` module](https://docs.scipy.org/doc/scipy/reference/optimize.html). SciPy is a numerical computing library for `python`. It provides an optimization module for root finding and minimization. As of `scipy 1.0`, the function `scipy.optimize.minimize` is the method to use for optimization problems(both constrained and unconstrained).\n", + "\n", + "For logistic regression, you want to optimize the cost function $J(\\theta)$ with parameters $\\theta$.\n", + "Concretely, you are going to use `optimize.minimize` to find the best parameters $\\theta$ for the logistic regression cost function, given a fixed dataset (of X and y values). You will pass to `optimize.minimize` the following inputs:\n", + "- `costFunction`: A cost function that, when given the training set and a particular $\\theta$, computes the logistic regression cost and gradient with respect to $\\theta$ for the dataset (X, y). It is important to note that we only pass the name of the function without the parenthesis. This indicates that we are only providing a reference to this function, and not evaluating the result from this function.\n", + "- `initial_theta`: The initial values of the parameters we are trying to optimize.\n", + "- `(X, y)`: These are additional arguments to the cost function.\n", + "- `jac`: Indication if the cost function returns the Jacobian (gradient) along with cost value. (True)\n", + "- `method`: Optimization method/algorithm to use\n", + "- `options`: Additional options which might be specific to the specific optimization method. In the following, we only tell the algorithm the maximum number of iterations before it terminates.\n", + "\n", + "If you have completed the `costFunction` correctly, `optimize.minimize` will converge on the right optimization parameters and return the final values of the cost and $\\theta$ in a class object. Notice that by using `optimize.minimize`, you did not have to write any loops yourself, or set a learning rate like you did for gradient descent. This is all done by `optimize.minimize`: you only needed to provide a function calculating the cost and the gradient.\n", + "\n", + "In the following, we already have code written to call `optimize.minimize` with the correct arguments." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost at theta found by optimize.minimize: 0.693\n", + "Expected cost (approx): 0.203\n", + "\n", + "theta:\n", + "\t[0.000, 0.000, 0.000]\n", + "Expected theta (approx):\n", + "\t[-25.161, 0.206, 0.201]\n" + ] + } + ], + "source": [ + "# set options for optimize.minimize\n", + "options= {'maxiter': 400}\n", + "\n", + "# see documention for scipy's optimize.minimize for description about\n", + "# the different parameters\n", + "# The function returns an object `OptimizeResult`\n", + "# We use truncated Newton algorithm for optimization which is \n", + "# equivalent to MATLAB's fminunc\n", + "# See https://stackoverflow.com/questions/18801002/fminunc-alternate-in-numpy\n", + "res = optimize.minimize(costFunction,\n", + " initial_theta,\n", + " (X, y),\n", + " jac=True,\n", + " method='TNC',\n", + " options=options)\n", + "\n", + "# the fun property of `OptimizeResult` object returns\n", + "# the value of costFunction at optimized theta\n", + "cost = res.fun\n", + "\n", + "# the optimized theta is in the x property\n", + "theta = res.x\n", + "\n", + "# Print theta to screen\n", + "print('Cost at theta found by optimize.minimize: {:.3f}'.format(cost))\n", + "print('Expected cost (approx): 0.203\\n');\n", + "\n", + "print('theta:')\n", + "print('\\t[{:.3f}, {:.3f}, {:.3f}]'.format(*theta))\n", + "print('Expected theta (approx):\\n\\t[-25.161, 0.206, 0.201]')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once `optimize.minimize` completes, we want to use the final value for $\\theta$ to visualize the decision boundary on the training data as shown in the figure below. \n", + "\n", + "![](Figures/decision_boundary1.png)\n", + "\n", + "To do so, we have written a function `plotDecisionBoundary` for plotting the decision boundary on top of training data. You do not need to write any code for plotting the decision boundary, but we also encourage you to look at the code in `plotDecisionBoundary` to see how to plot such a boundary using the $\\theta$ values. You can find this function in the `utils.py` file which comes with this assignment." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot Boundary\n", + "utils.plotDecisionBoundary(plotData, theta, X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "#### 1.2.4 Evaluating logistic regression\n", + "\n", + "After learning the parameters, you can use the model to predict whether a particular student will be admitted. For a student with an Exam 1 score of 45 and an Exam 2 score of 85, you should expect to see an admission\n", + "probability of 0.776. Another way to evaluate the quality of the parameters we have found is to see how well the learned model predicts on our training set. In this part, your task is to complete the code in function `predict`. The predict function will produce “1” or “0” predictions given a dataset and a learned parameter vector $\\theta$. \n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "def predict(theta, X):\n", + " \"\"\"\n", + " Predict whether the label is 0 or 1 using learned logistic regression.\n", + " Computes the predictions for X using a threshold at 0.5 \n", + " (i.e., if sigmoid(theta.T*x) >= 0.5, predict 1)\n", + " \n", + " Parameters\n", + " ----------\n", + " theta : array_like\n", + " Parameters for logistic regression. A vecotor of shape (n+1, ).\n", + " \n", + " X : array_like\n", + " The data to use for computing predictions. The rows is the number \n", + " of points to compute predictions, and columns is the number of\n", + " features.\n", + "\n", + " Returns\n", + " -------\n", + " p : array_like\n", + " Predictions and 0 or 1 for each row in X. \n", + " \n", + " Instructions\n", + " ------------\n", + " Complete the following code to make predictions using your learned \n", + " logistic regression parameters.You should set p to a vector of 0's and 1's \n", + " \"\"\"\n", + " m = X.shape[0] # Number of training examples\n", + "\n", + " # You need to return the following variables correctly\n", + " p = np.zeros(m)\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " Z = sigmoid(np.dot(X,theta))\n", + " for i in range(m):\n", + " if(Z[i]>= 0.5):\n", + " p[i]= 1\n", + " else:\n", + " p[i]= 0\n", + " \n", + " \n", + " \n", + " # ============================================================\n", + " return p" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After you have completed the code in `predict`, we proceed to report the training accuracy of your classifier by computing the percentage of examples it got correct." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For a student with scores 45 and 85,we predict an admission probability of 0.500\n", + "Expected value: 0.775 +/- 0.002\n", + "\n", + "Train Accuracy: 60.00 %\n", + "Expected accuracy (approx): 89.00 %\n" + ] + } + ], + "source": [ + "# Predict probability for a student with score 45 on exam 1 \n", + "# and score 85 on exam 2 \n", + "prob = sigmoid(np.dot([1, 45, 85], theta))\n", + "print('For a student with scores 45 and 85,'\n", + " 'we predict an admission probability of {:.3f}'.format(prob))\n", + "print('Expected value: 0.775 +/- 0.002\\n')\n", + "\n", + "# Compute accuracy on our training set\n", + "p = predict(theta, X)\n", + "print('Train Accuracy: {:.2f} %'.format(np.mean(p == y) * 100))\n", + "print('Expected accuracy (approx): 89.00 %')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[4] = predict\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2 Regularized logistic regression\n", + "\n", + "In this part of the exercise, you will implement regularized logistic regression to predict whether microchips from a fabrication plant passes quality assurance (QA). During QA, each microchip goes through various tests to ensure it is functioning correctly.\n", + "Suppose you are the product manager of the factory and you have the test results for some microchips on two different tests. From these two tests, you would like to determine whether the microchips should be accepted or rejected. To help you make the decision, you have a dataset of test results on past microchips, from which you can build a logistic regression model.\n", + "\n", + "First, we load the data from a CSV file:" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "# Load Data\n", + "# The first two columns contains the X values and the third column\n", + "# contains the label (y).\n", + "data = np.loadtxt(os.path.join('Data', 'ex2data2.txt'), delimiter=',')\n", + "X = data[:, :2]\n", + "y = data[:, 2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.1 Visualize the data\n", + "\n", + "Similar to the previous parts of this exercise, `plotData` is used to generate a figure, where the axes are the two test scores, and the positive (y = 1, accepted) and negative (y = 0, rejected) examples are shown with\n", + "different markers." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plotData(X, y)\n", + "# Labels and Legend\n", + "pyplot.xlabel('Microchip Test 1')\n", + "pyplot.ylabel('Microchip Test 2')\n", + "\n", + "# Specified in plot order\n", + "pyplot.legend(['y = 1', 'y = 0'], loc='upper right')\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The above figure shows that our dataset cannot be separated into positive and negative examples by a straight-line through the plot. Therefore, a straight-forward application of logistic regression will not perform well on this dataset since logistic regression will only be able to find a linear decision boundary.\n", + "\n", + "### 2.2 Feature mapping\n", + "\n", + "One way to fit the data better is to create more features from each data point. In the function `mapFeature` defined in the file `utils.py`, we will map the features into all polynomial terms of $x_1$ and $x_2$ up to the sixth power.\n", + "\n", + "$$ \\text{mapFeature}(x) = \\begin{bmatrix} 1 & x_1 & x_2 & x_1^2 & x_1 x_2 & x_2^2 & x_1^3 & \\dots & x_1 x_2^5 & x_2^6 \\end{bmatrix}^T $$\n", + "\n", + "As a result of this mapping, our vector of two features (the scores on two QA tests) has been transformed into a 28-dimensional vector. A logistic regression classifier trained on this higher-dimension feature vector will have a more complex decision boundary and will appear nonlinear when drawn in our 2-dimensional plot.\n", + "While the feature mapping allows us to build a more expressive classifier, it also more susceptible to overfitting. In the next parts of the exercise, you will implement regularized logistic regression to fit the data and also see for yourself how regularization can help combat the overfitting problem.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "# Note that mapFeature also adds a column of ones for us, so the intercept\n", + "# term is handled\n", + "X = utils.mapFeature(X[:, 0], X[:, 1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 2.3 Cost function and gradient\n", + "\n", + "Now you will implement code to compute the cost function and gradient for regularized logistic regression. Complete the code for the function `costFunctionReg` below to return the cost and gradient.\n", + "\n", + "Recall that the regularized cost function in logistic regression is\n", + "\n", + "$$ J(\\theta) = \\frac{1}{m} \\sum_{i=1}^m \\left[ -y^{(i)}\\log \\left( h_\\theta \\left(x^{(i)} \\right) \\right) - \\left( 1 - y^{(i)} \\right) \\log \\left( 1 - h_\\theta \\left( x^{(i)} \\right) \\right) \\right] + \\frac{\\lambda}{2m} \\sum_{j=1}^n \\theta_j^2 $$\n", + "\n", + "Note that you should not regularize the parameters $\\theta_0$. The gradient of the cost function is a vector where the $j^{th}$ element is defined as follows:\n", + "\n", + "$$ \\frac{\\partial J(\\theta)}{\\partial \\theta_0} = \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left(x^{(i)}\\right) - y^{(i)} \\right) x_j^{(i)} \\qquad \\text{for } j =0 $$\n", + "\n", + "$$ \\frac{\\partial J(\\theta)}{\\partial \\theta_j} = \\left( \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left(x^{(i)}\\right) - y^{(i)} \\right) x_j^{(i)} \\right) + \\frac{\\lambda}{m}\\theta_j \\qquad \\text{for } j \\ge 1 $$\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "def costFunctionReg(theta, X, y, lambda_):\n", + " \"\"\"\n", + " Compute cost and gradient for logistic regression with regularization.\n", + " \n", + " Parameters\n", + " ----------\n", + " theta : array_like\n", + " Logistic regression parameters. A vector with shape (n, ). n is \n", + " the number of features including any intercept. If we have mapped\n", + " our initial features into polynomial features, then n is the total \n", + " number of polynomial features. \n", + " \n", + " X : array_like\n", + " The data set with shape (m x n). m is the number of examples, and\n", + " n is the number of features (after feature mapping).\n", + " \n", + " y : array_like\n", + " The data labels. A vector with shape (m, ).\n", + " \n", + " lambda_ : float\n", + " The regularization parameter. \n", + " \n", + " Returns\n", + " -------\n", + " J : float\n", + " The computed value for the regularized cost function. \n", + " \n", + " grad : array_like\n", + " A vector of shape (n, ) which is the gradient of the cost\n", + " function with respect to theta, at the current values of theta.\n", + " \n", + " Instructions\n", + " ------------\n", + " Compute the cost `J` of a particular choice of theta.\n", + " Compute the partial derivatives and set `grad` to the partial\n", + " derivatives of the cost w.r.t. each parameter in theta.\n", + " \"\"\"\n", + " # Initialize some useful values\n", + " m = y.size # number of training examples\n", + "\n", + " # You need to return the following variables correctly \n", + " J = 0\n", + " grad = np.zeros(theta.shape)\n", + "\n", + " # ===================== YOUR CODE HERE ======================\n", + " cost,grad = costFunction(theta, X, y)\n", + " J = cost + (lambda_/(2*m))*np.sum(theta**2)\n", + " for i in range(theta.size):\n", + " if(i==0):\n", + " grad[i]=grad[i]\n", + " else:\n", + " grad[i]=grad[i]+ (lambda_/m)*theta[i] \n", + " \n", + " # =============================================================\n", + " return J, grad" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n" + ] + } + ], + "source": [ + "print(np.sum(theta**2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you are done with the `costFunctionReg`, we call it below using the initial value of $\\theta$ (initialized to all zeros), and also another test case where $\\theta$ is all ones." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost at initial theta (zeros): 0.693\n", + "Expected cost (approx) : 0.693\n", + "\n", + "Gradient at initial theta (zeros) - first five values only:\n", + "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n", + "Expected gradients (approx) - first five values only:\n", + "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n", + "\n", + "------------------------------\n", + "\n", + "Cost at test theta : 2.33\n", + "Expected cost (approx): 3.16\n", + "\n", + "Gradient at initial theta (zeros) - first five values only:\n", + "\t[-0.3291, 0.0457, -0.0251, 0.0433, 0.1003]\n", + "Expected gradients (approx) - first five values only:\n", + "\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]\n" + ] + } + ], + "source": [ + "# Initialize fitting parameters\n", + "initial_theta = np.zeros(X.shape[1])\n", + "\n", + "# Set regularization parameter lambda to 1\n", + "# DO NOT use `lambda` as a variable name in python\n", + "# because it is a python keyword\n", + "lambda_ = 1\n", + "\n", + "# Compute and display initial cost and gradient for regularized logistic\n", + "# regression\n", + "cost, grad = costFunctionReg(initial_theta, X, y, lambda_)\n", + "\n", + "print('Cost at initial theta (zeros): {:.3f}'.format(cost))\n", + "print('Expected cost (approx) : 0.693\\n')\n", + "\n", + "print('Gradient at initial theta (zeros) - first five values only:')\n", + "print('\\t[{:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f}]'.format(*grad[:5]))\n", + "print('Expected gradients (approx) - first five values only:')\n", + "print('\\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\\n')\n", + "\n", + "\n", + "# Compute and display cost and gradient\n", + "# with all-ones theta and lambda = 10\n", + "test_theta = np.ones(X.shape[1])\n", + "cost, grad = costFunctionReg(test_theta, X, y, 10)\n", + "\n", + "print('------------------------------\\n')\n", + "print('Cost at test theta : {:.2f}'.format(cost))\n", + "print('Expected cost (approx): 3.16\\n')\n", + "\n", + "print('Gradient at initial theta (zeros) - first five values only:')\n", + "print('\\t[{:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f}]'.format(*grad[:5]))\n", + "print('Expected gradients (approx) - first five values only:')\n", + "print('\\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise logistic-regression\n", + "\n" + ] + } + ], + "source": [ + "grader[5] = costFunctionReg\n", + "grader[6] = costFunctionReg\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.3.1 Learning parameters using `scipy.optimize.minimize`\n", + "\n", + "Similar to the previous parts, you will use `optimize.minimize` to learn the optimal parameters $\\theta$. If you have completed the cost and gradient for regularized logistic regression (`costFunctionReg`) correctly, you should be able to step through the next part of to learn the parameters $\\theta$ using `optimize.minimize`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.4 Plotting the decision boundary\n", + "\n", + "To help you visualize the model learned by this classifier, we have provided the function `plotDecisionBoundary` which plots the (non-linear) decision boundary that separates the positive and negative examples. In `plotDecisionBoundary`, we plot the non-linear decision boundary by computing the classifier’s predictions on an evenly spaced grid and then and draw a contour plot where the predictions change from y = 0 to y = 1. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.5 Optional (ungraded) exercises\n", + "\n", + "In this part of the exercise, you will get to try out different regularization parameters for the dataset to understand how regularization prevents overfitting.\n", + "\n", + "Notice the changes in the decision boundary as you vary $\\lambda$. With a small\n", + "$\\lambda$, you should find that the classifier gets almost every training example correct, but draws a very complicated boundary, thus overfitting the data. See the following figures for the decision boundaries you should get for different values of $\\lambda$. \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " No regularization (overfitting)\n", + " \n", + " Decision boundary with regularization\n", + " \n", + " \n", + " Decision boundary with too much regularization\n", + " \n", + "
\n", + "\n", + "This is not a good decision boundary: for example, it predicts that a point at $x = (−0.25, 1.5)$ is accepted $(y = 1)$, which seems to be an incorrect decision given the training set.\n", + "With a larger $\\lambda$, you should see a plot that shows an simpler decision boundary which still separates the positives and negatives fairly well. However, if $\\lambda$ is set to too high a value, you will not get a good fit and the decision boundary will not follow the data so well, thus underfitting the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize fitting parameters\n", + "initial_theta = np.zeros(X.shape[1])\n", + "\n", + "# Set regularization parameter lambda to 1 (you should vary this)\n", + "lambda_ = 1\n", + "\n", + "# set options for optimize.minimize\n", + "options= {'maxiter': 100}\n", + "\n", + "res = optimize.minimize(costFunctionReg,\n", + " initial_theta,\n", + " (X, y, lambda_),\n", + " jac=True,\n", + " method='TNC',\n", + " options=options)\n", + "\n", + "# the fun property of OptimizeResult object returns\n", + "# the value of costFunction at optimized theta\n", + "cost = res.fun\n", + "\n", + "# the optimized theta is in the x property of the result\n", + "theta = res.x\n", + "\n", + "utils.plotDecisionBoundary(plotData, theta, X, y)\n", + "pyplot.xlabel('Microchip Test 1')\n", + "pyplot.ylabel('Microchip Test 2')\n", + "pyplot.legend(['y = 1', 'y = 0'])\n", + "pyplot.grid(False)\n", + "pyplot.title('lambda = %0.2f' % lambda_)\n", + "\n", + "# Compute accuracy on our training set\n", + "p = predict(theta, X)\n", + "\n", + "print('Train Accuracy: %.1f %%' % (np.mean(p == y) * 100))\n", + "print('Expected accuracy (with lambda = 1): 83.1 % (approx)\\n')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You do not need to submit any solutions for these optional (ungraded) exercises.*" + ] + }, + { + "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.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/exercise3.ipynb b/exercise3.ipynb new file mode 100644 index 000000000..585f2fbd9 --- /dev/null +++ b/exercise3.ipynb @@ -0,0 +1,1115 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Programming Exercise 3\n", + "# Multi-class Classification and Neural Networks\n", + "\n", + "## Introduction\n", + "\n", + "\n", + "In this exercise, you will implement one-vs-all logistic regression and neural networks to recognize handwritten digits. Before starting the programming exercise, we strongly recommend watching the video lectures and completing the review questions for the associated topics. \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 | [Regularized Logistic Regression](#section1) | [`lrCostFunction`](#lrCostFunction) | 30 \n", + "| 2 | [One-vs-all classifier training](#section2) | [`oneVsAll`](#oneVsAll) | 20 \n", + "| 3 | [One-vs-all classifier prediction](#section3) | [`predictOneVsAll`](#predictOneVsAll) | 20 \n", + "| 4 | [Neural Network Prediction Function](#section4) | [`predict`](#predict) | 30\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", + "
\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. They must also be re-executed everytime the submitted function is updated.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1 Multi-class Classification\n", + "\n", + "For this exercise, you will use logistic regression and neural networks to recognize handwritten digits (from 0 to 9). Automated handwritten digit recognition is widely used today - from recognizing zip codes (postal codes)\n", + "on mail envelopes to recognizing amounts written on bank checks. This exercise will show you how the methods you have learned can be used for this classification task.\n", + "\n", + "In the first part of the exercise, you will extend your previous implementation of logistic regression and apply it to one-vs-all classification.\n", + "\n", + "### 1.1 Dataset\n", + "\n", + "You are given a data set in `ex3data1.mat` that contains 5000 training examples of handwritten digits (This is a subset of the [MNIST](http://yann.lecun.com/exdb/mnist) handwritten digit dataset). The `.mat` format means that that the data has been saved in a native Octave/MATLAB matrix format, instead of a text (ASCII) format like a csv-file. We use the `.mat` format here because this is the dataset provided in the MATLAB version of this assignment. Fortunately, python provides mechanisms to load MATLAB native format using the `loadmat` function within the `scipy.io` module. This function returns a python dictionary with keys containing the variable names within the `.mat` file. \n", + "\n", + "There are 5000 training examples in `ex3data1.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 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} - \\: (x^{(1)})^T \\: - \\\\ -\\: (x^{(2)})^T \\:- \\\\ \\vdots \\\\ - \\: (x^{(m)})^T \\:- \\end{bmatrix} $$\n", + "\n", + "The second part of the training set is a 5000-dimensional vector `y` that contains labels for the training set. \n", + "We start the exercise by first loading the dataset. Execute the cell below, you do not need to write any code here." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# 20x20 Input Images of Digits\n", + "input_layer_size = 400\n", + "\n", + "# 10 labels, from 1 to 10 (note that we have mapped \"0\" to label 10)\n", + "num_labels = 10\n", + "\n", + "# training data stored in arrays X, y\n", + "data = loadmat(os.path.join('Data', 'ex3data1.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", + "m = y.size" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 Visualizing the data\n", + "\n", + "You will begin by visualizing a subset of the training set. In the following cell, the code randomly selects selects 100 rows from `X` and passes those rows to the `displayData` function. This function maps each row to a 20 pixel by 20 pixel grayscale image and displays the images together. We have provided the `displayData` function in the file `utils.py`. You are encouraged to examine the code to see how it works. Run the following cell to visualize the data." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "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": { + "collapsed": true + }, + "source": [ + "### 1.3 Vectorizing Logistic Regression\n", + "\n", + "You will be using multiple one-vs-all logistic regression models to build a multi-class classifier. Since there are 10 classes, you will need to train 10 separate logistic regression classifiers. To make this training efficient, it is important to ensure that your code is well vectorized. In this section, you will implement a vectorized version of logistic regression that does not employ any `for` loops. You can use your code in the previous exercise as a starting point for this exercise. \n", + "\n", + "To test your vectorized logistic regression, we will use custom data as defined in the following cell." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "# test values for the parameters theta\n", + "from sklearn import preprocessing\n", + "from sklearn.model_selection import StratifiedKFold\n", + "from sklearn.preprocessing import StandardScaler\n", + "theta_t = np.array([-2, -1, 1, 2], dtype=float)\n", + "\n", + "# test values for the inputs\n", + "X_t = np.concatenate([np.ones((5, 1)), np.arange(1, 16).reshape(5, 3, order='F')/10.0], axis=1)\n", + "\n", + "\n", + "# test values for the labels\n", + "y_t = np.array([1, 0, 1, 0, 1])\n", + "\n", + "# test value for the regularization parameter\n", + "lambda_t = 3\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "#### 1.3.1 Vectorizing the cost function \n", + "\n", + "We will begin by writing a vectorized version of the cost function. Recall that in (unregularized) logistic regression, the cost function is\n", + "\n", + "$$ J(\\theta) = \\frac{1}{m} \\sum_{i=1}^m \\left[ -y^{(i)} \\log \\left( h_\\theta\\left( x^{(i)} \\right) \\right) - \\left(1 - y^{(i)} \\right) \\log \\left(1 - h_\\theta \\left( x^{(i)} \\right) \\right) \\right] $$\n", + "\n", + "To compute each element in the summation, we have to compute $h_\\theta(x^{(i)})$ for every example $i$, where $h_\\theta(x^{(i)}) = g(\\theta^T x^{(i)})$ and $g(z) = \\frac{1}{1+e^{-z}}$ is the sigmoid function. It turns out that we can compute this quickly for all our examples by using matrix multiplication. Let us define $X$ and $\\theta$ as\n", + "\n", + "$$ X = \\begin{bmatrix} - \\left( x^{(1)} \\right)^T - \\\\ - \\left( x^{(2)} \\right)^T - \\\\ \\vdots \\\\ - \\left( x^{(m)} \\right)^T - \\end{bmatrix} \\qquad \\text{and} \\qquad \\theta = \\begin{bmatrix} \\theta_0 \\\\ \\theta_1 \\\\ \\vdots \\\\ \\theta_n \\end{bmatrix} $$\n", + "\n", + "Then, by computing the matrix product $X\\theta$, we have: \n", + "\n", + "$$ X\\theta = \\begin{bmatrix} - \\left( x^{(1)} \\right)^T\\theta - \\\\ - \\left( x^{(2)} \\right)^T\\theta - \\\\ \\vdots \\\\ - \\left( x^{(m)} \\right)^T\\theta - \\end{bmatrix} = \\begin{bmatrix} - \\theta^T x^{(1)} - \\\\ - \\theta^T x^{(2)} - \\\\ \\vdots \\\\ - \\theta^T x^{(m)} - \\end{bmatrix} $$\n", + "\n", + "In the last equality, we used the fact that $a^Tb = b^Ta$ if $a$ and $b$ are vectors. This allows us to compute the products $\\theta^T x^{(i)}$ for all our examples $i$ in one line of code.\n", + "\n", + "#### 1.3.2 Vectorizing the gradient\n", + "\n", + "Recall that the gradient of the (unregularized) logistic regression cost is a vector where the $j^{th}$ element is defined as\n", + "\n", + "$$ \\frac{\\partial J }{\\partial \\theta_j} = \\frac{1}{m} \\sum_{i=1}^m \\left( \\left( h_\\theta\\left(x^{(i)}\\right) - y^{(i)} \\right)x_j^{(i)} \\right) $$\n", + "\n", + "To vectorize this operation over the dataset, we start by writing out all the partial derivatives explicitly for all $\\theta_j$,\n", + "\n", + "$$\n", + "\\begin{align*}\n", + "\\begin{bmatrix} \n", + "\\frac{\\partial J}{\\partial \\theta_0} \\\\\n", + "\\frac{\\partial J}{\\partial \\theta_1} \\\\\n", + "\\frac{\\partial J}{\\partial \\theta_2} \\\\\n", + "\\vdots \\\\\n", + "\\frac{\\partial J}{\\partial \\theta_n}\n", + "\\end{bmatrix} = &\n", + "\\frac{1}{m} \\begin{bmatrix}\n", + "\\sum_{i=1}^m \\left( \\left(h_\\theta\\left(x^{(i)}\\right) - y^{(i)} \\right)x_0^{(i)}\\right) \\\\\n", + "\\sum_{i=1}^m \\left( \\left(h_\\theta\\left(x^{(i)}\\right) - y^{(i)} \\right)x_1^{(i)}\\right) \\\\\n", + "\\sum_{i=1}^m \\left( \\left(h_\\theta\\left(x^{(i)}\\right) - y^{(i)} \\right)x_2^{(i)}\\right) \\\\\n", + "\\vdots \\\\\n", + "\\sum_{i=1}^m \\left( \\left(h_\\theta\\left(x^{(i)}\\right) - y^{(i)} \\right)x_n^{(i)}\\right) \\\\\n", + "\\end{bmatrix} \\\\\n", + "= & \\frac{1}{m} \\sum_{i=1}^m \\left( \\left(h_\\theta\\left(x^{(i)}\\right) - y^{(i)} \\right)x^{(i)}\\right) \\\\\n", + "= & \\frac{1}{m} X^T \\left( h_\\theta(x) - y\\right)\n", + "\\end{align*}\n", + "$$\n", + "\n", + "where\n", + "\n", + "$$ h_\\theta(x) - y = \n", + "\\begin{bmatrix}\n", + "h_\\theta\\left(x^{(1)}\\right) - y^{(1)} \\\\\n", + "h_\\theta\\left(x^{(2)}\\right) - y^{(2)} \\\\\n", + "\\vdots \\\\\n", + "h_\\theta\\left(x^{(m)}\\right) - y^{(m)} \n", + "\\end{bmatrix} $$\n", + "\n", + "Note that $x^{(i)}$ is a vector, while $h_\\theta\\left(x^{(i)}\\right) - y^{(i)}$ is a scalar (single number).\n", + "To understand the last step of the derivation, let $\\beta_i = (h_\\theta\\left(x^{(m)}\\right) - y^{(m)})$ and\n", + "observe that:\n", + "\n", + "$$ \\sum_i \\beta_ix^{(i)} = \\begin{bmatrix} \n", + "| & | & & | \\\\\n", + "x^{(1)} & x^{(2)} & \\cdots & x^{(m)} \\\\\n", + "| & | & & | \n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + "\\beta_1 \\\\\n", + "\\beta_2 \\\\\n", + "\\vdots \\\\\n", + "\\beta_m\n", + "\\end{bmatrix} = x^T \\beta\n", + "$$\n", + "\n", + "where the values $\\beta_i = \\left( h_\\theta(x^{(i)} - y^{(i)} \\right)$.\n", + "\n", + "The expression above allows us to compute all the partial derivatives\n", + "without any loops. If you are comfortable with linear algebra, we encourage you to work through the matrix multiplications above to convince yourself that the vectorized version does the same computations. \n", + "\n", + "Your job is to write the unregularized cost function `lrCostFunction` which returns both the cost function $J(\\theta)$ and its gradient $\\frac{\\partial J}{\\partial \\theta}$. Your implementation should use the strategy we presented above to calculate $\\theta^T x^{(i)}$. You should also use a vectorized approach for the rest of the cost function. A fully vectorized version of `lrCostFunction` should not contain any loops.\n", + "\n", + "
\n", + "**Debugging Tip:** Vectorizing code can sometimes be tricky. One common strategy for debugging is to print out the sizes of the matrices you are working with using the `shape` property of `numpy` arrays. For example, given a data matrix $X$ of size $100 \\times 20$ (100 examples, 20 features) and $\\theta$, a vector with size $20$, you can observe that `np.dot(X, theta)` is a valid multiplication operation, while `np.dot(theta, X)` is not. Furthermore, if you have a non-vectorized version of your code, you can compare the output of your vectorized code and non-vectorized code to make sure that they produce the same outputs.\n", + "
\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "def lrCostFunction(theta, X, y, lambda_):\n", + " \"\"\"\n", + " Computes the cost of using theta as the parameter for regularized\n", + " logistic regression and the gradient of the cost w.r.t. to the parameters.\n", + " \n", + " Parameters\n", + " ----------\n", + " theta : array_like\n", + " Logistic regression parameters. A vector with shape (n, ). n is \n", + " the number of features including any intercept. \n", + " \n", + " X : array_like\n", + " The data set with shape (m x n). m is the number of examples, and\n", + " n is the number of features (including intercept).\n", + " \n", + " y : array_like\n", + " The data labels. A vector with shape (m, ).\n", + " \n", + " lambda_ : float\n", + " The regularization parameter. \n", + " \n", + " Returns\n", + " -------\n", + " J : float\n", + " The computed value for the regularized cost function. \n", + " \n", + " grad : array_like\n", + " A vector of shape (n, ) which is the gradient of the cost\n", + " function with respect to theta, at the current values of theta.\n", + " \n", + " Instructions\n", + " ------------\n", + " Compute the cost of a particular choice of theta. You should set J to the cost.\n", + " Compute the partial derivatives and set grad to the partial\n", + " derivatives of the cost w.r.t. each parameter in theta\n", + " \n", + " Hint 1\n", + " ------\n", + " The computation of the cost function and gradients can be efficiently\n", + " vectorized. For example, consider the computation\n", + " \n", + " sigmoid(X * theta)\n", + " \n", + " Each row of the resulting matrix will contain the value of the prediction\n", + " for that example. You can make use of this to vectorize the cost function\n", + " and gradient computations. \n", + " \n", + " Hint 2\n", + " ------\n", + " When computing the gradient of the regularized cost function, there are\n", + " many possible vectorized solutions, but one solution looks like:\n", + " \n", + " grad = (unregularized gradient for logistic regression)\n", + " temp = theta \n", + " temp[0] = 0 # because we don't add anything for j = 0\n", + " grad = grad + YOUR_CODE_HERE (using the temp variable)\n", + " \n", + " Hint 3\n", + " ------\n", + " We have provided the implementatation of the sigmoid function within \n", + " the file `utils.py`. At the start of the notebook, we imported this file\n", + " as a module. Thus to access the sigmoid function within that file, you can\n", + " do the following: `utils.sigmoid(z)`.\n", + " \n", + " \"\"\"\n", + " #Initialize some useful values\n", + " m = y.size\n", + " \n", + " # convert labels to ints if their type is bool\n", + " if y.dtype == bool:\n", + " y = y.astype(int)\n", + " \n", + " # You need to return the following variables correctly\n", + " J = 0\n", + " grad = np.zeros(theta.shape)\n", + " \n", + " # ====================== YOUR CODE HERE ======================\n", + " z = X.dot(theta)\n", + " h = utils.sigmoid(z)\n", + " J = (1 / m) * (np.sum(-y.T.dot(np.log(h)) - (1 - y).T.dot(np.log(1 - h))))+(lambda_*(sum(theta*theta)))/(2*m)\n", + " #cost = (1 / m) * (np.sum(-y.T.dot(np.log(h)) - (1 - y).T.dot(np.log(1 - h))))\n", + " temp = (lambda_/m)*theta\n", + " temp[0]=0\n", + " grad = (X.T.dot(h - y)) / m + temp\n", + " \n", + " \n", + "\n", + " \n", + " # =============================================================\n", + " return J, grad" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 1.3.3 Vectorizing regularized logistic regression\n", + "\n", + "After you have implemented vectorization for logistic regression, you will now\n", + "add regularization to the cost function. Recall that for regularized logistic\n", + "regression, the cost function is defined as\n", + "\n", + "$$ J(\\theta) = \\frac{1}{m} \\sum_{i=1}^m \\left[ -y^{(i)} \\log \\left(h_\\theta\\left(x^{(i)} \\right)\\right) - \\left( 1 - y^{(i)} \\right) \\log\\left(1 - h_\\theta \\left(x^{(i)} \\right) \\right) \\right] + \\frac{\\lambda}{2m} \\sum_{j=1}^n \\theta_j^2 $$\n", + "\n", + "Note that you should not be regularizing $\\theta_0$ which is used for the bias term.\n", + "Correspondingly, the partial derivative of regularized logistic regression cost for $\\theta_j$ is defined as\n", + "\n", + "$$\n", + "\\begin{align*}\n", + "& \\frac{\\partial J(\\theta)}{\\partial \\theta_0} = \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta\\left( x^{(i)} \\right) - y^{(i)} \\right) x_j^{(i)} & \\text{for } j = 0 \\\\\n", + "& \\frac{\\partial J(\\theta)}{\\partial \\theta_0} = \\left( \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta\\left( x^{(i)} \\right) - y^{(i)} \\right) x_j^{(i)} \\right) + \\frac{\\lambda}{m} \\theta_j & \\text{for } j \\ge 1\n", + "\\end{align*}\n", + "$$\n", + "\n", + "Now modify your code in lrCostFunction in the [**previous cell**](#lrCostFunction) to account for regularization. Once again, you should not put any loops into your code.\n", + "\n", + "
\n", + "**python/numpy Tip:** When implementing the vectorization for regularized logistic regression, you might often want to only sum and update certain elements of $\\theta$. In `numpy`, you can index into the matrices to access and update only certain elements. For example, A[:, 3:5]\n", + "= B[:, 1:3] will replaces the columns with index 3 to 5 of A with the columns with index 1 to 3 from B. To select columns (or rows) until the end of the matrix, you can leave the right hand side of the colon blank. For example, A[:, 2:] will only return elements from the $3^{rd}$ to last columns of $A$. If you leave the left hand size of the colon blank, you will select elements from the beginning of the matrix. For example, A[:, :2] selects the first two columns, and is equivalent to A[:, 0:2]. In addition, you can use negative indices to index arrays from the end. Thus, A[:, :-1] selects all columns of A except the last column, and A[:, -5:] selects the $5^{th}$ column from the end to the last column. Thus, you could use this together with the sum and power ($^{**}$) operations to compute the sum of only the elements you are interested in (e.g., `np.sum(z[1:]**2)`). In the starter code, `lrCostFunction`, we have also provided hints on yet another possible method computing the regularized gradient.\n", + "
\n", + "\n", + "Once you finished your implementation, you can call the function `lrCostFunction` to test your solution using the following cell:" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost : 3.734819\n", + "Expected cost: 2.534819\n", + "-----------------------\n", + "Gradients:\n", + " [0.146561, -0.548558, 0.724722, 1.398003]\n", + "Expected gradients:\n", + " [0.146561, -0.548558, 0.724722, 1.398003]\n" + ] + } + ], + "source": [ + "J, grad = lrCostFunction(theta_t, X_t, y_t, lambda_t)\n", + "\n", + "print('Cost : {:.6f}'.format(J))\n", + "print('Expected cost: 2.534819')\n", + "print('-----------------------')\n", + "print('Gradients:')\n", + "print(' [{:.6f}, {:.6f}, {:.6f}, {:.6f}]'.format(*grad))\n", + "print('Expected gradients:')\n", + "print(' [0.146561, -0.548558, 0.724722, 1.398003]');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After completing a part of the exercise, you can submit your solutions for grading by first adding the function you modified to the submission object, and then sending your function to Coursera for grading. \n", + "\n", + "The submission script will prompt you for your login e-mail and submission token. You can obtain a submission token from the web page for the assignment. You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n", + "\n", + "*Execute the following cell to grade your solution to the first part of this exercise.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# appends the implemented function in part 1 to the grader object\n", + "grader[1] = lrCostFunction\n", + "\n", + "# send the added functions to coursera grader for getting a grade on this part\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 1.4 One-vs-all Classification\n", + "\n", + "In this part of the exercise, you will implement one-vs-all classification by training multiple regularized logistic regression classifiers, one for each of the $K$ classes in our dataset. In the handwritten digits dataset, $K = 10$, but your code should work for any value of $K$. \n", + "\n", + "You should now complete the code for the function `oneVsAll` below, to train one classifier for each class. In particular, your code should return all the classifier parameters in a matrix $\\theta \\in \\mathbb{R}^{K \\times (N +1)}$, where each row of $\\theta$ corresponds to the learned logistic regression parameters for one class. You can do this with a “for”-loop from $0$ to $K-1$, training each classifier independently.\n", + "\n", + "Note that the `y` argument to this function is a vector of labels from 0 to 9. When training the classifier for class $k \\in \\{0, ..., K-1\\}$, you will want a K-dimensional vector of labels $y$, where $y_j \\in 0, 1$ indicates whether the $j^{th}$ training instance belongs to class $k$ $(y_j = 1)$, or if it belongs to a different\n", + "class $(y_j = 0)$. You may find logical arrays helpful for this task. \n", + "\n", + "Furthermore, you will be using scipy's `optimize.minimize` for this exercise. \n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "def oneVsAll(X, y, num_labels, lambda_):\n", + " \"\"\"\n", + " Trains num_labels logistic regression classifiers and returns\n", + " each of these classifiers in a matrix all_theta, where the i-th\n", + " row of all_theta corresponds to the classifier for label i.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The input dataset of shape (m x n). m is the number of \n", + " data points, and n is the number of features. Note that we \n", + " do not assume that the intercept term (or bias) is in X, however\n", + " we provide the code below to add the bias term to X. \n", + " \n", + " y : array_like\n", + " The data labels. A vector of shape (m, ).\n", + " \n", + " num_labels : int\n", + " Number of possible labels.\n", + " \n", + " lambda_ : float\n", + " The logistic regularization parameter.\n", + " \n", + " Returns\n", + " -------\n", + " all_theta : array_like\n", + " The trained parameters for logistic regression for each class.\n", + " This is a matrix of shape (K x n+1) where K is number of classes\n", + " (ie. `numlabels`) and n is number of features without the bias.\n", + " \n", + " Instructions\n", + " ------------\n", + " You should complete the following code to train `num_labels`\n", + " logistic regression classifiers with regularization parameter `lambda_`. \n", + " \n", + " Hint\n", + " ----\n", + " You can use y == c to obtain a vector of 1's and 0's that tell you\n", + " whether the ground truth is true/false for this class.\n", + " \n", + " Note\n", + " ----\n", + " For this assignment, we recommend using `scipy.optimize.minimize(method='CG')`\n", + " to optimize the cost function. It is okay to use a for-loop \n", + " (`for c in range(num_labels):`) to loop over the different classes.\n", + " \n", + " Example Code\n", + " ------------\n", + " \n", + " # Set Initial theta\n", + " initial_theta = np.zeros(n + 1)\n", + " \n", + " # Set options for minimize\n", + " options = {'maxiter': 50}\n", + " \n", + " # Run minimize to obtain the optimal theta. This function will \n", + " # return a class object where theta is in `res.x` and cost in `res.fun`\n", + " res = optimize.minimize(lrCostFunction, \n", + " initial_theta, \n", + " (X, (y == c), lambda_), \n", + " jac=True, \n", + " method='TNC',\n", + " options=options) \n", + " \"\"\"\n", + " # Some useful variables\n", + " m, n = X.shape\n", + " \n", + " # You need to return the following variables correctly \n", + " all_theta = np.zeros((num_labels, n + 1))\n", + "\n", + " # Add ones to the X data matrix\n", + " X = np.concatenate([np.ones((m, 1)), X], axis=1)\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " for c in range(num_labels):\n", + " initial_theta = np.zeros(n+1)\n", + " options = {'maxiter':50}\n", + " res = optimize.minimize(lrCostFunction, \n", + " initial_theta, \n", + " (X, (y == c), lambda_), \n", + " jac=True, \n", + " method='TNC',\n", + " options=options) \n", + " all_theta[c]= res.x\n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " # ============================================================\n", + " return all_theta" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After you have completed the code for `oneVsAll`, the following cell will use your implementation to train a multi-class classifier. " + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10, 404)\n" + ] + } + ], + "source": [ + "lambda_ = 0.1\n", + "all_theta = oneVsAll(X, y, num_labels, lambda_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[2] = oneVsAll\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "#### 1.4.1 One-vs-all Prediction\n", + "\n", + "After training your one-vs-all classifier, you can now use it to predict the digit contained in a given image. For each input, you should compute the “probability” that it belongs to each class using the trained logistic regression classifiers. Your one-vs-all prediction function will pick the class for which the corresponding logistic regression classifier outputs the highest probability and return the class label (0, 1, ..., K-1) as the prediction for the input example. You should now complete the code in the function `predictOneVsAll` to use the one-vs-all classifier for making predictions. \n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [], + "source": [ + "def predictOneVsAll(all_theta, X):\n", + " \"\"\"\n", + " Return a vector of predictions for each example in the matrix X. \n", + " Note that X contains the examples in rows. all_theta is a matrix where\n", + " the i-th row is a trained logistic regression theta vector for the \n", + " i-th class. You should set p to a vector of values from 0..K-1 \n", + " (e.g., p = [0, 2, 0, 1] predicts classes 0, 2, 0, 1 for 4 examples) .\n", + " \n", + " Parameters\n", + " ----------\n", + " all_theta : array_like\n", + " The trained parameters for logistic regression for each class.\n", + " This is a matrix of shape (K x n+1) where K is number of classes\n", + " and n is number of features without the bias.\n", + " \n", + " X : array_like\n", + " Data points to predict their labels. This is a matrix of shape \n", + " (m x n) where m is number of data points to predict, and n is number \n", + " of features without the bias term. Note we add the bias term for X in \n", + " this function. \n", + " \n", + " Returns\n", + " -------\n", + " p : array_like\n", + " The predictions for each data point in X. This is a vector of shape (m, ).\n", + " \n", + " Instructions\n", + " ------------\n", + " Complete the following code to make predictions using your learned logistic\n", + " regression parameters (one-vs-all). You should set p to a vector of predictions\n", + " (from 0 to num_labels-1).\n", + " \n", + " Hint\n", + " ----\n", + " This code can be done all vectorized using the numpy argmax function.\n", + " In particular, the argmax function returns the index of the max element,\n", + " for more information see '?np.argmax' or search online. If your examples\n", + " are in rows, then, you can use np.argmax(A, axis=1) to obtain the index \n", + " of the max for each row.\n", + " \"\"\"\n", + " m = X.shape[0];\n", + " num_labels = all_theta.shape[0]\n", + "\n", + " # You need to return the following variables correctly \n", + " p = np.zeros(m)\n", + "\n", + " # Add ones to the X data matrix\n", + " X = np.concatenate([np.ones((m, 1)), X], axis=1)\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " # print(X)\n", + " #all_theta = np.concatenate([np.arange(num_labels),all_theta])\n", + " #q = [max((utils.sigmoid(i.dot(theta)), c) for theta, c in all_theta)[1] for i in X ]\n", + " #print(X[1].shape)\n", + " #print(all_theta[1].shape)\n", + " A = np.zeros((m,num_labels))\n", + " for i in range(m):\n", + " #print(X[i])\n", + " for j in range(num_labels):\n", + " #print(all_theta[j])\n", + " A[i,j]= utils.sigmoid(X[i].dot(all_theta[j]))\n", + " print(A.shape)\n", + " print(A)\n", + " p=np.argmax(A,axis=1)\n", + "\n", + "\n", + "\n", + " \n", + " # ============================================================\n", + " return p" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you are done, call your `predictOneVsAll` function using the learned value of $\\theta$. You should see that the training set accuracy is about 95.1% (i.e., it classifies 95.1% of the examples in the training set correctly)." + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5000, 10)\n", + "[[9.99769333e-01 1.54982847e-15 2.43800058e-04 ... 2.55635510e-07\n", + " 1.13925125e-05 1.40260676e-03]\n", + " [9.99986047e-01 1.54954592e-12 1.88901927e-05 ... 7.89455828e-07\n", + " 1.08353538e-07 3.09064449e-05]\n", + " [9.99939875e-01 7.18496780e-15 4.36193444e-04 ... 8.40335748e-08\n", + " 1.40728613e-02 8.47423902e-04]\n", + " ...\n", + " [2.73890301e-10 1.72539018e-02 4.53646116e-03 ... 1.73305603e-05\n", + " 1.47043618e-03 8.88663607e-01]\n", + " [4.58259949e-08 2.35724433e-11 3.34185503e-09 ... 1.96091547e-04\n", + " 3.35330289e-02 9.48448644e-01]\n", + " [3.00421252e-03 9.25314023e-18 2.96195863e-06 ... 2.97409734e-01\n", + " 2.84855028e-03 2.60113046e-01]]\n", + "Training Set Accuracy: 95.56%\n" + ] + } + ], + "source": [ + "pred = predictOneVsAll(all_theta, X)\n", + "print('Training Set Accuracy: {:.2f}%'.format(np.mean(pred == y) * 100))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n" + ] + } + ], + "source": [ + "grader[3] = predictOneVsAll\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2 Neural Networks\n", + "\n", + "In the previous part of this exercise, you implemented multi-class logistic regression to recognize handwritten digits. However, logistic regression cannot form more complex hypotheses as it is only a linear classifier (You could add more features - such as polynomial features - to logistic regression, but that can be very expensive to train).\n", + "\n", + "In this part of the exercise, you will implement a neural network to recognize handwritten digits using the same training set as before. The neural network will be able to represent complex models that form non-linear hypotheses. For this week, you will be using parameters from a neural network that we have already trained. Your goal is to implement the feedforward propagation algorithm to use our weights for prediction. In next week’s exercise, you will write the backpropagation algorithm for learning the neural network parameters. \n", + "\n", + "We start by first reloading and visualizing the dataset which contains the MNIST handwritten digits (this is the same as we did in the first part of this exercise, we reload it here to ensure the variables have not been modified). " + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1672 32 426 ... 2559 2861 4768]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# training data stored in arrays X, y\n", + "data = loadmat(os.path.join('Data', 'ex3data1.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", + "\n", + "# get number of examples in dataset\n", + "m = y.size\n", + "\n", + "# randomly permute examples, to be used for visualizing one \n", + "# picture at a time\n", + "indices = np.random.permutation(m)\n", + "print(indices)\n", + "\n", + "# 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": [ + "\n", + "### 2.1 Model representation \n", + "\n", + "Our neural network is shown in the following figure.\n", + "\n", + "![Neural network](Figures/neuralnetwork.png)\n", + "\n", + "It has 3 layers: an input layer, a hidden layer and an output layer. Recall that our inputs are pixel values of digit images. Since the images are of size 20×20, this gives us 400 input layer units (excluding the extra bias unit which always outputs +1). As before, the training data will be loaded into the variables X and y. \n", + "\n", + "You have been provided with a set of network parameters ($\\Theta^{(1)}$, $\\Theta^{(2)}$) already trained by us. These are stored in `ex3weights.mat`. The following cell loads those parameters 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": 47, + "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 .mat file, which returns a dictionary \n", + "weights = loadmat(os.path.join('Data', 'ex3weights.mat'))\n", + "\n", + "# get the model weights from the dictionary\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)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 2.2 Feedforward Propagation and Prediction\n", + "\n", + "Now you will implement feedforward propagation for the neural network. You will need to complete the code in the function `predict` to return the neural network’s prediction. You should implement the feedforward computation that computes $h_\\theta(x^{(i)})$ for every example $i$ and returns the associated predictions. Similar to the one-vs-all classification strategy, the prediction from the neural network will be the label that has the largest output $\\left( h_\\theta(x) \\right)_k$.\n", + "\n", + "
\n", + "**Implementation Note:** The matrix $X$ contains the examples in rows. When you complete the code in the function `predict`, you will need to add the column of 1’s to the matrix. The matrices `Theta1` and `Theta2` contain the parameters for each unit in rows. Specifically, the first row of `Theta1` corresponds to the first hidden unit in the second layer. In `numpy`, when you compute $z^{(2)} = \\theta^{(1)}a^{(1)}$, be sure that you index (and if necessary, transpose) $X$ correctly so that you get $a^{(l)}$ as a 1-D vector.\n", + "
\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## " + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (, line 60)", + "output_type": "error", + "traceback": [ + "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m60\u001b[0m\n\u001b[1;33m a = utils.sigmoid(z)\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "source": [ + "def predict(Theta1, Theta2, X):\n", + " \"\"\"\n", + " Predict the label of an input given a trained neural network.\n", + " \n", + " Parameters\n", + " ----------\n", + " Theta1 : array_like\n", + " Weights for the first layer in the neural network.\n", + " It has shape (2nd hidden layer size x input size)\n", + " \n", + " Theta2: array_like\n", + " Weights for the second layer in the neural network. \n", + " It has shape (output layer size x 2nd hidden layer size)\n", + " \n", + " X : array_like\n", + " The image inputs having shape (number of examples x image dimensions).\n", + " \n", + " Return \n", + " ------\n", + " p : array_like\n", + " Predictions vector containing the predicted label for each example.\n", + " It has a length equal to the number of examples.\n", + " \n", + " Instructions\n", + " ------------\n", + " Complete the following code to make predictions using your learned neural\n", + " network. You should set p to a vector containing labels \n", + " between 0 to (num_labels-1).\n", + " \n", + " Hint\n", + " ----\n", + " This code can be done all vectorized using the numpy argmax function.\n", + " In particular, the argmax function returns the index of the max element,\n", + " for more information see '?np.argmax' or search online. If your examples\n", + " are in rows, then, you can use np.argmax(A, axis=1) to obtain the index\n", + " of the max for each row.\n", + " \n", + " Note\n", + " ----\n", + " Remember, we have supplied the `sigmoid` function in the `utils.py` file. \n", + " You can use this function by calling `utils.sigmoid(z)`, where you can \n", + " replace `z` by the required input variable to sigmoid.\n", + " \"\"\"\n", + " # Make sure the input has two dimensions\n", + " if X.ndim == 1:\n", + " X = X[None] # promote to 2-dimensions\n", + " \n", + " # useful variables\n", + " m = X.shape[0]\n", + " num_labels = Theta2.shape[0]\n", + "\n", + " # You need to return the following variables correctly \n", + " p = np.zeros(X.shape[0])\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " A = np.zeros((m,num_labels)) \n", + " for i in range(X.shape[0]):\n", + " \n", + " z = np.dot((np.append(X[i],1),Theta1)\n", + " a = utils.sigmoid(z)\n", + " a = np.append(a2, 1)\n", + " b = utils.sigmoid(np.sum((a2*Theta2),axis=1))\n", + " A[i]=a\n", + " p=np.argmax(A,axis=1)\n", + " \n", + "\n", + " \n", + "\n", + "\n", + " # =============================================================\n", + " return p" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you are done, call your predict function using the loaded set of parameters for `Theta1` and `Theta2`. You should see that the accuracy is about 97.5%." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "dot() got an unexpected keyword argument 'axis'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mpred\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mTheta1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mTheta2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Training Set Accuracy: {:.1f}%'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpred\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m*\u001b[0m \u001b[1;36m100\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m\u001b[0m in \u001b[0;36mpredict\u001b[1;34m(Theta1, Theta2, X)\u001b[0m\n\u001b[0;32m 56\u001b[0m \u001b[0mA\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mnum_labels\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 57\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 58\u001b[1;33m \u001b[0mz\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mTheta1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 59\u001b[0m \u001b[0ma2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mutils\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msigmoid\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mz\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 60\u001b[0m \u001b[0ma2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mdot\u001b[1;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[1;31mTypeError\u001b[0m: dot() got an unexpected keyword argument 'axis'" + ] + } + ], + "source": [ + "pred = predict(Theta1, Theta2, X)\n", + "print('Training Set Accuracy: {:.1f}%'.format(np.mean(pred == y) * 100))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After that, we will display images from the training set one at a time, while at the same time printing out the predicted label for the displayed image. \n", + "\n", + "Run the following cell to display a single image the the neural network's prediction. You can run the cell multiple time to see predictions for different images." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Neural Network Prediction: 5\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "if indices.size > 0:\n", + " i, indices = indices[0], indices[1:]\n", + " utils.displayData(X[i, :], figsize=(4, 4))\n", + " pred = predict(Theta1, Theta2, X[i, :])\n", + " print('Neural Network Prediction: {}'.format(*pred))\n", + "else:\n", + " print('No more images to display!')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[4] = predict\n", + "grader.grade()" + ] + } + ], + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/exercise4.ipynb b/exercise4.ipynb new file mode 100644 index 000000000..b0dfa7cf3 --- /dev/null +++ b/exercise4.ipynb @@ -0,0 +1,1188 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "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": 21, + "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", + "
\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", + "
" + ] + }, + { + "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": 55, + "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": [ + "
" + ] + }, + "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": 56, + "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": [ + "\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", + "
\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", + "
\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "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", + " A=0\n", + " p = np.array([1])\n", + " the1 = Theta1[:,1:]\n", + " the2 = Theta2[:,1:]\n", + " for i in range(m):\n", + " Y = np.zeros(num_labels)\n", + " for c in range(num_labels):\n", + " if y[i]==c:\n", + " Y[c]=1\n", + " else:\n", + " Y[c]=0\n", + "\n", + " z = np.dot(Theta1,np.concatenate([p, X[i]]))\n", + " a= utils.sigmoid(z)\n", + " b = np.dot(Theta2,np.concatenate([p, a]))\n", + " c = utils.sigmoid(b)\n", + " B = (np.dot(Y,np.log(c))+np.dot((1-Y),np.log(1-c)))*(-1/m)\n", + " A = A + B\n", + " J = A + (lambda_/(2*m))* ((the1*the1).sum()+(the2*the2).sum())\n", + " X = np.column_stack((np.ones((m,1)), X)) \n", + " a2 = utils.sigmoid( np.dot(X,Theta1.T) )\n", + " a2 = np.column_stack((np.ones((a2.shape[0],1)), a2))\n", + " a3 = utils.sigmoid( np.dot(a2,Theta2.T) )\n", + " labels = y\n", + " y= np.zeros((m,num_labels))\n", + " for i in range(m):\n", + " y[i, labels[i]] = 1\n", + " Delta1 = 0\n", + " Delta2 = 0\n", + " for t in range(m):\n", + " x = X[t]\n", + " a2 = utils.sigmoid( np.dot(x,Theta1.T) )\n", + " a2 = np.concatenate((np.array([1]), a2))\n", + " a3 = utils.sigmoid( np.dot(a2,Theta2.T) )\n", + " delta3 = np.zeros((num_labels))\n", + " for k in range(num_labels):\n", + " y_k = y[t, k]\n", + " delta3[k] = a3[k] - y_k\n", + " delta2 = (np.dot(Theta2[:,1:].T, delta3).T) * sigmoidGradient( np.dot(x, Theta1.T) )\n", + " Delta1 += np.outer(delta2, x)\n", + " Delta2 += np.outer(delta3, a2)\n", + " \n", + " #Theta1_grad = Delta1 / m\n", + " #Theta2_grad = Delta2 / m\n", + " Theta1_grad[:,0]=Delta1[:,0]/m\n", + " Theta1_grad[:,1:]=Delta1[:,1:]/m +(lambda_/m)*(Theta1[:,1:])\n", + " Theta2_grad[:,0]=Delta2[:,0]/m\n", + " Theta2_grad[:,1:]=Delta2[:,1:]/m +(lambda_/m)*(Theta2[:,1:])\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \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": [ + "
\n", + "Use the following links to go back to the different parts of this exercise that require to modify the function `nnCostFunction`.
\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", + "
" + ] + }, + { + "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": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost at parameters (loaded from ex4weights): 0.287629 \n", + "The cost should be about : 0.287629.\n" + ] + } + ], + "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": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n" + ] + } + ], + "source": [ + "grader = utils.Grader()\n", + "grader[1] = nnCostFunction\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\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": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost at parameters (loaded from ex4weights): 0.383770\n", + "This value should be about : 0.383770.\n" + ] + } + ], + "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": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n" + ] + } + ], + "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": [ + "\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", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "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", + " s=1/(1+np.e**(-1*(z)))\n", + " f = s*(1-s)\n", + " g = f\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": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sigmoid gradient evaluated at [-1 -0.5 0 0.5 1]:\n", + " \n", + "[0.19661193 0.23500371 0.25 0.23500371 0.19661193]\n" + ] + } + ], + "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", + "
\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", + "
\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": 66, + "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", + " 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": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initializing Neural Network Parameters ...\n" + ] + } + ], + "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": [ + "\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", + "
\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", + "
\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", + "
\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", + "
\n", + "\n", + "
\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", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-9.27825235e-03 -9.27825236e-03]\n", + " [-3.04978931e-06 -3.04978914e-06]\n", + " [-1.75060082e-04 -1.75060082e-04]\n", + " [-9.62660618e-05 -9.62660620e-05]\n", + " [ 8.89911959e-03 8.89911960e-03]\n", + " [ 1.42869450e-05 1.42869443e-05]\n", + " [ 2.33146358e-04 2.33146357e-04]\n", + " [ 1.17982666e-04 1.17982666e-04]\n", + " [-8.36010761e-03 -8.36010762e-03]\n", + " [-2.59383093e-05 -2.59383100e-05]\n", + " [-2.87468729e-04 -2.87468729e-04]\n", + " [-1.37149709e-04 -1.37149706e-04]\n", + " [ 7.62813551e-03 7.62813551e-03]\n", + " [ 3.69883213e-05 3.69883234e-05]\n", + " [ 3.35320349e-04 3.35320347e-04]\n", + " [ 1.53247079e-04 1.53247082e-04]\n", + " [-6.74798369e-03 -6.74798370e-03]\n", + " [-4.68759764e-05 -4.68759769e-05]\n", + " [-3.76215585e-04 -3.76215587e-04]\n", + " [-1.66560294e-04 -1.66560294e-04]\n", + " [ 3.14544970e-01 3.14544970e-01]\n", + " [ 1.64090819e-01 1.64090819e-01]\n", + " [ 1.64567932e-01 1.64567932e-01]\n", + " [ 1.58339334e-01 1.58339334e-01]\n", + " [ 1.51127527e-01 1.51127527e-01]\n", + " [ 1.49568335e-01 1.49568335e-01]\n", + " [ 1.11056588e-01 1.11056588e-01]\n", + " [ 5.75736494e-02 5.75736493e-02]\n", + " [ 5.77867378e-02 5.77867378e-02]\n", + " [ 5.59235296e-02 5.59235296e-02]\n", + " [ 5.36967009e-02 5.36967009e-02]\n", + " [ 5.31542052e-02 5.31542052e-02]\n", + " [ 9.74006970e-02 9.74006970e-02]\n", + " [ 5.04575855e-02 5.04575855e-02]\n", + " [ 5.07530173e-02 5.07530173e-02]\n", + " [ 4.91620841e-02 4.91620841e-02]\n", + " [ 4.71456249e-02 4.71456249e-02]\n", + " [ 4.65597186e-02 4.65597186e-02]]\n", + "The above two columns you get should be very similar.\n", + "(Left-Your Numerical Gradient, Right-Analytical Gradient)\n", + "\n", + "If your backpropagation implementation is correct, then \n", + "the relative difference will be small (less than 1e-9). \n", + "Relative Difference: 2.19924e-11\n" + ] + } + ], + "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": [ + "\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": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-9.27825235e-03 -9.27825236e-03]\n", + " [-1.67679797e-02 -1.67679797e-02]\n", + " [-6.01744725e-02 -6.01744725e-02]\n", + " [-1.73704651e-02 -1.73704651e-02]\n", + " [ 8.89911959e-03 8.89911960e-03]\n", + " [ 3.94334829e-02 3.94334829e-02]\n", + " [-3.19612287e-02 -3.19612287e-02]\n", + " [-5.75658668e-02 -5.75658668e-02]\n", + " [-8.36010761e-03 -8.36010762e-03]\n", + " [ 5.93355565e-02 5.93355565e-02]\n", + " [ 2.49225535e-02 2.49225535e-02]\n", + " [-4.51963845e-02 -4.51963845e-02]\n", + " [ 7.62813550e-03 7.62813551e-03]\n", + " [ 2.47640974e-02 2.47640974e-02]\n", + " [ 5.97717617e-02 5.97717617e-02]\n", + " [ 9.14587966e-03 9.14587966e-03]\n", + " [-6.74798370e-03 -6.74798370e-03]\n", + " [-3.26881426e-02 -3.26881426e-02]\n", + " [ 3.86410548e-02 3.86410548e-02]\n", + " [ 5.46101547e-02 5.46101547e-02]\n", + " [ 3.14544970e-01 3.14544970e-01]\n", + " [ 1.18682669e-01 1.18682669e-01]\n", + " [ 2.03987128e-01 2.03987128e-01]\n", + " [ 1.25698067e-01 1.25698067e-01]\n", + " [ 1.76337550e-01 1.76337550e-01]\n", + " [ 1.32294136e-01 1.32294136e-01]\n", + " [ 1.11056588e-01 1.11056588e-01]\n", + " [ 3.81928644e-05 3.81928696e-05]\n", + " [ 1.17148233e-01 1.17148233e-01]\n", + " [-4.07588279e-03 -4.07588279e-03]\n", + " [ 1.13133142e-01 1.13133142e-01]\n", + " [-4.52964427e-03 -4.52964427e-03]\n", + " [ 9.74006970e-02 9.74006970e-02]\n", + " [ 3.36926556e-02 3.36926556e-02]\n", + " [ 7.54801264e-02 7.54801264e-02]\n", + " [ 1.69677090e-02 1.69677090e-02]\n", + " [ 8.61628953e-02 8.61628953e-02]\n", + " [ 1.50048381e-03 1.50048382e-03]]\n", + "The above two columns you get should be very similar.\n", + "(Left-Your Numerical Gradient, Right-Analytical Gradient)\n", + "\n", + "If your backpropagation implementation is correct, then \n", + "the relative difference will be small (less than 1e-9). \n", + "Relative Difference: 2.13543e-11\n", + "\n", + "\n", + "Cost at (fixed) debugging parameters (w/ lambda = 3.000000): 0.576051 \n", + "(for lambda = 3, this value should be about 0.576051)\n" + ] + } + ], + "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": 69, + "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": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Set Accuracy: 95.800000\n" + ] + } + ], + "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": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/exercise5.ipynb b/exercise5.ipynb new file mode 100644 index 000000000..1e0528ef5 --- /dev/null +++ b/exercise5.ipynb @@ -0,0 +1,1156 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Programming Exercise 5:\n", + "# Regularized Linear Regression and Bias vs Variance\n", + "\n", + "## Introduction\n", + "\n", + "In this exercise, you will implement regularized linear regression and use it to study models with different bias-variance properties. Before starting on the programming exercise, we strongly recommend watching the video lectures and completing the review questions for the associated topics.\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 | Submitted Function | Points |\n", + "| :- |:- |:- | :-: |\n", + "| 1 | [Regularized Linear Regression Cost Function](#section1) | [`linearRegCostFunction`](#linearRegCostFunction) | 25 |\n", + "| 2 | [Regularized Linear Regression Gradient](#section2) | [`linearRegCostFunction`](#linearRegCostFunction) |25 |\n", + "| 3 | [Learning Curve](#section3) | [`learningCurve`](#func2) | 20 |\n", + "| 4 | [Polynomial Feature Mapping](#section4) | [`polyFeatures`](#polyFeatures) | 10 |\n", + "| 5 | [Cross Validation Curve](#section5) | [`validationCurve`](#validationCurve) | 20 |\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", + "
\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", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1 Regularized Linear Regression\n", + "\n", + "In the first half of the exercise, you will implement regularized linear regression to predict the amount of water flowing out of a dam using the change of water level in a reservoir. In the next half, you will go through some diagnostics of debugging learning algorithms and examine the effects of bias v.s.\n", + "variance. \n", + "\n", + "### 1.1 Visualizing the dataset\n", + "\n", + "We will begin by visualizing the dataset containing historical records on the change in the water level, $x$, and the amount of water flowing out of the dam, $y$. This dataset is divided into three parts:\n", + "\n", + "- A **training** set that your model will learn on: `X`, `y`\n", + "- A **cross validation** set for determining the regularization parameter: `Xval`, `yval`\n", + "- A **test** set for evaluating performance. These are “unseen” examples which your model did not see during training: `Xtest`, `ytest`\n", + "\n", + "Run the next cell to plot the training data. In the following parts, you will implement linear regression and use that to fit a straight line to the data and plot learning curves. Following that, you will implement polynomial regression to find a better fit to the data." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Load from ex5data1.mat, where all variables will be store in a dictionary\n", + "data = loadmat(os.path.join('Data', 'ex5data1.mat'))\n", + "\n", + "# Extract train, test, validation data from dictionary\n", + "# and also convert y's form 2-D matrix (MATLAB format) to a numpy vector\n", + "X, y = data['X'], data['y'][:, 0]\n", + "Xtest, ytest = data['Xtest'], data['ytest'][:, 0]\n", + "Xval, yval = data['Xval'], data['yval'][:, 0]\n", + "\n", + "# m = Number of examples\n", + "m = y.size\n", + "\n", + "# Plot training data\n", + "pyplot.plot(X, y, 'ro', ms=10, mec='k', mew=1)\n", + "pyplot.xlabel('Change in water level (x)')\n", + "pyplot.ylabel('Water flowing out of the dam (y)');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 Regularized linear regression cost function\n", + "\n", + "Recall that regularized linear regression has the following cost function:\n", + "\n", + "$$ J(\\theta) = \\frac{1}{2m} \\left( \\sum_{i=1}^m \\left( h_\\theta\\left( x^{(i)} \\right) - y^{(i)} \\right)^2 \\right) + \\frac{\\lambda}{2m} \\left( \\sum_{j=1}^n \\theta_j^2 \\right)$$\n", + "\n", + "where $\\lambda$ is a regularization parameter which controls the degree of regularization (thus, help preventing overfitting). The regularization term puts a penalty on the overall cost J. As the magnitudes of the model parameters $\\theta_j$ increase, the penalty increases as well. Note that you should not regularize\n", + "the $\\theta_0$ term.\n", + "\n", + "You should now complete the code in the function `linearRegCostFunction` in the next cell. Your task is to calculate the regularized linear regression cost function. If possible, try to vectorize your code and avoid writing loops.\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "def linearRegCostFunction(X, y, theta, lambda_=0.0):\n", + " \"\"\"\n", + " Compute cost and gradient for regularized linear regression \n", + " with multiple variables. Computes the cost of using theta as\n", + " the parameter for linear regression to fit the data points in X and y. \n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The dataset. Matrix with shape (m x n + 1) where m is the \n", + " total number of examples, and n is the number of features \n", + " before adding the bias term.\n", + " \n", + " y : array_like\n", + " The functions values at each datapoint. A vector of\n", + " shape (m, ).\n", + " \n", + " theta : array_like\n", + " The parameters for linear regression. A vector of shape (n+1,).\n", + " \n", + " lambda_ : float, optional\n", + " The regularization parameter.\n", + " \n", + " Returns\n", + " -------\n", + " J : float\n", + " The computed cost function. \n", + " \n", + " grad : array_like\n", + " The value of the cost function gradient w.r.t theta. \n", + " A vector of shape (n+1, ).\n", + " \n", + " Instructions\n", + " ------------\n", + " Compute the cost and gradient of regularized linear regression for\n", + " a particular choice of theta.\n", + " You should set J to the cost and grad to the gradient.\n", + " \"\"\"\n", + " # Initialize some useful values\n", + " m = y.size # number of training examples\n", + "\n", + " # You need to return the following variables correctly \n", + " J = 0\n", + " grad = np.zeros(theta.shape)\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " prediction = np.dot(X, theta)\n", + " error = prediction - y\n", + " J = 1/(2*m) * np.dot(error.T, error)\n", + " \n", + " #J = (1/2*m)*(np.dot((np.dot(X,theta)-y).T,(np.dot(X,theta)-y)))+ (lambda_/(2*m))*(sum(theta[:,1:]**2))\n", + " s = (lambda_/m)*sum(np.dot(X,theta)-y)\n", + " grad[0]= s\n", + " d = (lambda_/m)*np.dot(X.T,(np.dot(X,theta)-y))+(lambda_/m)*theta\n", + " for i in range(theta.shape[0]-1): \n", + " grad[i+1] = d[i+1]\n", + " # ============================================================\n", + " return J, grad" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When you are finished, the next cell will run your cost function using `theta` initialized at `[1, 1]`. You should expect to see an output of 303.993." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost at theta = [1, 1]:\t 303.951526 \n", + "This value should be about 303.993192)\n", + "\n" + ] + } + ], + "source": [ + "theta = np.array([1, 1])\n", + "J, _ = linearRegCostFunction(np.concatenate([np.ones((m, 1)), X], axis=1), y, theta, 1)\n", + "\n", + "print('Cost at theta = [1, 1]:\\t %f ' % J)\n", + "print('This value should be about 303.993192)\\n' % J)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After completing a part of the exercise, you can submit your solutions for grading by first adding the function you modified to the submission object, and then sending your function to Coursera for grading. \n", + "\n", + "The submission script will prompt you for your login e-mail and submission token. You can obtain a submission token from the web page for the assignment. You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n", + "\n", + "*Execute the following cell to grade your solution to the first part of this exercise.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise regularized-linear-regression-and-bias-variance\n", + "\n" + ] + } + ], + "source": [ + "grader[1] = linearRegCostFunction\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 1.3 Regularized linear regression gradient\n", + "\n", + "Correspondingly, the partial derivative of the cost function for regularized linear regression is defined as:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "& \\frac{\\partial J(\\theta)}{\\partial \\theta_0} = \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left(x^{(i)} \\right) - y^{(i)} \\right) x_j^{(i)} & \\qquad \\text{for } j = 0 \\\\\n", + "& \\frac{\\partial J(\\theta)}{\\partial \\theta_j} = \\left( \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left( x^{(i)} \\right) - y^{(i)} \\right) x_j^{(i)} \\right) + \\frac{\\lambda}{m} \\theta_j & \\qquad \\text{for } j \\ge 1\n", + "\\end{align}\n", + "$$\n", + "\n", + "In the function [`linearRegCostFunction`](#linearRegCostFunction) above, add code to calculate the gradient, returning it in the variable `grad`. Do not forget to re-execute the cell containing this function to update the function's definition.\n", + "\n", + "\n", + "When you are finished, use the next cell to run your gradient function using theta initialized at `[1, 1]`. You should expect to see a gradient of `[-15.30, 598.250]`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gradient at theta = [1, 1]: [-15.303016, 598.250744] \n", + " (this value should be about [-15.303016, 598.250744])\n", + "\n" + ] + } + ], + "source": [ + "theta = np.array([1, 1])\n", + "J, grad = linearRegCostFunction(np.concatenate([np.ones((m, 1)), X], axis=1), y, theta, 1)\n", + "\n", + "print('Gradient at theta = [1, 1]: [{:.6f}, {:.6f}] '.format(*grad))\n", + "print(' (this value should be about [-15.303016, 598.250744])\\n')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise regularized-linear-regression-and-bias-variance\n", + "\n" + ] + } + ], + "source": [ + "grader[2] = linearRegCostFunction\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fitting linear regression\n", + "\n", + "Once your cost function and gradient are working correctly, the next cell will run the code in `trainLinearReg` (found in the module `utils.py`) to compute the optimal values of $\\theta$. This training function uses `scipy`'s optimization module to minimize the cost function.\n", + "\n", + "In this part, we set regularization parameter $\\lambda$ to zero. Because our current implementation of linear regression is trying to fit a 2-dimensional $\\theta$, regularization will not be incredibly helpful for a $\\theta$ of such low dimension. In the later parts of the exercise, you will be using polynomial regression with regularization.\n", + "\n", + "Finally, the code in the next cell should also plot the best fit line, which should look like the figure below. \n", + "\n", + "![](Figures/linear_fit.png)\n", + "\n", + "The best fit line tells us that the model is not a good fit to the data because the data has a non-linear pattern. While visualizing the best fit as shown is one possible way to debug your learning algorithm, it is not always easy to visualize the data and model. In the next section, you will implement a function to generate learning curves that can help you debug your learning algorithm even if it is not easy to visualize the\n", + "data." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# add a columns of ones for the y-intercept\n", + "X_aug = np.concatenate([np.ones((m, 1)), X], axis=1)\n", + "theta = utils.trainLinearReg(linearRegCostFunction, X_aug, y, lambda_=1)\n", + " \n", + "\n", + "# Plot fit over the data\n", + "pyplot.plot(X, y, 'ro', ms=10, mec='k', mew=1.5)\n", + "pyplot.xlabel('Change in water level (x)')\n", + "pyplot.ylabel('Water flowing out of the dam (y)')\n", + "pyplot.plot(X, np.dot(X_aug, theta), '--', lw=2);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 2 Bias-variance\n", + "\n", + "An important concept in machine learning is the bias-variance tradeoff. Models with high bias are not complex enough for the data and tend to underfit, while models with high variance overfit to the training data.\n", + "\n", + "In this part of the exercise, you will plot training and test errors on a learning curve to diagnose bias-variance problems.\n", + "\n", + "### 2.1 Learning Curves\n", + "\n", + "You will now implement code to generate the learning curves that will be useful in debugging learning algorithms. Recall that a learning curve plots training and cross validation error as a function of training set size. Your job is to fill in the function `learningCurve` in the next cell, so that it returns a vector of errors for the training set and cross validation set.\n", + "\n", + "To plot the learning curve, we need a training and cross validation set error for different training set sizes. To obtain different training set sizes, you should use different subsets of the original training set `X`. Specifically, for a training set size of $i$, you should use the first $i$ examples (i.e., `X[:i, :]`\n", + "and `y[:i]`).\n", + "\n", + "You can use the `trainLinearReg` function (by calling `utils.trainLinearReg(...)`) to find the $\\theta$ parameters. Note that the `lambda_` is passed as a parameter to the `learningCurve` function.\n", + "After learning the $\\theta$ parameters, you should compute the error on the training and cross validation sets. Recall that the training error for a dataset is defined as\n", + "\n", + "$$ J_{\\text{train}} = \\frac{1}{2m} \\left[ \\sum_{i=1}^m \\left(h_\\theta \\left( x^{(i)} \\right) - y^{(i)} \\right)^2 \\right] $$\n", + "\n", + "In particular, note that the training error does not include the regularization term. One way to compute the training error is to use your existing cost function and set $\\lambda$ to 0 only when using it to compute the training error and cross validation error. When you are computing the training set error, make sure you compute it on the training subset (i.e., `X[:n,:]` and `y[:n]`) instead of the entire training set. However, for the cross validation error, you should compute it over the entire cross validation set. You should store\n", + "the computed errors in the vectors error train and error val.\n", + "\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (, line 89)", + "output_type": "error", + "traceback": [ + "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m89\u001b[0m\n\u001b[1;33m error_train[i-1] = 1/(2*i) * np.dot(error.T, error)+ lambda_/(2*i)*np.dot(theta[1:].T theta[1:])\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "source": [ + " def learningCurve(X, y, Xval, yval, lambda_=1):\n", + " \"\"\"\n", + " Generates the train and cross validation set errors needed to plot a learning curve\n", + " returns the train and cross validation set errors for a learning curve. \n", + " \n", + " In this function, you will compute the train and test errors for\n", + " dataset sizes from 1 up to m. In practice, when working with larger\n", + " datasets, you might want to do this in larger intervals.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The training dataset. Matrix with shape (m x n + 1) where m is the \n", + " total number of examples, and n is the number of features \n", + " before adding the bias term.\n", + " \n", + " y : array_like\n", + " The functions values at each training datapoint. A vector of\n", + " shape (m, ).\n", + " \n", + " Xval : array_like\n", + " The validation dataset. Matrix with shape (m_val x n + 1) where m is the \n", + " total number of examples, and n is the number of features \n", + " before adding the bias term.\n", + " \n", + " yval : array_like\n", + " The functions values at each validation datapoint. A vector of\n", + " shape (m_val, ).\n", + " \n", + " lambda_ : float, optional\n", + " The regularization parameter.\n", + " \n", + " Returns\n", + " -------\n", + " error_train : array_like\n", + " A vector of shape m. error_train[i] contains the training error for\n", + " i examples.\n", + " error_val : array_like\n", + " A vecotr of shape m. error_val[i] contains the validation error for\n", + " i training examples.\n", + " \n", + " Instructions\n", + " ------------\n", + " Fill in this function to return training errors in error_train and the\n", + " cross validation errors in error_val. i.e., error_train[i] and \n", + " error_val[i] should give you the errors obtained after training on i examples.\n", + " \n", + " Notes\n", + " -----\n", + " - You should evaluate the training error on the first i training\n", + " examples (i.e., X[:i, :] and y[:i]).\n", + " \n", + " For the cross-validation error, you should instead evaluate on\n", + " the _entire_ cross validation set (Xval and yval).\n", + " \n", + " - If you are using your cost function (linearRegCostFunction) to compute\n", + " the training and cross validation error, you should call the function with\n", + " the lambda argument set to 0. Do note that you will still need to use\n", + " lambda when running the training to obtain the theta parameters.\n", + " \n", + " Hint\n", + " ----\n", + " You can loop over the examples with the following:\n", + " \n", + " for i in range(1, m+1):\n", + " # Compute train/cross validation errors using training examples \n", + " # X[:i, :] and y[:i], storing the result in \n", + " # error_train[i-1] and error_val[i-1]\n", + " .... \n", + " \"\"\"\n", + " # Number of training examples\n", + " m = y.size\n", + "\n", + " # You need to return these values correctly\n", + " error_train = np.zeros(m)\n", + " error_val = np.zeros(m)\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " #for i in range(1, X.shape[0] ):\n", + " #theta = utils5.trainLinearReg(linearRegCostFunction,X[:i,:], y[:i,:], lambda_)\n", + " #error_train[i] = linearRegCostFunction(theta, X[:i,:], y[:i,:], 0)\n", + " #error_val[i] = linearRegCostFunction(theta, Xval, yval, 0)\n", + "\n", + " prediction = np.zeros((m))\n", + " for i in range(1,m+1):\n", + " theta = utils.trainLinearReg(linearRegCostFunction,X[:i,:],y[:i],lambda_)\n", + " prediction = np.dot(X[:i,:], theta)\n", + " error = prediction - y[:i]\n", + " error_train[i-1] = 1/(2*i) * np.dot(error.T, error)+ lambda_/(2*i)*np.dot(theta[1:].T theta[1:])\n", + "\n", + " predictionval = np.dot(Xval, theta)\n", + " errorval = predictionval - yval\n", + " error_val[i-1] = 1/(2*i) * np.dot(errorval.T, errorval)+ lambda_/(2*i)*np.dot(theta[1:].T,theta[1:])\n", + "\n", + " # =============================================================\n", + " return error_train, error_val" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When you are finished implementing the function `learningCurve`, executing the next cell prints the learning curves and produce a plot similar to the figure below. \n", + "\n", + "![](Figures/learning_curve.png)\n", + "\n", + "In the learning curve figure, you can observe that both the train error and cross validation error are high when the number of training examples is increased. This reflects a high bias problem in the model - the linear regression model is too simple and is unable to fit our dataset well. In the next section, you will implement polynomial regression to fit a better model for this dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# Training Examples\tTrain Error\tCross Validation Error\n", + " \t1\t\t0.000000\t1052.018382\n", + " \t2\t\t0.000015\t1161.801315\n", + " \t3\t\t3.286615\t314.852393\n", + " \t4\t\t2.842689\t253.818666\n", + " \t5\t\t13.154052\t150.626052\n", + " \t6\t\t19.443965\t118.396720\n", + " \t7\t\t20.098524\t95.910279\n", + " \t8\t\t18.172860\t81.015050\n", + " \t9\t\t22.609407\t72.652768\n", + " \t10\t\t23.261462\t60.771001\n", + " \t11\t\t24.317250\t56.421641\n", + " \t12\t\t22.373907\t51.513694\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "X_aug = np.concatenate([np.ones((m, 1)), X], axis=1)\n", + "Xval_aug = np.concatenate([np.ones((yval.size, 1)), Xval], axis=1)\n", + "error_train, error_val = learningCurve(X_aug, y, Xval_aug, yval, lambda_=1)\n", + "\n", + "pyplot.plot(np.arange(1, m+1), error_train, np.arange(1, m+1), error_val, lw=2)\n", + "pyplot.title('Learning curve for linear regression')\n", + "pyplot.legend(['Train', 'Cross Validation'])\n", + "pyplot.xlabel('Number of training examples')\n", + "pyplot.ylabel('Error')\n", + "pyplot.axis([0, 13, 0, 150])\n", + "\n", + "print('# Training Examples\\tTrain Error\\tCross Validation Error')\n", + "for i in range(m):\n", + " print(' \\t%d\\t\\t%f\\t%f' % (i+1, error_train[i], error_val[i]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[3] = learningCurve\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## 3 Polynomial regression\n", + "\n", + "The problem with our linear model was that it was too simple for the data\n", + "and resulted in underfitting (high bias). In this part of the exercise, you will address this problem by adding more features. For polynomial regression, our hypothesis has the form:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "h_\\theta(x) &= \\theta_0 + \\theta_1 \\times (\\text{waterLevel}) + \\theta_2 \\times (\\text{waterLevel})^2 + \\cdots + \\theta_p \\times (\\text{waterLevel})^p \\\\\n", + "& = \\theta_0 + \\theta_1 x_1 + \\theta_2 x_2 + \\cdots + \\theta_p x_p\n", + "\\end{align}\n", + "$$\n", + "\n", + "Notice that by defining $x_1 = (\\text{waterLevel})$, $x_2 = (\\text{waterLevel})^2$ , $\\cdots$, $x_p =\n", + "(\\text{waterLevel})^p$, we obtain a linear regression model where the features are the various powers of the original value (waterLevel).\n", + "\n", + "Now, you will add more features using the higher powers of the existing feature $x$ in the dataset. Your task in this part is to complete the code in the function `polyFeatures` in the next cell. The function should map the original training set $X$ of size $m \\times 1$ into its higher powers. Specifically, when a training set $X$ of size $m \\times 1$ is passed into the function, the function should return a $m \\times p$ matrix `X_poly`, where column 1 holds the original values of X, column 2 holds the values of $X^2$, column 3 holds the values of $X^3$, and so on. Note that you don’t have to account for the zero-eth power in this function.\n", + "\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "def polyFeatures(X, p):\n", + " \"\"\"\n", + " Maps X (1D vector) into the p-th power.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " A data vector of size m, where m is the number of examples.\n", + " \n", + " p : int\n", + " The polynomial power to map the features. \n", + " \n", + " Returns \n", + " -------\n", + " X_poly : array_like\n", + " A matrix of shape (m x p) where p is the polynomial \n", + " power and m is the number of examples. That is:\n", + " \n", + " X_poly[i, :] = [X[i], X[i]**2, X[i]**3 ... X[i]**p]\n", + " \n", + " Instructions\n", + " ------------\n", + " Given a vector X, return a matrix X_poly where the p-th column of\n", + " X contains the values of X to the p-th power.\n", + " \"\"\"\n", + " # You need to return the following variables correctly.\n", + " X_poly = np.zeros((X.shape[0], p))\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " #print(X.shape,X_poly.shape)\n", + " for i in range(p):\n", + " X_poly[:,i]=X[:,0]**(i+1)\n", + "\n", + " # ============================================================\n", + " return X_poly" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now you have a function that will map features to a higher dimension. The next cell will apply it to the training set, the test set, and the cross validation set." + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Normalized Training Example 1:\n" + ] + }, + { + "data": { + "text/plain": [ + "array([ 1. , -0.36214078, -0.75508669, 0.18222588, -0.70618991,\n", + " 0.30661792, -0.59087767, 0.3445158 , -0.50848117])" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p = 8\n", + "\n", + "# Map X onto Polynomial Features and Normalize\n", + "X_poly = polyFeatures(X, p)\n", + "X_poly, mu, sigma = utils5.featureNormalize(X_poly)\n", + "X_poly = np.concatenate([np.ones((m, 1)), X_poly], axis=1)\n", + "\n", + "# Map X_poly_test and normalize (using mu and sigma)\n", + "X_poly_test = polyFeatures(Xtest, p)\n", + "X_poly_test -= mu\n", + "X_poly_test /= sigma\n", + "X_poly_test = np.concatenate([np.ones((ytest.size, 1)), X_poly_test], axis=1)\n", + "\n", + "# Map X_poly_val and normalize (using mu and sigma)\n", + "X_poly_val = polyFeatures(Xval, p)\n", + "X_poly_val -= mu\n", + "X_poly_val /= sigma\n", + "X_poly_val = np.concatenate([np.ones((yval.size, 1)), X_poly_val], axis=1)\n", + "\n", + "print('Normalized Training Example 1:')\n", + "X_poly[0, :]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[4] = polyFeatures\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.1 Learning Polynomial Regression\n", + "\n", + "After you have completed the function `polyFeatures`, we will proceed to train polynomial regression using your linear regression cost function.\n", + "\n", + "Keep in mind that even though we have polynomial terms in our feature vector, we are still solving a linear regression optimization problem. The polynomial terms have simply turned into features that we can use for linear regression. We are using the same cost function and gradient that you wrote for the earlier part of this exercise.\n", + "\n", + "For this part of the exercise, you will be using a polynomial of degree 8. It turns out that if we run the training directly on the projected data, will not work well as the features would be badly scaled (e.g., an example with $x = 40$ will now have a feature $x_8 = 40^8 = 6.5 \\times 10^{12}$). Therefore, you will\n", + "need to use feature normalization.\n", + "\n", + "Before learning the parameters $\\theta$ for the polynomial regression, we first call `featureNormalize` and normalize the features of the training set, storing the mu, sigma parameters separately. We have already implemented this function for you (in `utils.py` module) and it is the same function from the first exercise.\n", + "\n", + "After learning the parameters $\\theta$, you should see two plots generated for polynomial regression with $\\lambda = 0$, which should be similar to the ones here:\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "You should see that the polynomial fit is able to follow the datapoints very well, thus, obtaining a low training error. The figure on the right shows that the training error essentially stays zero for all numbers of training samples. However, the polynomial fit is very complex and even drops off at the extremes. This is an indicator that the polynomial regression model is overfitting the training data and will not generalize well.\n", + "\n", + "To better understand the problems with the unregularized ($\\lambda = 0$) model, you can see that the learning curve shows the same effect where the training error is low, but the cross validation error is high. There is a gap between the training and cross validation errors, indicating a high variance problem." + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Polynomial Regression (lambda = 100.000000)\n", + "\n", + "# Training Examples\tTrain Error\tCross Validation Error\n", + " \t1\t\t0.000000\t2915.782351\n", + " \t2\t\t0.012265\t1540.393038\n", + " \t3\t\t2.596534\t34.085355\n", + " \t4\t\t1.479207\t37.918828\n", + " \t5\t\t0.364940\t44.469584\n", + " \t6\t\t0.667807\t32.458941\n", + " \t7\t\t0.919482\t18.359190\n", + " \t8\t\t1.039568\t14.809372\n", + " \t9\t\t1.002097\t12.060821\n", + " \t10\t\t1.441185\t12.579890\n", + " \t11\t\t0.840699\t9.794922\n", + " \t12\t\t1.800847\t6.824375\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "lambda_ = 100\n", + "theta = utils.trainLinearReg(linearRegCostFunction, X_poly, y,\n", + " lambda_=lambda_, maxiter=55)\n", + "\n", + "# Plot training data and fit\n", + "pyplot.plot(X, y, 'ro', ms=10, mew=1.5, mec='k')\n", + "\n", + "utils5.plotFit(polyFeatures, np.min(X), np.max(X), mu, sigma, theta, p)\n", + "\n", + "pyplot.xlabel('Change in water level (x)')\n", + "pyplot.ylabel('Water flowing out of the dam (y)')\n", + "pyplot.title('Polynomial Regression Fit (lambda = %f)' % lambda_)\n", + "pyplot.ylim([-20, 50])\n", + "\n", + "pyplot.figure()\n", + "error_train, error_val = learningCurve(X_poly, y, X_poly_val, yval, lambda_)\n", + "pyplot.plot(np.arange(1, 1+m), error_train, np.arange(1, 1+m), error_val)\n", + "\n", + "pyplot.title('Polynomial Regression Learning Curve (lambda = %f)' % lambda_)\n", + "pyplot.xlabel('Number of training examples')\n", + "pyplot.ylabel('Error')\n", + "pyplot.axis([0, 13, 0, 100])\n", + "pyplot.legend(['Train', 'Cross Validation'])\n", + "\n", + "print('Polynomial Regression (lambda = %f)\\n' % lambda_)\n", + "print('# Training Examples\\tTrain Error\\tCross Validation Error')\n", + "for i in range(m):\n", + " print(' \\t%d\\t\\t%f\\t%f' % (i+1, error_train[i], error_val[i]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One way to combat the overfitting (high-variance) problem is to add regularization to the model. In the next section, you will get to try different $\\lambda$ parameters to see how regularization can lead to a better model.\n", + "\n", + "### 3.2 Optional (ungraded) exercise: Adjusting the regularization parameter\n", + "\n", + "In this section, you will get to observe how the regularization parameter affects the bias-variance of regularized polynomial regression. You should now modify the the lambda parameter and try $\\lambda = 1, 100$. For each of these values, the script should generate a polynomial fit to the data and also a learning curve.\n", + "\n", + "For $\\lambda = 1$, the generated plots should look like the the figure below. You should see a polynomial fit that follows the data trend well (left) and a learning curve (right) showing that both the cross validation and training error converge to a relatively low value. This shows the $\\lambda = 1$ regularized polynomial regression model does not have the high-bias or high-variance problems. In effect, it achieves a good trade-off between bias and variance.\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "For $\\lambda = 100$, you should see a polynomial fit (figure below) that does not follow the data well. In this case, there is too much regularization and the model is unable to fit the training data.\n", + "\n", + "![](Figures/polynomial_regression_reg_100.png)\n", + "\n", + "*You do not need to submit any solutions for this optional (ungraded) exercise.*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.3 Selecting $\\lambda$ using a cross validation set\n", + "\n", + "From the previous parts of the exercise, you observed that the value of $\\lambda$ can significantly affect the results of regularized polynomial regression on the training and cross validation set. In particular, a model without regularization ($\\lambda = 0$) fits the training set well, but does not generalize. Conversely, a model with too much regularization ($\\lambda = 100$) does not fit the training set and testing set well. A good choice of $\\lambda$ (e.g., $\\lambda = 1$) can provide a good fit to the data.\n", + "\n", + "In this section, you will implement an automated method to select the $\\lambda$ parameter. Concretely, you will use a cross validation set to evaluate how good each $\\lambda$ value is. After selecting the best $\\lambda$ value using the cross validation set, we can then evaluate the model on the test set to estimate\n", + "how well the model will perform on actual unseen data. \n", + "\n", + "Your task is to complete the code in the function `validationCurve`. Specifically, you should should use the `utils.trainLinearReg` function to train the model using different values of $\\lambda$ and compute the training error and cross validation error. You should try $\\lambda$ in the following range: {0, 0.001, 0.003, 0.01, 0.03, 0.1, 0.3, 1, 3, 10}.\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [], + "source": [ + "def validationCurve(X, y, Xval, yval):\n", + " \"\"\"\n", + " Generate the train and validation errors needed to plot a validation\n", + " curve that we can use to select lambda_.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The training dataset. Matrix with shape (m x n) where m is the \n", + " total number of training examples, and n is the number of features \n", + " including any polynomial features.\n", + " \n", + " y : array_like\n", + " The functions values at each training datapoint. A vector of\n", + " shape (m, ).\n", + " \n", + " Xval : array_like\n", + " The validation dataset. Matrix with shape (m_val x n) where m is the \n", + " total number of validation examples, and n is the number of features \n", + " including any polynomial features.\n", + " \n", + " yval : array_like\n", + " The functions values at each validation datapoint. A vector of\n", + " shape (m_val, ).\n", + " \n", + " Returns\n", + " -------\n", + " lambda_vec : list\n", + " The values of the regularization parameters which were used in \n", + " cross validation.\n", + " \n", + " error_train : list\n", + " The training error computed at each value for the regularization\n", + " parameter.\n", + " \n", + " error_val : list\n", + " The validation error computed at each value for the regularization\n", + " parameter.\n", + " \n", + " Instructions\n", + " ------------\n", + " Fill in this function to return training errors in `error_train` and\n", + " the validation errors in `error_val`. The vector `lambda_vec` contains\n", + " the different lambda parameters to use for each calculation of the\n", + " errors, i.e, `error_train[i]`, and `error_val[i]` should give you the\n", + " errors obtained after training with `lambda_ = lambda_vec[i]`.\n", + "\n", + " Note\n", + " ----\n", + " You can loop over lambda_vec with the following:\n", + " \n", + " for i in range(len(lambda_vec))\n", + " lambda = lambda_vec[i]\n", + " # Compute train / val errors when training linear \n", + " # regression with regularization parameter lambda_\n", + " # You should store the result in error_train[i]\n", + " # and error_val[i]\n", + " ....\n", + " \"\"\"\n", + " # Selected values of lambda (you should not change this)\n", + " lambda_vec = [0, 0.001, 0.003, 0.01, 0.03, 0.1, 0.3, 1, 3, 10]\n", + "\n", + " # You need to return these variables correctly.\n", + " error_train = np.zeros(len(lambda_vec))\n", + " error_val = np.zeros(len(lambda_vec))\n", + " m = y.size\n", + " m_val=yval.size\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " for i in range(len(lambda_vec)):\n", + " theta = utils5.trainLinearReg(linearRegCostFunction,X,y,lambda_vec[i])\n", + " prediction = np.dot(X, theta)\n", + " error = prediction - y\n", + " error_train[i] = 1/(2*m) * np.dot(error.T, error)+ lambda_vec[i]/(2*m)*np.dot(theta[1:].T,theta[1:])\n", + "\n", + " predictionval = np.dot(Xval, theta)\n", + " errorval = predictionval - yval\n", + " error_val[i] = 1/(2*m_val) * np.dot(errorval.T, errorval)+ lambda_vec[i]/(2*m_val)*np.dot(theta[1:].T,theta[1:])\n", + " print(prediction)\n", + "\n", + "\n", + " # ============================================================\n", + " return lambda_vec, error_train, error_val" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After you have completed the code, the next cell will run your function and plot a cross validation curve of error v.s. $\\lambda$ that allows you select which $\\lambda$ parameter to use. You should see a plot similar to the figure below. \n", + "\n", + "![](Figures/cross_validation.png)\n", + "\n", + "In this figure, we can see that the best value of $\\lambda$ is around 3. Due to randomness\n", + "in the training and validation splits of the dataset, the cross validation error can sometimes be lower than the training error." + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 2.886347 2.4036378 32.68970808 34.46382572 3.40380957 4.02471621\n", + " 13.48309845 2.7613083 6.90450359 3.50261546 9.14253597 18.70703532]\n", + "lambda\t\tTrain Error\tValidation Error\n", + " 0.000000\t140.954121\t164.115794\n", + " 0.001000\t2.077194\t4.269617\n", + " 0.003000\t2.095565\t4.319492\n", + " 0.010000\t2.147566\t4.338203\n", + " 0.030000\t2.228198\t4.354756\n", + " 0.100000\t2.587184\t4.619987\n", + " 0.300000\t3.633722\t5.150864\n", + " 1.000000\t7.268178\t7.225757\n", + " 3.000000\t17.659752\t13.172895\n", + " 10.000000\t61.125809\t37.688284\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "lambda_vec, error_train, error_val = validationCurve(X_poly, y, X_poly_val, yval)\n", + "\n", + "pyplot.plot(lambda_vec, error_train, '-o', lambda_vec, error_val, '-o', lw=2)\n", + "pyplot.legend(['Train', 'Cross Validation'])\n", + "pyplot.xlabel('lambda')\n", + "pyplot.ylabel('Error')\n", + "\n", + "print('lambda\\t\\tTrain Error\\tValidation Error')\n", + "for i in range(len(lambda_vec)):\n", + " print(' %f\\t%f\\t%f' % (lambda_vec[i], error_train[i], error_val[i]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[5] = validationCurve\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.4 Optional (ungraded) exercise: Computing test set error\n", + "\n", + "In the previous part of the exercise, you implemented code to compute the cross validation error for various values of the regularization parameter $\\lambda$. However, to get a better indication of the model’s performance in the real world, it is important to evaluate the “final” model on a test set that was not used in any part of training (that is, it was neither used to select the $\\lambda$ parameters, nor to learn the model parameters $\\theta$). For this optional (ungraded) exercise, you should compute the test error using the best value of $\\lambda$ you found. In our cross validation, we obtained a test error of 3.8599 for $\\lambda = 3$.\n", + "\n", + "*You do not need to submit any solutions for this optional (ungraded) exercise.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.5 Optional (ungraded) exercise: Plotting learning curves with randomly selected examples\n", + "\n", + "In practice, especially for small training sets, when you plot learning curves to debug your algorithms, it is often helpful to average across multiple sets of randomly selected examples to determine the training error and cross validation error.\n", + "\n", + "Concretely, to determine the training error and cross validation error for $i$ examples, you should first randomly select $i$ examples from the training set and $i$ examples from the cross validation set. You will then learn the parameters $\\theta$ using the randomly chosen training set and evaluate the parameters $\\theta$ on the randomly chosen training set and cross validation set. The above steps should then be repeated multiple times (say 50) and the averaged error should be used to determine the training error and cross validation error for $i$ examples.\n", + "\n", + "For this optional (ungraded) exercise, you should implement the above strategy for computing the learning curves. For reference, the figure below shows the learning curve we obtained for polynomial regression with $\\lambda = 0.01$. Your figure may differ slightly due to the random selection of examples.\n", + "\n", + "![](Figures/learning_curve_random.png)\n", + "\n", + "*You do not need to submit any solutions for this optional (ungraded) exercise.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "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.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/exercise6.ipynb b/exercise6.ipynb new file mode 100644 index 000000000..0cdcf2454 --- /dev/null +++ b/exercise6.ipynb @@ -0,0 +1,1231 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Programming Exercise 6:\n", + "# Support Vector Machines\n", + "\n", + "## Introduction\n", + "\n", + "In this exercise, you will be using support vector machines (SVMs) to build a spam classifier. Before starting on the programming exercise, we strongly recommend watching the video lectures and completing the review questions for the associated topics.\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": 12, + "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", + "# Import regular expressions to process emails\n", + "import re\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 | Submitted Function | Points |\n", + "| :- |:- |:- | :-: |\n", + "| 1 | [Gaussian Kernel](#section1) | [`gaussianKernel`](#gaussianKernel) | 25 |\n", + "| 2 | [Parameters (C, $\\sigma$) for Dataset 3](#section2)| [`dataset3Params`](#dataset3Params) | 25 |\n", + "| 3 | [Email Preprocessing](#section3) | [`processEmail`](#processEmail) | 25 |\n", + "| 4 | [Email Feature Extraction](#section4) | [`emailFeatures`](#emailFeatures) | 25 |\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", + "
\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", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1 Support Vector Machines\n", + "\n", + "In the first half of this exercise, you will be using support vector machines (SVMs) with various example 2D datasets. Experimenting with these datasets will help you gain an intuition of how SVMs work and how to use a Gaussian kernel with SVMs. In the next half of the exercise, you will be using support\n", + "vector machines to build a spam classifier." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1 Example Dataset 1\n", + "\n", + "We will begin by with a 2D example dataset which can be separated by a linear boundary. The following cell plots the training data, which should look like this:\n", + "\n", + "![Dataset 1 training data](Figures/dataset1.png)\n", + "\n", + "In this dataset, the positions of the positive examples (indicated with `x`) and the negative examples (indicated with `o`) suggest a natural separation indicated by the gap. However, notice that there is an outlier positive example `x` on the far left at about (0.1, 4.1). As part of this exercise, you will also see how this outlier affects the SVM decision boundary." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Load from ex6data1\n", + "# You will have X, y as keys in the dict data\n", + "data = loadmat(os.path.join('Data', 'ex6data1.mat'))\n", + "X, y = data['X'], data['y'][:, 0]\n", + "\n", + "# Plot training data\n", + "utils.plotData(X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this part of the exercise, you will try using different values of the $C$ parameter with SVMs. Informally, the $C$ parameter is a positive value that controls the penalty for misclassified training examples. A large $C$ parameter tells the SVM to try to classify all the examples correctly. $C$ plays a role similar to $1/\\lambda$, where $\\lambda$ is the regularization parameter that we were using previously for logistic regression.\n", + "\n", + "\n", + "The following cell will run the SVM training (with $C=1$) using SVM software that we have included with the starter code (function `svmTrain` within the `utils` module of this exercise). When $C=1$, you should find that the SVM puts the decision boundary in the gap between the two datasets and *misclassifies* the data point on the far left, as shown in the figure (left) below.\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SVM Decision boundary for example dataset 1
C=1C=100
\n", + "\n", + "
\n", + "In order to minimize the dependency of this assignment on external libraries, we have included this implementation of an SVM learning algorithm in utils.svmTrain. However, this particular implementation is not very efficient (it was originally chosen to maximize compatibility between Octave/MATLAB for the first version of this assignment set). If you are training an SVM on a real problem, especially if you need to scale to a larger dataset, we strongly recommend instead using a highly optimized SVM toolbox such as [LIBSVM](https://www.csie.ntu.edu.tw/~cjlin/libsvm/). The python machine learning library [scikit-learn](http://scikit-learn.org/stable/index.html) provides wrappers for the LIBSVM library.\n", + "
\n", + "
\n", + "
\n", + "**Implementation Note:** Most SVM software packages (including the function `utils.svmTrain`) automatically add the extra feature $x_0$ = 1 for you and automatically take care of learning the intercept term $\\theta_0$. So when passing your training data to the SVM software, there is no need to add this extra feature $x_0 = 1$ yourself. In particular, in python your code should be working with training examples $x \\in \\mathcal{R}^n$ (rather than $x \\in \\mathcal{R}^{n+1}$); for example, in the first example dataset $x \\in \\mathcal{R}^2$.\n", + "
\n", + "\n", + "Your task is to try different values of $C$ on this dataset. Specifically, you should change the value of $C$ in the next cell to $C = 100$ and run the SVM training again. When $C = 100$, you should find that the SVM now classifies every single example correctly, but has a decision boundary that does not\n", + "appear to be a natural fit for the data." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# You should try to change the C value below and see how the decision\n", + "# boundary varies (e.g., try C = 1000)\n", + "C = 100\n", + "\n", + "model = utils.svmTrain(X, y, C, utils6.linearKernel, 1e-3, 20)\n", + "utils.visualizeBoundaryLinear(X, y, model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 1.2 SVM with Gaussian Kernels\n", + "\n", + "In this part of the exercise, you will be using SVMs to do non-linear classification. In particular, you will be using SVMs with Gaussian kernels on datasets that are not linearly separable.\n", + "\n", + "#### 1.2.1 Gaussian Kernel\n", + "\n", + "To find non-linear decision boundaries with the SVM, we need to first implement a Gaussian kernel. You can think of the Gaussian kernel as a similarity function that measures the “distance” between a pair of examples,\n", + "($x^{(i)}$, $x^{(j)}$). The Gaussian kernel is also parameterized by a bandwidth parameter, $\\sigma$, which determines how fast the similarity metric decreases (to 0) as the examples are further apart.\n", + "You should now complete the code in `gaussianKernel` to compute the Gaussian kernel between two examples, ($x^{(i)}$, $x^{(j)}$). The Gaussian kernel function is defined as:\n", + "\n", + "$$ K_{\\text{gaussian}} \\left( x^{(i)}, x^{(j)} \\right) = \\exp \\left( - \\frac{\\left\\lvert\\left\\lvert x^{(i)} - x^{(j)}\\right\\lvert\\right\\lvert^2}{2\\sigma^2} \\right) = \\exp \\left( -\\frac{\\sum_{k=1}^n \\left( x_k^{(i)} - x_k^{(j)}\\right)^2}{2\\sigma^2} \\right)$$\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def gaussianKernel(x1, x2, sigma):\n", + " \"\"\"\n", + " Computes the radial basis function\n", + " Returns a radial basis function kernel between x1 and x2.\n", + " \n", + " Parameters\n", + " ----------\n", + " x1 : numpy ndarray\n", + " A vector of size (n, ), representing the first datapoint.\n", + " \n", + " x2 : numpy ndarray\n", + " A vector of size (n, ), representing the second datapoint.\n", + " \n", + " sigma : float\n", + " The bandwidth parameter for the Gaussian kernel.\n", + "\n", + " Returns\n", + " -------\n", + " sim : float\n", + " The computed RBF between the two provided data points.\n", + " \n", + " Instructions\n", + " ------------\n", + " Fill in this function to return the similarity between `x1` and `x2`\n", + " computed using a Gaussian kernel with bandwidth `sigma`.\n", + " \"\"\"\n", + " sim = 0\n", + " # ====================== YOUR CODE HERE ======================\n", + " diff = x1-x2\n", + " sim = np.e**(-1*np.dot(diff.T,diff)/(2*(sigma**2)))\n", + "\n", + "\n", + " # =============================================================\n", + " return sim" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you have completed the function `gaussianKernel` the following cell will test your kernel function on two provided examples and you should expect to see a value of 0.324652." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gaussian Kernel between x1 = [1, 2, 1], x2 = [0, 4, -1], sigma = 2.00:\n", + "\t0.324652\n", + "(for sigma = 2, this value should be about 0.324652)\n", + "\n" + ] + } + ], + "source": [ + "x1 = np.array([1, 2, 1])\n", + "x2 = np.array([0, 4, -1])\n", + "sigma = 2\n", + "\n", + "sim = gaussianKernel(x1, x2, sigma)\n", + "\n", + "print('Gaussian Kernel between x1 = [1, 2, 1], x2 = [0, 4, -1], sigma = %0.2f:'\n", + " '\\n\\t%f\\n(for sigma = 2, this value should be about 0.324652)\\n' % (sigma, sim))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[1] = gaussianKernel\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2.2 Example Dataset 2\n", + "\n", + "The next part in this notebook will load and plot dataset 2, as shown in the figure below. \n", + "\n", + "![Dataset 2](Figures/dataset2.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Load from ex6data2\n", + "# You will have X, y as keys in the dict data\n", + "data = loadmat(os.path.join('Data', 'ex6data2.mat'))\n", + "X, y = data['X'], data['y'][:, 0]\n", + "\n", + "# Plot training data\n", + "utils.plotData(X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the figure, you can obserse that there is no linear decision boundary that separates the positive and negative examples for this dataset. However, by using the Gaussian kernel with the SVM, you will be able to learn a non-linear decision boundary that can perform reasonably well for the dataset. If you have correctly implemented the Gaussian kernel function, the following cell will proceed to train the SVM with the Gaussian kernel on this dataset.\n", + "\n", + "You should get a decision boundary as shown in the figure below, as computed by the SVM with a Gaussian kernel. The decision boundary is able to separate most of the positive and negative examples correctly and follows the contours of the dataset well.\n", + "\n", + "![Dataset 2 decision boundary](Figures/svm_dataset2.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# SVM Parameters\n", + "C = 1\n", + "sigma = 0.1\n", + "\n", + "model= utils.svmTrain(X, y, C, gaussianKernel, args=(sigma,))\n", + "utils.visualizeBoundary(X, y, model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "#### 1.2.3 Example Dataset 3\n", + "\n", + "In this part of the exercise, you will gain more practical skills on how to use a SVM with a Gaussian kernel. The next cell will load and display a third dataset, which should look like the figure below.\n", + "\n", + "![Dataset 3](Figures/dataset3.png)\n", + "\n", + "You will be using the SVM with the Gaussian kernel with this dataset. In the provided dataset, `ex6data3.mat`, you are given the variables `X`, `y`, `Xval`, `yval`. " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Load from ex6data3\n", + "# You will have X, y, Xval, yval as keys in the dict data\n", + "data = loadmat(os.path.join('Data', 'ex6data3.mat'))\n", + "X, y, Xval, yval = data['X'], data['y'][:, 0], data['Xval'], data['yval'][:, 0]\n", + "\n", + "# Plot training data\n", + "utils.plotData(X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Your task is to use the cross validation set `Xval`, `yval` to determine the best $C$ and $\\sigma$ parameter to use. You should write any additional code necessary to help you search over the parameters $C$ and $\\sigma$. For both $C$ and $\\sigma$, we suggest trying values in multiplicative steps (e.g., 0.01, 0.03, 0.1, 0.3, 1, 3, 10, 30).\n", + "Note that you should try all possible pairs of values for $C$ and $\\sigma$ (e.g., $C = 0.3$ and $\\sigma = 0.1$). For example, if you try each of the 8 values listed above for $C$ and for $\\sigma^2$, you would end up training and evaluating (on the cross validation set) a total of $8^2 = 64$ different models. After you have determined the best $C$ and $\\sigma$ parameters to use, you should modify the code in `dataset3Params`, filling in the best parameters you found. For our best parameters, the SVM returned a decision boundary shown in the figure below. \n", + "\n", + "![](Figures/svm_dataset3_best.png)\n", + "\n", + "
\n", + "**Implementation Tip:** When implementing cross validation to select the best $C$ and $\\sigma$ parameter to use, you need to evaluate the error on the cross validation set. Recall that for classification, the error is defined as the fraction of the cross validation examples that were classified incorrectly. In `numpy`, you can compute this error using `np.mean(predictions != yval)`, where `predictions` is a vector containing all the predictions from the SVM, and `yval` are the true labels from the cross validation set. You can use the `utils.svmPredict` function to generate the predictions for the cross validation set.\n", + "
\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "def dataset3Params(X, y, Xval, yval):\n", + " \"\"\"\n", + " Returns your choice of C and sigma for Part 3 of the exercise \n", + " where you select the optimal (C, sigma) learning parameters to use for SVM\n", + " with RBF kernel.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " (m x n) matrix of training data where m is number of training examples, and \n", + " n is the number of features.\n", + " \n", + " y : array_like\n", + " (m, ) vector of labels for ther training data.\n", + " \n", + " Xval : array_like\n", + " (mv x n) matrix of validation data where mv is the number of validation examples\n", + " and n is the number of features\n", + " \n", + " yval : array_like\n", + " (mv, ) vector of labels for the validation data.\n", + " \n", + " Returns\n", + " -------\n", + " C, sigma : float, float\n", + " The best performing values for the regularization parameter C and \n", + " RBF parameter sigma.\n", + " \n", + " Instructions\n", + " ------------\n", + " Fill in this function to return the optimal C and sigma learning \n", + " parameters found using the cross validation set.\n", + " You can use `svmPredict` to predict the labels on the cross\n", + " validation set. For example, \n", + " \n", + " predictions = svmPredict(model, Xval)\n", + "\n", + " will return the predictions on the cross validation set.\n", + " \n", + " Note\n", + " ----\n", + " You can compute the prediction error using \n", + " \n", + " np.mean(predictions != yval)\n", + " \"\"\"\n", + " # You need to return the following variables correctly.\n", + " C = 1\n", + " sigma = 0.3\n", + " predictionerrors = np.zeros((64,3))\n", + " i =0\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " for C in [0.01, 0.03, 0.1, 0.3, 1, 3, 10, 30]:\n", + " for sigma in [0.01, 0.03, 0.1, 0.3, 1, 3, 10, 30]:\n", + " #print('sigma = {} and C = {}'.format(sigma,C))\n", + " model = utils6.svmTrain(X,y,C,gaussianKernel,args=(sigma,))\n", + " predictions = utils6.svmPredict(model, Xval)\n", + " predictionerrors[i,0] = np.mean(predictions != yval)\n", + " predictionerrors[i,1]= C\n", + " predictionerrors[i,2]= sigma\n", + " i=i+1\n", + "\n", + " #row = predictionerrors.argmin(axis=0)\n", + " s=np.min(predictionerrors[:,0])\n", + " w = np.argwhere(predictionerrors[:,0]==np.min(predictionerrors[:,0]))\n", + " sigma = predictionerrors[w[0],2]\n", + " C = predictionerrors[w[0],1]\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " # ============================================================\n", + " return C, sigma" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The provided code in the next cell trains the SVM classifier using the training set $(X, y)$ using parameters loaded from `dataset3Params`. Note that this might take a few minutes to execute." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[34]\n", + " [42]] 0.035\n", + "[1.] [0.1]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Try different SVM Parameters here\n", + "C, sigma = dataset3Params(X, y, Xval, yval)\n", + "\n", + "# Train the SVM\n", + "# model = utils.svmTrain(X, y, C, lambda x1, x2: gaussianKernel(x1, x2, sigma))\n", + "model = utils.svmTrain(X, y, C, gaussianKernel, args=(sigma,))\n", + "utils.visualizeBoundary(X, y, model)\n", + "print(C, sigma)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One you have computed the values `C` and `sigma` in the cell above, we will submit those values for grading.\n", + "\n", + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise support-vector-machines\n", + "\n" + ] + } + ], + "source": [ + "grader[2] = lambda : (C, sigma)\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 2 Spam Classification\n", + "\n", + "Many email services today provide spam filters that are able to classify emails into spam and non-spam email with high accuracy. In this part of the exercise, you will use SVMs to build your own spam filter.\n", + "\n", + "You will be training a classifier to classify whether a given email, $x$, is spam ($y = 1$) or non-spam ($y = 0$). In particular, you need to convert each email into a feature vector $x \\in \\mathbb{R}^n$ . The following parts of the exercise will walk you through how such a feature vector can be constructed from an email.\n", + "\n", + "The dataset included for this exercise is based on a a subset of the [SpamAssassin Public Corpus](http://spamassassin.apache.org/old/publiccorpus/). For the purpose of this exercise, you will only be using the body of the email (excluding the email headers)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.1 Preprocessing Emails\n", + "\n", + "Before starting on a machine learning task, it is usually insightful to take a look at examples from the dataset. The figure below shows a sample email that contains a URL, an email address (at the end), numbers, and dollar\n", + "amounts.\n", + "\n", + "\n", + "\n", + "While many emails would contain similar types of entities (e.g., numbers, other URLs, or other email addresses), the specific entities (e.g., the specific URL or specific dollar amount) will be different in almost every\n", + "email. Therefore, one method often employed in processing emails is to “normalize” these values, so that all URLs are treated the same, all numbers are treated the same, etc. For example, we could replace each URL in the\n", + "email with the unique string “httpaddr” to indicate that a URL was present.\n", + "\n", + "This has the effect of letting the spam classifier make a classification decision based on whether any URL was present, rather than whether a specific URL was present. This typically improves the performance of a spam classifier, since spammers often randomize the URLs, and thus the odds of seeing any particular URL again in a new piece of spam is very small. \n", + "\n", + "In the function `processEmail` below, we have implemented the following email preprocessing and normalization steps:\n", + "\n", + "- **Lower-casing**: The entire email is converted into lower case, so that captialization is ignored (e.g., IndIcaTE is treated the same as Indicate).\n", + "\n", + "- **Stripping HTML**: All HTML tags are removed from the emails. Many emails often come with HTML formatting; we remove all the HTML tags, so that only the content remains.\n", + "\n", + "- **Normalizing URLs**: All URLs are replaced with the text “httpaddr”.\n", + "\n", + "- **Normalizing Email Addresses**: All email addresses are replaced with the text “emailaddr”.\n", + "\n", + "- **Normalizing Numbers**: All numbers are replaced with the text “number”.\n", + "\n", + "- **Normalizing Dollars**: All dollar signs ($) are replaced with the text “dollar”.\n", + "\n", + "- **Word Stemming**: Words are reduced to their stemmed form. For example, “discount”, “discounts”, “discounted” and “discounting” are all replaced with “discount”. Sometimes, the Stemmer actually strips off additional characters from the end, so “include”, “includes”, “included”, and “including” are all replaced with “includ”.\n", + "\n", + "- **Removal of non-words**: Non-words and punctuation have been removed. All white spaces (tabs, newlines, spaces) have all been trimmed to a single space character.\n", + "\n", + "The result of these preprocessing steps is shown in the figure below. \n", + "\n", + "\"email\n", + "\n", + "While preprocessing has left word fragments and non-words, this form turns out to be much easier to work with for performing feature extraction." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.1.1 Vocabulary List\n", + "\n", + "After preprocessing the emails, we have a list of words for each email. The next step is to choose which words we would like to use in our classifier and which we would want to leave out.\n", + "\n", + "For this exercise, we have chosen only the most frequently occuring words as our set of words considered (the vocabulary list). Since words that occur rarely in the training set are only in a few emails, they might cause the\n", + "model to overfit our training set. The complete vocabulary list is in the file `vocab.txt` (inside the `Data` directory for this exercise) and also shown in the figure below.\n", + "\n", + "\"Vocab\"\n", + "\n", + "Our vocabulary list was selected by choosing all words which occur at least a 100 times in the spam corpus,\n", + "resulting in a list of 1899 words. In practice, a vocabulary list with about 10,000 to 50,000 words is often used.\n", + "Given the vocabulary list, we can now map each word in the preprocessed emails into a list of word indices that contains the index of the word in the vocabulary dictionary. The figure below shows the mapping for the sample email. Specifically, in the sample email, the word “anyone” was first normalized to “anyon” and then mapped onto the index 86 in the vocabulary list.\n", + "\n", + "\"word\n", + "\n", + "Your task now is to complete the code in the function `processEmail` to perform this mapping. In the code, you are given a string `word` which is a single word from the processed email. You should look up the word in the vocabulary list `vocabList`. If the word exists in the list, you should add the index of the word into the `word_indices` variable. If the word does not exist, and is therefore not in the vocabulary, you can skip the word.\n", + "\n", + "
\n", + "**python tip**: In python, you can find the index of the first occurence of an item in `list` using the `index` attribute. In the provided code for `processEmail`, `vocabList` is a python list containing the words in the vocabulary. To find the index of a word, we can use `vocabList.index(word)` which would return a number indicating the index of the word within the list. If the word does not exist in the list, a `ValueError` exception is raised. In python, we can use the `try/except` statement to catch exceptions which we do not want to stop the program from running. You can think of the `try/except` statement to be the same as an `if/else` statement, but it asks for forgiveness rather than permission.\n", + "\n", + "An example would be:\n", + "
\n", + "\n", + "```\n", + "try:\n", + " do stuff here\n", + "except ValueError:\n", + " pass\n", + " # do nothing (forgive me) if a ValueError exception occured within the try statement\n", + "```\n", + "
\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def processEmail(email_contents, verbose=True):\n", + " \"\"\"\n", + " Preprocesses the body of an email and returns a list of indices \n", + " of the words contained in the email. \n", + " \n", + " Parameters\n", + " ----------\n", + " email_contents : str\n", + " A string containing one email. \n", + " \n", + " verbose : bool\n", + " If True, print the resulting email after processing.\n", + " \n", + " Returns\n", + " -------\n", + " word_indices : list\n", + " A list of integers containing the index of each word in the \n", + " email which is also present in the vocabulary.\n", + " \n", + " Instructions\n", + " ------------\n", + " Fill in this function to add the index of word to word_indices \n", + " if it is in the vocabulary. At this point of the code, you have \n", + " a stemmed word from the email in the variable word.\n", + " You should look up word in the vocabulary list (vocabList). \n", + " If a match exists, you should add the index of the word to the word_indices\n", + " list. Concretely, if word = 'action', then you should\n", + " look up the vocabulary list to find where in vocabList\n", + " 'action' appears. For example, if vocabList[18] =\n", + " 'action', then, you should add 18 to the word_indices \n", + " vector (e.g., word_indices.append(18)).\n", + " \n", + " Notes\n", + " -----\n", + " - vocabList[idx] returns a the word with index idx in the vocabulary list.\n", + " \n", + " - vocabList.index(word) return index of word `word` in the vocabulary list.\n", + " (A ValueError exception is raised if the word does not exist.)\n", + " \"\"\"\n", + " # Load Vocabulary\n", + " vocabList = utils.getVocabList()\n", + "\n", + " # Init return value\n", + " word_indices = []\n", + "\n", + " # ========================== Preprocess Email ===========================\n", + " # Find the Headers ( \\n\\n and remove )\n", + " # Uncomment the following lines if you are working with raw emails with the\n", + " # full headers\n", + " # hdrstart = email_contents.find(chr(10) + chr(10))\n", + " # email_contents = email_contents[hdrstart:]\n", + "\n", + " # Lower case\n", + " email_contents = email_contents.lower()\n", + " \n", + " # Strip all HTML\n", + " # Looks for any expression that starts with < and ends with > and replace\n", + " # and does not have any < or > in the tag it with a space\n", + " email_contents =re.compile('<[^<>]+>').sub(' ', email_contents)\n", + "\n", + " # Handle Numbers\n", + " # Look for one or more characters between 0-9\n", + " email_contents = re.compile('[0-9]+').sub(' number ', email_contents)\n", + "\n", + " # Handle URLS\n", + " # Look for strings starting with http:// or https://\n", + " email_contents = re.compile('(http|https)://[^\\s]*').sub(' httpaddr ', email_contents)\n", + "\n", + " # Handle Email Addresses\n", + " # Look for strings with @ in the middle\n", + " email_contents = re.compile('[^\\s]+@[^\\s]+').sub(' emailaddr ', email_contents)\n", + " \n", + " # Handle $ sign\n", + " email_contents = re.compile('[$]+').sub(' dollar ', email_contents)\n", + " \n", + " # get rid of any punctuation\n", + " email_contents = re.split('[ @$/#.-:&*+=\\[\\]?!(){},''\">_<;%\\n\\r]', email_contents)\n", + "\n", + " # remove any empty word string\n", + " email_contents = [word for word in email_contents if len(word) > 0]\n", + " \n", + " # Stem the email contents word by word\n", + " stemmer = utils.PorterStemmer()\n", + " processed_email = []\n", + " for word in email_contents:\n", + " # Remove any remaining non alphanumeric characters in word\n", + " word = re.compile('[^a-zA-Z0-9]').sub('', word).strip()\n", + " word = stemmer.stem(word)\n", + " processed_email.append(word)\n", + "\n", + " if len(word) < 1:\n", + " continue\n", + "\n", + " # Look up the word in the dictionary and add to word_indices if found\n", + " # ====================== YOUR CODE HERE ======================\n", + " try:\n", + " t =vocabList.index(word)\n", + " word_indices.append(t)\n", + " \n", + " except ValueError:\n", + " pass\n", + "\n", + " \n", + "\n", + " # =============================================================\n", + "\n", + " if verbose:\n", + " print('----------------')\n", + " print('Processed email:')\n", + " print('----------------')\n", + " print(' '.join(processed_email))\n", + " return word_indices" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you have implemented `processEmail`, the following cell will run your code on the email sample and you should see an output of the processed email and the indices list mapping." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------\n", + "Processed email:\n", + "----------------\n", + "anyon know how much it cost to host a web portal well it depend on how mani visitor your expect thi can be anywher from less than number buck a month to a coupl of dollar number you should checkout httpaddr or perhap amazon ec number if your run someth big to unsubscrib yourself from thi mail list send an email to emailaddr\n", + "-------------\n", + "Word Indices:\n", + "-------------\n", + "[85, 915, 793, 1076, 882, 369, 1698, 789, 1821, 1830, 882, 430, 1170, 793, 1001, 1894, 591, 1675, 237, 161, 88, 687, 944, 1662, 1119, 1061, 1698, 374, 1161, 476, 1119, 1892, 1509, 798, 1181, 1236, 511, 1119, 809, 1894, 1439, 1546, 180, 1698, 1757, 1895, 687, 1675, 991, 960, 1476, 70, 529, 1698, 530]\n" + ] + } + ], + "source": [ + "# To use an SVM to classify emails into Spam v.s. Non-Spam, you first need\n", + "# to convert each email into a vector of features. In this part, you will\n", + "# implement the preprocessing steps for each email. You should\n", + "# complete the code in processEmail.m to produce a word indices vector\n", + "# for a given email.\n", + "\n", + "# Extract Features\n", + "with open(os.path.join('Data', 'emailSample1.txt')) as fid:\n", + " file_contents = fid.read()\n", + "\n", + "word_indices = processEmail(file_contents)\n", + "\n", + "#Print Stats\n", + "print('-------------')\n", + "print('Word Indices:')\n", + "print('-------------')\n", + "print(word_indices)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[3] = processEmail\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 2.2 Extracting Features from Emails\n", + "\n", + "You will now implement the feature extraction that converts each email into a vector in $\\mathbb{R}^n$. For this exercise, you will be using n = # words in vocabulary list. Specifically, the feature $x_i \\in \\{0, 1\\}$ for an email corresponds to whether the $i^{th}$ word in the dictionary occurs in the email. That is, $x_i = 1$ if the $i^{th}$ word is in the email and $x_i = 0$ if the $i^{th}$ word is not present in the email.\n", + "\n", + "Thus, for a typical email, this feature would look like:\n", + "\n", + "$$ x = \\begin{bmatrix} \n", + "0 & \\dots & 1 & 0 & \\dots & 1 & 0 & \\dots & 0 \n", + "\\end{bmatrix}^T \\in \\mathbb{R}^n\n", + "$$\n", + "\n", + "You should now complete the code in the function `emailFeatures` to generate a feature vector for an email, given the `word_indices`.\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def emailFeatures(word_indices):\n", + " \"\"\"\n", + " Takes in a word_indices vector and produces a feature vector from the word indices. \n", + " \n", + " Parameters\n", + " ----------\n", + " word_indices : list\n", + " A list of word indices from the vocabulary list.\n", + " \n", + " Returns\n", + " -------\n", + " x : list \n", + " The computed feature vector.\n", + " \n", + " Instructions\n", + " ------------\n", + " Fill in this function to return a feature vector for the\n", + " given email (word_indices). To help make it easier to process \n", + " the emails, we have have already pre-processed each email and converted\n", + " each word in the email into an index in a fixed dictionary (of 1899 words).\n", + " The variable `word_indices` contains the list of indices of the words \n", + " which occur in one email.\n", + " \n", + " Concretely, if an email has the text:\n", + "\n", + " The quick brown fox jumped over the lazy dog.\n", + "\n", + " Then, the word_indices vector for this text might look like:\n", + " \n", + " 60 100 33 44 10 53 60 58 5\n", + "\n", + " where, we have mapped each word onto a number, for example:\n", + "\n", + " the -- 60\n", + " quick -- 100\n", + " ...\n", + "\n", + " Note\n", + " ----\n", + " The above numbers are just an example and are not the actual mappings.\n", + "\n", + " Your task is take one such `word_indices` vector and construct\n", + " a binary feature vector that indicates whether a particular\n", + " word occurs in the email. That is, x[i] = 1 when word i\n", + " is present in the email. Concretely, if the word 'the' (say,\n", + " index 60) appears in the email, then x[60] = 1. The feature\n", + " vector should look like:\n", + " x = [ 0 0 0 0 1 0 0 0 ... 0 0 0 0 1 ... 0 0 0 1 0 ..]\n", + " \"\"\"\n", + " # Total number of words in the dictionary\n", + " n = 1899\n", + "\n", + " # You need to return the following variables correctly.\n", + " x = np.zeros(n)\n", + "\n", + " # ===================== YOUR CODE HERE ======================\n", + " vocabList = utils.getVocabList()\n", + "\n", + " for i in range(n):\n", + " for j in range(len(word_indices)):\n", + " if vocabList.index(vocabList[i])==word_indices[j]:\n", + " x[i]=1\n", + " continue\n", + " x[i]=0\n", + " print(x,len(word_indices))\n", + " \n", + " \n", + " # ===========================================================\n", + " \n", + " return x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you have implemented `emailFeatures`, the next cell will run your code on the email sample. You should see that the feature vector had length 1899 and 45 non-zero entries." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------\n", + "Processed email:\n", + "----------------\n", + "anyon know how much it cost to host a web portal well it depend on how mani visitor your expect thi can be anywher from less than number buck a month to a coupl of dollar number you should checkout httpaddr or perhap amazon ec number if your run someth big to unsubscrib yourself from thi mail list send an email to emailaddr\n", + "[0. 0. 0. ... 0. 0. 0.] 55\n", + "\n", + "Length of feature vector: 1899\n", + "Number of non-zero entries: 45\n" + ] + } + ], + "source": [ + "# Extract Features\n", + "with open(os.path.join('Data', 'emailSample1.txt')) as fid:\n", + " file_contents = fid.read()\n", + "\n", + "word_indices = processEmail(file_contents)\n", + "features = emailFeatures(word_indices)\n", + "\n", + "# Print Stats\n", + "print('\\nLength of feature vector: %d' % len(features))\n", + "print('Number of non-zero entries: %d' % sum(features > 0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[4] = emailFeatures\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3 Training SVM for Spam Classification\n", + "\n", + "In the following section we will load a preprocessed training dataset that will be used to train a SVM classifier. The file `spamTrain.mat` (within the `Data` folder for this exercise) contains 4000 training examples of spam and non-spam email, while `spamTest.mat` contains 1000 test examples. Each\n", + "original email was processed using the `processEmail` and `emailFeatures` functions and converted into a vector $x^{(i)} \\in \\mathbb{R}^{1899}$.\n", + "\n", + "After loading the dataset, the next cell proceed to train a linear SVM to classify between spam ($y = 1$) and non-spam ($y = 0$) emails. Once the training completes, you should see that the classifier gets a training accuracy of about 99.8% and a test accuracy of about 98.5%." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Linear SVM (Spam Classification)\n", + "This may take 1 to 2 minutes ...\n", + "\n" + ] + } + ], + "source": [ + "# Load the Spam Email dataset\n", + "# You will have X, y in your environment\n", + "data = loadmat(os.path.join('Data', 'spamTrain.mat'))\n", + "X, y= data['X'].astype(float), data['y'][:, 0]\n", + "\n", + "print('Training Linear SVM (Spam Classification)')\n", + "print('This may take 1 to 2 minutes ...\\n')\n", + "\n", + "C = 0.1\n", + "model = utils.svmTrain(X, y, C, utils6.linearKernel)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Accuracy: 99.85\n" + ] + } + ], + "source": [ + "# Compute the training accuracy\n", + "p = utils.svmPredict(model, X)\n", + "\n", + "print('Training Accuracy: %.2f' % (np.mean(p == y) * 100))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Execute the following cell to load the test set and compute the test accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Evaluating the trained Linear SVM on a test set ...\n", + "Test Accuracy: 98.90\n" + ] + } + ], + "source": [ + "# Load the test dataset\n", + "# You will have Xtest, ytest in your environment\n", + "data = loadmat(os.path.join('Data', 'spamTest.mat'))\n", + "Xtest, ytest = data['Xtest'].astype(float), data['ytest'][:, 0]\n", + "\n", + "print('Evaluating the trained Linear SVM on a test set ...')\n", + "p = utils.svmPredict(model, Xtest)\n", + "\n", + "print('Test Accuracy: %.2f' % (np.mean(p == ytest) * 100))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.4 Top Predictors for Spam\n", + "\n", + "To better understand how the spam classifier works, we can inspect the parameters to see which words the classifier thinks are the most predictive of spam. The next cell finds the parameters with the largest positive values in the classifier and displays the corresponding words similar to the ones shown in the figure below.\n", + "\n", + "
\n", + "our click remov guarante visit basenumb dollar pleas price will nbsp most lo ga hour\n", + "
\n", + "\n", + "Thus, if an email contains words such as “guarantee”, “remove”, “dollar”, and “price” (the top predictors shown in the figure), it is likely to be classified as spam.\n", + "\n", + "Since the model we are training is a linear SVM, we can inspect the weights learned by the model to understand better how it is determining whether an email is spam or not. The following code finds the words with the highest weights in the classifier. Informally, the classifier 'thinks' that these words are the most likely indicators of spam." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Sort the weights and obtin the vocabulary list\n", + "# NOTE some words have the same weights, \n", + "# so their order might be different than in the text above\n", + "idx = np.argsort(model['w'])\n", + "top_idx = idx[-15:][::-1]\n", + "vocabList = utils.getVocabList()\n", + "\n", + "print('Top predictors of spam:')\n", + "print('%-15s %-15s' % ('word', 'weight'))\n", + "print('----' + ' '*12 + '------')\n", + "for word, w in zip(np.array(vocabList)[top_idx], model['w'][top_idx]):\n", + " print('%-15s %0.2f' % (word, w))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.5 Optional (ungraded) exercise: Try your own emails\n", + "\n", + "Now that you have trained a spam classifier, you can start trying it out on your own emails. In the starter code, we have included two email examples (`emailSample1.txt` and `emailSample2.txt`) and two spam examples (`spamSample1.txt` and `spamSample2.txt`). The next cell runs the spam classifier over the first spam example and classifies it using the learned SVM. You should now try the other examples we have provided and see if the classifier gets them right. You can also try your own emails by replacing the examples (plain text files) with your own emails.\n", + "\n", + "*You do not need to submit any solutions for this optional (ungraded) exercise.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "filename = os.path.join('Data', 'emailSample1.txt')\n", + "\n", + "with open(filename) as fid:\n", + " file_contents = fid.read()\n", + "\n", + "word_indices = processEmail(file_contents, verbose=False)\n", + "x = emailFeatures(word_indices)\n", + "p = utils.svmPredict(model, x)\n", + "\n", + "print('\\nProcessed %s\\nSpam Classification: %s' % (filename, 'spam' if p else 'not spam'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.6 Optional (ungraded) exercise: Build your own dataset\n", + "\n", + "In this exercise, we provided a preprocessed training set and test set. These datasets were created using the same functions (`processEmail` and `emailFeatures`) that you now have completed. For this optional (ungraded) exercise, you will build your own dataset using the original emails from the SpamAssassin Public Corpus.\n", + "\n", + "Your task in this optional (ungraded) exercise is to download the original\n", + "files from the public corpus and extract them. After extracting them, you should run the `processEmail` and `emailFeatures` functions on each email to extract a feature vector from each email. This will allow you to build a dataset `X`, `y` of examples. You should then randomly divide up the dataset into a training set, a cross validation set and a test set.\n", + "\n", + "While you are building your own dataset, we also encourage you to try building your own vocabulary list (by selecting the high frequency words that occur in the dataset) and adding any additional features that you think\n", + "might be useful. Finally, we also suggest trying to use highly optimized SVM toolboxes such as [`LIBSVM`](https://www.csie.ntu.edu.tw/~cjlin/libsvm/) or [`scikit-learn`](http://scikit-learn.org/stable/modules/classes.html#module-sklearn.svm).\n", + "\n", + "*You do not need to submit any solutions for this optional (ungraded) exercise.*" + ] + }, + { + "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.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/exercise7.ipynb b/exercise7.ipynb new file mode 100644 index 000000000..4dd38a987 --- /dev/null +++ b/exercise7.ipynb @@ -0,0 +1,6610 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Programming Exercise 7:\n", + "# K-means Clustering and Principal Component Analysis\n", + "\n", + "## Introduction\n", + "\n", + "In this exercise, you will implement the K-means clustering algorithm and apply it to compress an image. In the second part, you will use principal component analysis to find a low-dimensional representation of face images. Before starting on the programming exercise, we strongly recommend watching the video lectures and completing the review questions for the associated topics.\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", + "# Import regular expressions to process emails\n", + "import re\n", + "\n", + "# Plotting library\n", + "from matplotlib import pyplot\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "import matplotlib as mpl\n", + "\n", + "from IPython.display import HTML, display, clear_output\n", + "\n", + "try:\n", + " pyplot.rcParams[\"animation.html\"] = \"jshtml\"\n", + "except ValueError:\n", + " pyplot.rcParams[\"animation.html\"] = \"html5\"\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", + "%load_ext autoreload\n", + "%autoreload 2\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 | Submitted Function | Points |\n", + "| :- |:- |:- | :-: |\n", + "| 1 | [Find Closest Centroids](#section1) | [`findClosestCentroids`](#findClosestCentroids) | 30 |\n", + "| 2 | [Computed Centroid Means](#section2) | [`computeCentroids`](#computeCentroids) | 30 |\n", + "| 3 | [PCA](#section3) | [`pca`](#pca) | 20 |\n", + "| 4 | [Project Data](#section4) | [`projectData`](#projectData) | 10 |\n", + "| 5 | [Recover Data](#section5) | [`recoverData`](#recoverData) | 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", + "
\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", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1 K-means Clustering\n", + "\n", + "In this exercise, you will implement K-means algorithm and use it for image compression. You will first start on an example 2D dataset that will help you gain an intuition of how the K-means algorithm works. After\n", + "that, you wil use the K-means algorithm for image compression by reducing the number of colors that occur in an image to only those that are most common in that image.\n", + "\n", + "### 1.1 Implementing K-means\n", + "\n", + "The K-means algorithm is a method to automatically cluster similar data examples together. Concretely, you are given a training set $\\{x^{(1)} , \\cdots, x^{(m)}\\}$ (where $x^{(i)} \\in \\mathbb{R}^n$), and want to group the data into a few cohesive “clusters”. The intuition behind K-means is an iterative procedure that starts by guessing the initial centroids, and then refines this guess by repeatedly assigning examples to their closest centroids and then recomputing the centroids based on the assignments.\n", + "\n", + "The K-means algorithm is as follows:\n", + "\n", + "```python\n", + "centroids = kMeansInitCentroids(X, K)\n", + "for i in range(iterations):\n", + " # Cluster assignment step: Assign each data point to the\n", + " # closest centroid. idx[i] corresponds to cˆ(i), the index\n", + " # of the centroid assigned to example i\n", + " idx = findClosestCentroids(X, centroids)\n", + " \n", + " # Move centroid step: Compute means based on centroid\n", + " # assignments\n", + " centroids = computeMeans(X, idx, K)\n", + "```\n", + "\n", + "The inner-loop of the algorithm repeatedly carries out two steps: (1) Assigning each training example $x^{(i)}$ to its closest centroid, and (2) Recomputing the mean of each centroid using the points assigned to it. The K-means algorithm will always converge to some final set of means for the centroids. Note that the converged solution may not always be ideal and depends on the initial setting of the centroids. Therefore, in practice the K-means algorithm is usually run a few times with different random initializations. One way to choose between these different solutions from different random initializations is to choose the one with the lowest cost function value (distortion). You will implement the two phases of the K-means algorithm separately\n", + "in the next sections." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "#### 1.1.1 Finding closest centroids\n", + "\n", + "In the “cluster assignment” phase of the K-means algorithm, the algorithm assigns every training example $x^{(i)}$ to its closest centroid, given the current positions of centroids. Specifically, for every example $i$ we set\n", + "\n", + "$$c^{(i)} := j \\quad \\text{that minimizes} \\quad \\lvert\\rvert x^{(i)} - \\mu_j \\lvert\\rvert^2, $$\n", + "\n", + "where $c^{(i)}$ is the index of the centroid that is closest to $x^{(i)}$, and $\\mu_j$ is the position (value) of the $j^{th}$ centroid. Note that $c^{(i)}$ corresponds to `idx[i]` in the starter code.\n", + "\n", + "Your task is to complete the code in the function `findClosestCentroids`. This function takes the data matrix `X` and the locations of all centroids inside `centroids` and should output a one-dimensional array `idx` that holds the index (a value in $\\{1, ..., K\\}$, where $K$ is total number of centroids) of the closest centroid to every training example.\n", + "\n", + "You can implement this using a loop over every training example and every centroid.\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def findClosestCentroids(X, centroids):\n", + " \"\"\"\n", + " Computes the centroid memberships for every example.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The dataset of size (m, n) where each row is a single example. \n", + " That is, we have m examples each of n dimensions.\n", + " \n", + " centroids : array_like\n", + " The k-means centroids of size (K, n). K is the number\n", + " of clusters, and n is the the data dimension.\n", + " \n", + " Returns\n", + " -------\n", + " idx : array_like\n", + " A vector of size (m, ) which holds the centroids assignment for each\n", + " example (row) in the dataset X.\n", + " \n", + " Instructions\n", + " ------------\n", + " Go over every example, find its closest centroid, and store\n", + " the index inside `idx` at the appropriate location.\n", + " Concretely, idx[i] should contain the index of the centroid\n", + " closest to example i. Hence, it should be a value in the \n", + " range 0..K-1\n", + "\n", + " Note\n", + " ----\n", + " You can use a for-loop over the examples to compute this.\n", + " \"\"\"\n", + " # Set K\n", + " K = centroids.shape[0]\n", + "\n", + " # You need to return the following variables correctly.\n", + " idx = np.zeros(X.shape[0], dtype=int)\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " d = np.zeros((K,1))\n", + " for i in range(X.shape[0]):\n", + " for j in range(K):\n", + " d[j,0] = np. linalg. norm(X[i,:]-centroids[j,:])\n", + " index_ = np.argmin(d, axis=0)\n", + " idx[i]=index_\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " # =============================================================\n", + " return idx" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you have completed the code in `findClosestCentroids`, the following cell will run your code and you should see the output `[0 2 1]` corresponding to the centroid assignments for the first 3 examples." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Closest centroids for the first 3 examples:\n", + "[0 2 1]\n", + "(the closest centroids should be 0, 2, 1 respectively)\n" + ] + } + ], + "source": [ + "# Load an example dataset that we will be using\n", + "data = loadmat(os.path.join('Data', 'ex7data2.mat'))\n", + "X = data['X']\n", + "\n", + "# Select an initial set of centroids\n", + "K = 3 # 3 Centroids\n", + "initial_centroids = np.array([[3, 3], [6, 2], [8, 5]])\n", + "\n", + "# Find the closest centroids for the examples using the initial_centroids\n", + "idx = findClosestCentroids(X, initial_centroids)\n", + "\n", + "print('Closest centroids for the first 3 examples:')\n", + "print(idx[:3])\n", + "print('(the closest centroids should be 0, 2, 1 respectively)')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[1] = findClosestCentroids\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 1.1.2 Computing centroid means\n", + "\n", + "Given assignments of every point to a centroid, the second phase of the algorithm recomputes, for each centroid, the mean of the points that were assigned to it. Specifically, for every centroid $k$ we set\n", + "\n", + "$$ \\mu_k := \\frac{1}{\\left| C_k\\right|} \\sum_{i \\in C_k} x^{(i)}$$\n", + "\n", + "where $C_k$ is the set of examples that are assigned to centroid $k$. Concretely, if two examples say $x^{(3)}$ and $x^{(5)}$ are assigned to centroid $k = 2$, then you should update $\\mu_2 = \\frac{1}{2} \\left( x^{(3)} + x^{(5)} \\right)$.\n", + "\n", + "You should now complete the code in the function `computeCentroids`. You can implement this function using a loop over the centroids. You can also use a loop over the examples; but if you can use a vectorized implementation that does not use such a loop, your code may run faster.\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def computeCentroids(X, idx, K):\n", + " \"\"\"\n", + " Returns the new centroids by computing the means of the data points\n", + " assigned to each centroid.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The datset where each row is a single data point. That is, it \n", + " is a matrix of size (m, n) where there are m datapoints each\n", + " having n dimensions. \n", + " \n", + " idx : array_like \n", + " A vector (size m) of centroid assignments (i.e. each entry in range [0 ... K-1])\n", + " for each example.\n", + " \n", + " K : int\n", + " Number of clusters\n", + " \n", + " Returns\n", + " -------\n", + " centroids : array_like\n", + " A matrix of size (K, n) where each row is the mean of the data \n", + " points assigned to it.\n", + " \n", + " Instructions\n", + " ------------\n", + " Go over every centroid and compute mean of all points that\n", + " belong to it. Concretely, the row vector centroids[i, :]\n", + " should contain the mean of the data points assigned to\n", + " cluster i.\n", + "\n", + " Note:\n", + " -----\n", + " You can use a for-loop over the centroids to compute this.\n", + " \"\"\"\n", + " # Useful variables\n", + " m, n = X.shape\n", + " # You need to return the following variables correctly.\n", + " centroids = np.zeros((K, n))\n", + "\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " for i in range(K):\n", + " c=[idx==i]\n", + " C =np.count_nonzero(c)\n", + " x=sum(X[c])\n", + " centroids[i] = (1/C)*x\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " # =============================================================\n", + " return centroids" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you have completed the code in `computeCentroids`, the following cell will run your code and output the centroids after the first step of K-means." + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Centroids computed after initial finding of closest centroids:\n", + "[[2.42830111 3.15792418]\n", + " [5.81350331 2.63365645]\n", + " [7.11938687 3.6166844 ]]\n", + "\n", + "The centroids should be\n", + " [ 2.428301 3.157924 ]\n", + " [ 5.813503 2.633656 ]\n", + " [ 7.119387 3.616684 ]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\DELL\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:47: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n" + ] + } + ], + "source": [ + "# Compute means based on the closest centroids found in the previous part.\n", + "centroids = computeCentroids(X, idx, K)\n", + "\n", + "print('Centroids computed after initial finding of closest centroids:')\n", + "print(centroids)\n", + "print('\\nThe centroids should be')\n", + "print(' [ 2.428301 3.157924 ]')\n", + "print(' [ 5.813503 2.633656 ]')\n", + "print(' [ 7.119387 3.616684 ]')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[2] = computeCentroids\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 K-means on example dataset \n", + "\n", + "After you have completed the two functions (`findClosestCentroids` and `computeCentroids`), you have all the necessary pieces to run the K-means algorithm. The next cell will run the K-means algorithm on a toy 2D dataset to help you understand how K-means works. Your functions are called from inside the `runKmeans` function (in this assignment's `utils.py` module). We encourage you to take a look at the function to understand how it works. Notice that the code calls the two functions you implemented in a loop.\n", + "\n", + "When you run the next step, the K-means code will produce an animation that steps you through the progress of the algorithm at each iteration. At the end, your figure should look as the one displayed below.\n", + "\n", + "![](Figures/kmeans_result.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\DELL\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:47: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Load an example dataset\n", + "data = loadmat(os.path.join('Data', 'ex7data2.mat'))\n", + "\n", + "# Settings for running K-Means\n", + "K = 3\n", + "max_iters = 10\n", + "\n", + "# For consistency, here we set centroids to specific values\n", + "# but in practice you want to generate them automatically, such as by\n", + "# settings them to be random examples (as can be seen in\n", + "# kMeansInitCentroids).\n", + "initial_centroids = np.array([[3, 3], [6, 2], [8, 5]])\n", + "\n", + "\n", + "# Run K-Means algorithm. The 'true' at the end tells our function to plot\n", + "# the progress of K-Means\n", + "centroids, idx, anim = utils.runkMeans(X, initial_centroids,\n", + " findClosestCentroids, computeCentroids, max_iters, True)\n", + "anim" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3 Random initialization \n", + "\n", + "The initial assignments of centroids for the example dataset in the previous cell were designed so that you will see the same figure as that shown in the cell above. In practice, a\n", + "good strategy for initializing the centroids is to select random examples from the training set.\n", + "\n", + "In this part of the exercise, you should complete the function `kMeansInitCentroids` with the following code:\n", + "\n", + "```python\n", + "# Initialize the centroids to be random examples\n", + "\n", + "# Randomly reorder the indices of examples\n", + "randidx = np.random.permutation(X.shape[0])\n", + "# Take the first K examples as centroids\n", + "centroids = X[randidx[:K], :]\n", + "```\n", + "\n", + "The code above first randomly permutes the indices of the examples (using `permute` within the `numpy.random` module). Then, it selects the first $K$ examples based on the random permutation of the indices. This allows the examples to be selected at random without the risk of selecting the same example twice.\n", + "\n", + "*You do not need to make any submission for this part of the exercise*\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def kMeansInitCentroids(X, K):\n", + " \"\"\"\n", + " This function initializes K centroids that are to be used in K-means on the dataset x.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like \n", + " The dataset of size (m x n).\n", + " \n", + " K : int\n", + " The number of clusters.\n", + " \n", + " Returns\n", + " -------\n", + " centroids : array_like\n", + " Centroids of the clusters. This is a matrix of size (K x n).\n", + " \n", + " Instructions\n", + " ------------\n", + " You should set centroids to randomly chosen examples from the dataset X.\n", + " \"\"\"\n", + " m, n = X.shape\n", + " \n", + " # You should return this values correctly\n", + " centroids = np.zeros((K, n))\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " randidx = np.random.permutation(X.shape[0])\n", + " centroids = X[randidx[:K], :]\n", + "\n", + " \n", + " # =============================================================\n", + " return centroids" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.4 Image compression with K-means\n", + "\n", + "In this exercise, you will apply K-means to image compression. We will use the image below as an example (property of Frank Wouters with permission to this class).\n", + "\n", + "![](Data/bird_small.png)\n", + "\n", + "In a straightforward 24-bit color representation of an image, each pixel is represented as three 8-bit unsigned integers (ranging from 0 to 255) that specify the red, green and blue intensity values. This encoding is often referred to as the RGB encoding. Our image contains thousands of colors, and in this part of the exercise, you will reduce the number of colors to 16 colors.\n", + "\n", + "By making this reduction, it is possible to represent (compress) the photo in an efficient way. Specifically, you only need to store the RGB values of the 16 selected colors, and for each pixel in the image you now need to only store the index of the color at that location (where only 4 bits are necessary to represent 16 possibilities).\n", + "\n", + "In this exercise, you will use the K-means algorithm to select the 16 colors that will be used to represent the compressed image. Concretely, you will treat every pixel in the original image as a data example and use the K-means algorithm to find the 16 colors that best group (cluster) the pixels in the 3-dimensional RGB space. Once you have computed the cluster centroids on the image, you will then use the 16 colors to replace the pixels in the original image.\n", + "\n", + "#### 1.4.1 K-means on pixels\n", + "\n", + "In python, images can be read in as follows:\n", + "\n", + "```python\n", + "# Load 128x128 color image (bird_small.png)\n", + "img = mpl.image.imread(os.path.join('Data', 'bird_small.png'))\n", + "\n", + "# We have already imported matplotlib as mpl at the beginning of this notebook.\n", + "```\n", + "This creates a three-dimensional matrix `A` whose first two indices identify a pixel position and whose last index represents red, green, or blue. For example, A[50, 33, 2] gives the blue intensity of the pixel at row 51 and column 34.\n", + "\n", + "The code in the following cell first loads the image, and then reshapes it to create an m x 3 matrix of pixel colors (where m = 16384 = 128 x 128), and calls your K-means function on it.\n", + "\n", + "After finding the top K = 16 colors to represent the image, you can now assign each pixel position to its closest centroid using the `findClosestCentroids` function. This allows you to represent the original image using the centroid assignments of each pixel. Notice that you have significantly reduced the number of bits that are required to describe the image. The original image required 24 bits for each one of the 128 x 128 pixel locations, resulting in total size of 128 x 128 x 24 = 393,216 bits. The new representation requires some overhead storage in form of a dictionary of 16 colors, each of which require 24 bits, but the image itself then only requires 4 bits per pixel location. The final number of bits used is therefore 16 x 24 + 128 x 128 x 4 = 65,920 bits, which corresponds to compressing the original image by about a factor of 6.\n", + "\n", + "Finally, you can view the effects of the compression by reconstructing the image based only on the centroid assignments. Specifically, you can replace each pixel location with the mean of the centroid assigned to it. The figure below shows the reconstruction we obtained. \n", + "\n", + "![](Figures/bird_compression.png)\n", + "\n", + "Even though the resulting image retains most of the characteristics of the original, we also see some compression artifacts.\n", + "\n", + "Run the following cell to compute the centroids and the centroid allocation of each pixel in the image." + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\DELL\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:47: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# ======= Experiment with these parameters ================\n", + "# You should try different values for those parameters\n", + "K = 16\n", + "max_iters = 10\n", + "\n", + "# Load an image of a bird\n", + "# Change the file name and path to experiment with your own images\n", + "A = mpl.image.imread(os.path.join('Data', 'bird_small.png'))\n", + "# ==========================================================\n", + "\n", + "# Divide by 255 so that all values are in the range 0 - 1\n", + "A /= 255\n", + "\n", + "# Reshape the image into an Nx3 matrix where N = number of pixels.\n", + "# Each row will contain the Red, Green and Blue pixel values\n", + "# This gives us our dataset matrix X that we will use K-Means on.\n", + "X = A.reshape(-1, 3)\n", + "\n", + "# When using K-Means, it is important to randomly initialize centroids\n", + "# You should complete the code in kMeansInitCentroids above before proceeding\n", + "initial_centroids = kMeansInitCentroids(X, K)\n", + "\n", + "# Run K-Means\n", + "centroids, idx = utils.runkMeans(X, initial_centroids,\n", + " findClosestCentroids,\n", + " computeCentroids,\n", + " max_iters)\n", + "\n", + "# We can now recover the image from the indices (idx) by mapping each pixel\n", + "# (specified by its index in idx) to the centroid value\n", + "# Reshape the recovered image into proper dimensions\n", + "X_recovered = centroids[idx, :].reshape(A.shape)\n", + "\n", + "# Display the original image, rescale back by 255\n", + "fig, ax = pyplot.subplots(1, 2, figsize=(8, 4))\n", + "ax[0].imshow(A*255)\n", + "ax[0].set_title('Original')\n", + "ax[0].grid(False)\n", + "\n", + "# Display compressed image, rescale back by 255\n", + "ax[1].imshow(X_recovered*255)\n", + "ax[1].set_title('Compressed, with %d colors' % K)\n", + "ax[1].grid(False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You do not need to make any submissions for this part of the exercise.*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.5 Optional (ungraded) exercise: Use your own image\n", + "\n", + "In this exercise, modify the code we have supplied in the previous cell to run on one of your own images. Note that if your image is very large, then K-means can take a long time to run. Therefore, we recommend that you resize your images to\n", + "manageable sizes before running the code. You can also try to vary $K$ to see the effects on the compression." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2 Principal Component Analysis\n", + "\n", + "In this exercise, you will use principal component analysis (PCA) to perform dimensionality reduction. You will first experiment with an example 2D dataset to get intuition on how PCA works, and then use it on a bigger dataset of 5000 face image dataset.\n", + "\n", + "### 2.1 Example Dataset\n", + "\n", + "To help you understand how PCA works, you will first start with a 2D dataset which has one direction of large variation and one of smaller variation. The cell below will plot the training data, also shown in here:\n", + "\n", + "In this part of the exercise, you will visualize what happens when you use PCA to reduce the data from 2D to 1D. In practice, you might want to reduce data from 256 to 50 dimensions, say; but using lower dimensional data in this example allows us to visualize the algorithms better." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Load the dataset into the variable X \n", + "data = loadmat(os.path.join('Data', 'ex7data1.mat'))\n", + "X = data['X']\n", + "\n", + "# Visualize the example dataset\n", + "pyplot.plot(X[:, 0], X[:, 1], 'bo', ms=10, mec='k', mew=1)\n", + "pyplot.axis([0.5, 6.5, 2, 8])\n", + "pyplot.gca().set_aspect('equal')\n", + "pyplot.grid(False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 2.2 Implementing PCA\n", + "\n", + "In this part of the exercise, you will implement PCA. PCA consists of two computational steps: \n", + "\n", + "1. Compute the covariance matrix of the data.\n", + "2. Use SVD (in python we use numpy's implementation `np.linalg.svd`) to compute the eigenvectors $U_1$, $U_2$, $\\dots$, $U_n$. These will correspond to the principal components of variation in the data.\n", + "\n", + "First, you should compute the covariance matrix of the data, which is given by:\n", + "\n", + "$$ \\Sigma = \\frac{1}{m} X^T X$$\n", + "\n", + "where $X$ is the data matrix with examples in rows, and $m$ is the number of examples. Note that $\\Sigma$ is a $n \\times n$ matrix and not the summation operator. \n", + "\n", + "After computing the covariance matrix, you can run SVD on it to compute the principal components. In python and `numpy` (or `scipy`), you can run SVD with the following command: `U, S, V = np.linalg.svd(Sigma)`, where `U` will contain the principal components and `S` will contain a diagonal matrix. Note that the `scipy` library also has a similar function to compute SVD `scipy.linalg.svd`. The functions in the two libraries use the same C-based library (LAPACK) for the SVD computation, but the `scipy` version provides more options and arguments to control SVD computation. In this exercise, we will stick with the `numpy` implementation of SVD.\n", + "\n", + "Complete the code in the following cell to implemente PCA.\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def pca(X):\n", + " \"\"\"\n", + " Run principal component analysis.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The dataset to be used for computing PCA. It has dimensions (m x n)\n", + " where m is the number of examples (observations) and n is \n", + " the number of features.\n", + " \n", + " Returns\n", + " -------\n", + " U : array_like\n", + " The eigenvectors, representing the computed principal components\n", + " of X. U has dimensions (n x n) where each column is a single \n", + " principal component.\n", + " \n", + " S : array_like\n", + " A vector of size n, contaning the singular values for each\n", + " principal component. Note this is the diagonal of the matrix we \n", + " mentioned in class.\n", + " \n", + " Instructions\n", + " ------------\n", + " You should first compute the covariance matrix. Then, you\n", + " should use the \"svd\" function to compute the eigenvectors\n", + " and eigenvalues of the covariance matrix. \n", + "\n", + " Notes\n", + " -----\n", + " When computing the covariance matrix, remember to divide by m (the\n", + " number of examples).\n", + " \"\"\"\n", + " # Useful values\n", + " m, n = X.shape\n", + "\n", + " # You need to return the following variables correctly.\n", + " U = np.zeros(n)\n", + " S = np.zeros(n)\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " sigma = (1/m)*np.dot(X.T,X)\n", + " U,S,V = np.linalg.svd(sigma)\n", + " \n", + " \n", + " \n", + " # ============================================================\n", + " return U, S" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before using PCA, it is important to first normalize the data by subtracting the mean value of each feature from the dataset, and scaling each dimension so that they are in the same range.\n", + "\n", + "In the next cell, this normalization will be performed for you using the `utils.featureNormalize` function.\n", + "After normalizing the data, you can run PCA to compute the principal components. Your task is to complete the code in the function `pca` to compute the principal components of the dataset. \n", + "\n", + "Once you have completed the function `pca`, the following cell will run PCA on the example dataset and plot the corresponding principal components found similar to the figure below. \n", + "\n", + "![](Figures/pca_components.png)\n", + "\n", + "\n", + "The following cell will also output the top principal component (eigenvector) found, and you should expect to see an output of about `[-0.707 -0.707]`. (It is possible that `numpy` may instead output the negative of this, since $U_1$ and $-U_1$ are equally valid choices for the first principal component.)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top eigenvector: U[:, 0] = [-0.707107 -0.707107]\n", + " (you should expect to see [-0.707107 -0.707107])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Before running PCA, it is important to first normalize X\n", + "X_norm, mu, sigma = utils.featureNormalize(X)\n", + "\n", + "# Run PCA\n", + "U, S = pca(X_norm)\n", + "\n", + "# Draw the eigenvectors centered at mean of data. These lines show the\n", + "# directions of maximum variations in the dataset.\n", + "fig, ax = pyplot.subplots()\n", + "ax.plot(X[:, 0], X[:, 1], 'bo', ms=10, mec='k', mew=0.25)\n", + "\n", + "for i in range(2):\n", + " ax.arrow(mu[0], mu[1], 1.5 * S[i]*U[0, i], 1.5 * S[i]*U[1, i],\n", + " head_width=0.25, head_length=0.2, fc='k', ec='k', lw=2, zorder=1000)\n", + "\n", + "ax.axis([0.5, 6.5, 2, 8])\n", + "ax.set_aspect('equal')\n", + "ax.grid(False)\n", + "\n", + "print('Top eigenvector: U[:, 0] = [{:.6f} {:.6f}]'.format(U[0, 0], U[1, 0]))\n", + "print(' (you should expect to see [-0.707107 -0.707107])')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[3] = pca\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3 Dimensionality Reduction with PCA\n", + "\n", + "After computing the principal components, you can use them to reduce the feature dimension of your dataset by projecting each example onto a lower dimensional space, $x^{(i)} \\rightarrow z^{(i)}$ (e.g., projecting the data from 2D to 1D). In this part of the exercise, you will use the eigenvectors returned by PCA and\n", + "project the example dataset into a 1-dimensional space. In practice, if you were using a learning algorithm such as linear regression or perhaps neural networks, you could now use the projected data instead of the original data. By using the projected data, you can train your model faster as there are less dimensions in the input.\n", + "\n", + "\n", + "\n", + "#### 2.3.1 Projecting the data onto the principal components\n", + "\n", + "You should now complete the code in the function `projectData`. Specifically, you are given a dataset `X`, the principal components `U`, and the desired number of dimensions to reduce to `K`. You should project each example in `X` onto the top `K` components in `U`. Note that the top `K` components in `U` are given by\n", + "the first `K` columns of `U`, that is `Ureduce = U[:, :K]`.\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def projectData(X, U, K):\n", + " \"\"\"\n", + " Computes the reduced data representation when projecting only \n", + " on to the top K eigenvectors.\n", + " \n", + " Parameters\n", + " ----------\n", + " X : array_like\n", + " The input dataset of shape (m x n). The dataset is assumed to be \n", + " normalized.\n", + " \n", + " U : array_like\n", + " The computed eigenvectors using PCA. This is a matrix of \n", + " shape (n x n). Each column in the matrix represents a single\n", + " eigenvector (or a single principal component).\n", + " \n", + " K : int\n", + " Number of dimensions to project onto. Must be smaller than n.\n", + " \n", + " Returns\n", + " -------\n", + " Z : array_like\n", + " The projects of the dataset onto the top K eigenvectors. \n", + " This will be a matrix of shape (m x k).\n", + " \n", + " Instructions\n", + " ------------\n", + " Compute the projection of the data using only the top K \n", + " eigenvectors in U (first K columns). \n", + " For the i-th example X[i,:], the projection on to the k-th \n", + " eigenvector is given as follows:\n", + " \n", + " x = X[i, :]\n", + " projection_k = np.dot(x, U[:, k])\n", + "\n", + " \"\"\"\n", + " # You need to return the following variables correctly.\n", + " Z = np.zeros((X.shape[0], K))\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " for i in range(X.shape[0]):\n", + " x = X[i,:]\n", + " projection_k = np.dot(x, U[:,:K])\n", + " Z[i,:] = projection_k.T\n", + "\n", + " print(Z.shape,projection_k.shape)\n", + "\n", + " \n", + " # =============================================================\n", + " return Z" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you have completed the code in `projectData`, the following cell will project the first example onto the first dimension and you should see a value of about 1.481 (or possibly -1.481, if you got $-U_1$ instead of $U_1$)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(50, 1) (1,)\n", + "Projection of the first example: 1.481274\n", + "(this value should be about : 1.481274)\n" + ] + } + ], + "source": [ + "# Project the data onto K = 1 dimension\n", + "K = 1\n", + "Z = projectData(X_norm, U, K)\n", + "print('Projection of the first example: {:.6f}'.format(Z[0, 0]))\n", + "print('(this value should be about : 1.481274)')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[4] = projectData\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "#### 2.3.2 Reconstructing an approximation of the data\n", + "\n", + "After projecting the data onto the lower dimensional space, you can approximately recover the data by projecting them back onto the original high dimensional space. Your task is to complete the function `recoverData` to project each example in `Z` back onto the original space and return the recovered approximation in `Xrec`.\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def recoverData(Z, U, K):\n", + " \"\"\"\n", + " Recovers an approximation of the original data when using the \n", + " projected data.\n", + " \n", + " Parameters\n", + " ----------\n", + " Z : array_like\n", + " The reduced data after applying PCA. This is a matrix\n", + " of shape (m x K).\n", + " \n", + " U : array_like\n", + " The eigenvectors (principal components) computed by PCA.\n", + " This is a matrix of shape (n x n) where each column represents\n", + " a single eigenvector.\n", + " \n", + " K : int\n", + " The number of principal components retained\n", + " (should be less than n).\n", + " \n", + " Returns\n", + " -------\n", + " X_rec : array_like\n", + " The recovered data after transformation back to the original \n", + " dataset space. This is a matrix of shape (m x n), where m is \n", + " the number of examples and n is the dimensions (number of\n", + " features) of original datatset.\n", + " \n", + " Instructions\n", + " ------------\n", + " Compute the approximation of the data by projecting back\n", + " onto the original space using the top K eigenvectors in U.\n", + " For the i-th example Z[i,:], the (approximate)\n", + " recovered data for dimension j is given as follows:\n", + "\n", + " v = Z[i, :]\n", + " recovered_j = np.dot(v, U[j, :K])\n", + "\n", + " Notice that U[j, :K] is a vector of size K.\n", + " \"\"\"\n", + " # You need to return the following variables correctly.\n", + " X_rec = np.zeros((Z.shape[0], U.shape[0]))\n", + "\n", + " # ====================== YOUR CODE HERE ======================\n", + " \n", + " X_rec = np.dot(Z, np.transpose(U[:, :K]))\n", + " \n", + "\n", + " \n", + "\n", + " # =============================================================\n", + " return X_rec" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you have completed the code in `recoverData`, the following cell will recover an approximation of the first example and you should see a value of about `[-1.047 -1.047]`. The code will then plot the data in this reduced dimension space. This will show you what the data looks like when using only the corresponding eigenvectors to reconstruct it. An example of what you should get for PCA projection is shown in this figure: \n", + "\n", + "![](Figures/pca_reconstruction.png)\n", + "\n", + "In the figure above, the original data points are indicated with the blue circles, while the projected data points are indicated with the red circles. The projection effectively only retains the information in the direction given by $U_1$. The dotted lines show the distance from the data points in original space to the projected space. Those dotted lines represent the error measure due to PCA projection." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Approximation of the first example: [-1.047419 -1.047419]\n", + " (this value should be about [-1.047419 -1.047419])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAATMAAAEvCAYAAAApTCa+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3de1zUZd7/8deFgKACpiGmqWm5ZVlYqdWarqgp3nkAtYNmJ612tdpSS+u2trvVftaW1V1t7baZWWHda4aaborhAd2t9ZTkmmam2brmAVEQUGDg8/vjyzAMDIeBGebA5/l4zIPm9J1reOSb63wZEUEppQJdiK8LoJRSnqBhppQKChpmSqmgoGGmlAoKGmZKqaCgYaaUCgqhvvjQ888/Xy666CJffLRSKsBt3749S0RiKz/ukzC76KKL2LZtmy8+WikV4Iwxh1w9rs1MpVRQ0DBTSgUFDTOlVFDQMFNKBQUNM6VUUNAwU0oFBQ0zpVRQ0DBTSgUFDTOlVFDQMFNKBQUNM6VUUNAwU0oFBQ0zpVRQ0DBTSgUFDTOlVFDQMFPKCzIyIDkZEhKsnxkZvi5R8PPJ5oxKBbMZM2DBAsjJcTy2fj1Mngzz5/uuXMFOa2ZKeVBGRtUgA+v+ggWwaZNvytUUaJgp5UGvvFIxyEqB78ufy8mBl1/2RamaBg0zpTzo9OmK93YD/YAvyx+pXGNTnqNhppQHtW5d8d6VwPvAaOyBFhPT+GVqKjTMlPKgadMqB1YiVqAtJSYGpk/3TbmaAg0zpTxowABr1LJyoMXEvMTIkTsJDf2yureqBtIwU8rD5s+Hzz6DpCRrnllSknV/4sRjjB49mi+/1EDzBp1nppQX9O9v3ZwN4/3332f06NEsX76cG264wRdFC1paM1OqESUmJvLBBx/QvHlzXxcl6GiYKdXIhg0bxjXXXMPMmTO1yelBGmZK+cigQYO0D82DNMyU8pHExMTyPrR9+/b5ujgBT8NMKR9KTExk7dq1XHLJJRQVFfm6OAGtwWFmjOlkjFlvjNljjNltjHnEEwVTqqmIj4+nsLCQ+Ph4bXI2gCdqZjZghoj0AK4HHjTGXO6B6yrVZERGRvLKK69oH1oDNDjMRORnEdlR9t9ngD1Ax4ZeV6mmxt6HNmnSJG1y1oNH+8yMMRcBVwP/dPHcA8aYbcaYbSdOnPDkxyoVNBITE9mxYwehoaE6KOAmj4WZMaYVsBR4VERyKz8vIm+LSG8R6R0bG+upj1Uq6ERGRrJr1y5uvPFGbXK6wSNhZowJwwqyFBH51BPXVKopi4+PL5+2oYFWN54YzTTAAmCPiOg+mkp5iL0PbdmyZb4uSkAwItKwCxhzI7AJ2IW1TzDAf4vI36p7T+/evWXbtm0N+lylmpLt27dTVFSki9MBY8x2Eeld+XFPjGZuFhEjIleJSK+yW7VBppRyX1ZWljY5a6ErAJQKAMOGDdM+tFpomCkVIOzbB7Vo0cLXRfFLGmZKBZBhw4YRHx/PjBkztIZWiYaZUgHopptu0iZnJRpmSgWgitsHff/997W/oQnQMFMqQCUmJvLFF19w8cUX61pONMyUCmhXXXUV586do2fPnk2+yalhplQAysiA5GTrKLs77mjB/fe/5tSHVvH55GTrfrDTo+aUCjAzZsCCBZCT43hs/fpEBg16n/vuu4+bbtrJindzmHHmd1zKPvZyKXelz2Hs/W2YP9935fY2rZkpFUAyMqoGGVj3161LZPLk7RT86UNWnmnHg7zFENJ5iDf54Uws+W8uYtMm35S7MWiYKRVAXnmlapDZ5eTAX/5QwAOFkxmIsJ5wvqIvZ4mgGaX88dwk/vx8duMWuBFpmCkVQE6frnjvJ+B+oLD8kemnnqY3wtuEM4h23MDfaMPJ8kAbm/l0I5e48WiYKRVAWreueO8CIBsYRwSnmEAKN5WsLnvmKqyNbNpyjhZ8w5UAdCv6rnEL3Ig0zJQKINOmQUyM/V4Y8DGtyWcYF5DCRC4qOQBAX7bRj10ARFDAVWX/Hdvv0sYvdCPRMFMqgAwYAJMnOwItAhvfsJtnKeTw+fEUT52KAAbYxAD+SW+yaUsk5yglhA4L5viy+F6lYaZUgJk/Hz77DJKSYPblqXTiOBd378WXr83i67vvxrzzTnmg9WU7kZxDTAgh770Lbdr4uvheo/PMlN/JyLBG7U6ftvqIpk2zaiTKoX9/68bcA/A0tEoeyi3jx1tP9u2LycyE11+Hbt0gMREzZ05QBxlomCk/43pCqNW0CuYJn/XWrZv1c80amDsXwsKguNgx5X/OHJgwwXfla0TazFR+o6YJoQsWENQTPustORni4iAzE/r0gZkzrZ+Zmdbjycm+LmGj0ZqZ8hu1TQh9+eWyppVyiIy0OtBGjrQCLDPTejwuzno8MtK35WtEGmbKbzhPCF0NfAr8CXsDorqga/L69IGDByE1FQ4csJqeyclNKshAw0z5EecJoTcC87BmuP8FCKkwv0pVERnZZPrGqqN9ZspvOE8IbQWsAvYDzxETA9On+6xovlNQACkpVuf+4sVw9qyvS+S3tGam/IZ9QqhjEMAKtKioQu68M49+/VrQpP7+bt1q9YUdO+Z4zN4X1qeP78rlp5rQ/xkqEFScEJqQAElJrVi1qi3G/Df3338/paWlvi5i4zh71hFkvXpZo5Tx8db9kSO1huaCEZFG/9DevXvLtm3bGv1zVeDKy8vj5ptv5pJLLuEvf/kLISFB/nd48WK44w4ryLZsYfe+fRw5dCGXjP8VXXMzefnaFHq/PKFJTiY2xmwXkd6VHw/y/yNUsGjVqhWrVq3ihx9+ICOY94C295G9+651PyEBwsKYOPFPDB+VTEpuAgDZ2w8wapQ1yVhZNMxUwGjVqhXp6ekMHDiQv//9743S5GzUvfS3brWmVUycCOnp1mOvv87Xb37JgQOvUlrSkRW8QwFwgG46mbgyEWn027XXXitK1VdJSYkkJCTIpEmTpKSkxGufM326SEyMCDhuMTHW4x5XUCASF2d9SK9e1oeEhoqAFJtQmc+jso2r5LcgG2krERSUlykpyQvl8WPANnGRK1ozUwEnJCSEFStWsH//fq8NCjT60qrUVEdn/5Yt1khIRgaEhhIqNqbzKtfyDU8Sxww+5xyOCbE6mdiiYaYCkr0PLTw8nDNnznj8+lWXVp0DrMEy+9IqjzpgbarI0KEQFkZpaSk/dewIDz8MwBcMZgIpdOUg23CelqGTiS0aZipgtWrVirfeegsRYd68eR6toTkvrQJ4EPgdFQPNoyruflFczLZt27juuuvYtWoVAB9HTuIjJjjVyICmO5nYBQ0zFfBCQ0NZvXq1R5uczkurwFpatQx7oHm8NlRp94u+n3zCq+HhDN23j11t2tD2vuQqnxkTY00y1sX3ZVx1pHn7pgMAytPOnDkjAwYMkPvuu88j19u4sWrnPxwTuFJatvynZGR45GOcbdniGAQou30cEyOPTZwoIiKvvSZywQUirVtbP197zQtlCABUMwCgy5lUULD3oa1fv94j16u6tAqgHdHRW7nvvubExHyDyJUYYzzyeYDL3S9uS07mtshI7rzza5YtCyUvzzpl6fRpePpp+PFH3bTSTlcAqKCzatUqli9fzp/+9KcGrxTYtMnq7M/JcfRP3XCDjT59+jBixAh+//vfuww0l1t/9y6wgurgQbe26cnIgOHDl1BQ8FsgDcqOjQOrTJ991rSamtWtANBmpgo69ianN+ehHT9+XHr27ClPPfWUlJaWOj3nan7awJZbJKeFcxNS4uKspmUtkpLsb/lYoL3AN06X0XlmOs9MBSl7k3P//v3MmzfPK58RGxvLunXr2L9/PwUFBeWPV56fFkkB97CQFfkJRBccI+/iq9xeNO4YWb0NeA0odnpe55lZPBJmxph3jTHHjTH/8sT1lGooe6BNmTKF3NxcNmwo9fiypNjYWD766CNsNhtvv/02IuI0P603W9lIFxYyiSjyASg+fAzGjbOWLtkDLTW1xs9xHlm9BbjG6XmdZ2bx1ADAe8AbwPseup5SDdaqVSsAevV6iG+/PUtxsbVjLXj2xKeioiJef/11Dh8+zKlTzwKGCM6yjJsZRhYTCOe/KeI4sbQrPEbhiBEcWruWXwwdak3FsE+Yrca0aVZ5XdXAdJ6Zg0dqZiKSAWR74lpKeVJGBhw8+DzFxfuxtuC25qF5cllSbGws6enppKamcvToMwA8wTw6coLPgXcp4lXgPLI50rI7Xx0/zoABA8hcvty6gH3CbDUqn2Jup/PMnHlsNNMYcxGwUkR61vZaHc1UjSU5GZYtA8gDRgD9gWex/x1PSqq1lVetyiOW9957gh071vHlix34vOBXhJStFvg38B0wBBBjMCJ80ro1D50+zZo2bYg/fLhOo5quRlabYpBVN5rZaPPMjDEPAA8AdO7cubE+VjVxjs5z+5kCw4FRWLP5Q+vdee76sOJYfn3XKCYXteV/EJ4FThDLSS5gCN8ggCmrPIw7fRpiYki74w7i63iKUvkp5sqlRhvNFJG3RaS3iPSOjY1trI9VTZxz53lLYCWwGbgCsNWr87ymHTVOvpPKQNtZUoFnTBjtOIGJKuHrqPMon40WHg4LFzLu5595/LXXWLt2LTt37nS/IMqJTs1Q9daoGxfWk/OJTwDRwF6gmNDQ+3n0UasPzZ3v4ryjxmngNJEUMIEUbj/7Lu2AdCChQzuIi+PEmd0MP3OKr+1veeopuOee8qZlbm4uiYmJGmgN5Wrymbs34CPgZ6wJMIeByTW9XifNBr5G3biwgVyVNTr6jFx66e3y0EMPybRpJW59l4EDK772ZWnJFbKX2MoLOa3blVeKDB8uS0NCJA5kR8uW1kaMlSxZskTi4uJk586dXv5tBD6qmTSrKwCU21wvwnaEgFcWYTdQRoY1Uz4hwfr52msiI0ackRYtfilwjUBxnb+LY0a+SGtOyAOES1+QTDrJqzwsxSbU5S9nqTGyYNasasu4fPlyOXjwoPd+CUFCw0x5TMV/zHBcYG9ALa9xrqn9LBAjcIVASZUMcvVd7GHemy1yihgpBXkE5BOQoyZO9s58p3zL6wpVwfJk/Pjjj2XHjh0uy1ZaWir33HOP1tBqUF2YaZ+ZcpvzxoWbgUFY/VAWf15eU7Xzvj1W2SOAm4E/OL3e1XcZMAB+fddZVpqRtCYHA9xOX34REk+cHOPSRbPhN7+xXjx4sHXa0tGj5UORYWFhDB8+nK+//rrKtY0x3HzzzQwbNozMzEzPfOkmQsNMuc15hDAZa+PCwdgDzZ+X11TdDvsj4CywAWgNPIf1fSzVfZcXrk8lTo5xPLILxUC7qHPkrv6HY4nSihXWCydNggkTnOaRjRkzhjfffJPhw4fzzTffVLn2uHHjeOONNxg2bBhHjx5tyNdtUjTMlNuqjhDehRUA//L75TVVt8M+BSQAJ4C/AHHAM8Afa/4uZUuQ2k0Zy7bzzqPrmW/o9/gvrWkXAD/9ZO0cm5zs8u1jxoxh0aJFdOjQweXz48aNY926dbRv355z58658xWbLA0z5TbXy2vuIiZmHNddt5DY2L3VvdXnqm6HPRV4HCvQsoAMoDkhIe9zzz1F1U9StS9BSk/nhlWr2NmmDc9mZiJbt1qPR0dbG43VMCF22LBhtGnThtGjR7tscl5++eVkZWXRo0cPbXLWhauONG/fdAAgOFQeIczIEFm0aJF06NBB9uzZ4+viuVT9SOzH0qxZtlx9tcjw4cfkqqv6y5VXXinPPfec9cb8fJEPPxSZM0ckJUXk5EnHFtfx8ZL1m99IfFiYzAIpjY62nq+jpUuXSlxcXLWDAjptwxk6mqkaiz3Q9u3b5+uiuFTdHLlHHimUpKQkOXjwoJw5c0YGDx4s0dHRMvfuu0UiI53fEBcn8t57Tnv2Z4HEh4bKnF//2u0yLV26VNq3by/Z2dkun1+yZInccMMNVTaCbIqqCzPdNlt5xcqVKxkwYADR0dG+LopL1S3a/uMf/8jcuS9y5ZUbKM1vwfYvu5Av51gH3Fj5InFx8O23sHp1+Z79JwcM4GhODj169MAY49YZAYcOHaJLly7k5OSQmRlTZdvt668vorS0lEOHDnHppZd68tcRUHTbbNXoioqKZNiwYX7b5HRl+nSRiIg3pDkd5QDny88gbUBuAdlvjEh4uHMNLSXF5XWeeeYZmTlzpts1qcOHD0vLlhdIq1Y7XK5IWL9+fZNvcqLzzFRjCwsLY8KECQwePJi9e/1zUKDimsz+/eHtt4Fzk/iCs3Qli2jgEHCMUDaJWNW4iAjHBarZWPHhhx8mLS2NJ554wurPqaMffuiIyBvk5Q0Hx2rO8v3XmjUbWD5tQwcFKnGVcN6+ac2saVm0aJF07txZ8vPzfV0UJ676zkBkNr8XAdkD0hXkIEghzeRwi0usF3TtWmvNTEQkKytLevXqJampqXUuk2N1xVKBYdWuSFiyZIm8/PLLDf0VBCS0z0z50k8//UTnzp3Jyckhxg9m1WZkwKhRVWf4R3CW47RjF3m8STOuo4TLgJuAUkz5houANe3i5Mkap1/k5ubSqlUrDh8+TKdOnWrtQ0tIgA0b7PdKgGZVnl+3znF/9erVXHDBBcTHx9fyjYNHdX1m2sxUjaJz587s27ePK664wi+anFVXAgiRFPASjxFFHtcAR4jkOgw3AQLOQQbWLP9aNlaMjo7GGMNdd93Fk08+WWuT03keXLMqz1f+O5CXl6dNTjtX1TVv37SZ2XT5yzw052181klrEuQQ7aq0OY/QTkoqt/WMEXn7bbc+LysrS+Lj42XWrFk1DgrUZ0cS+zy0zMxMd38NAQmdZ6b8xaJFi+SWW27xaRkq7vzRnNMyjOYyGuQ7OouAnKXSqKX91revWxNiK8rKypKhQ4fKkSNHanxdffaKW7FihRw6dEhErEBMSrICOynJuh9MNMyUXykpKZGjR4/K3r17ffL5FWtA40mRQpCBREsYD8tRrImw50IiRECKW5a9sF07lxsrustms8lHH31UYw3N1eqK2pSWlkqPHhOlVauv3QrCQKNhpvzO0qVLfdrktNeAZjNHBGQuMyQq6qS8MmGL08z+8hn/W7Z45HNPnTolvXr1qrXJ6a6NG0VatPhEIE6gaqD546aZ9aFhpvySt/vQqm1yla21PDh5jqzqOlUE5EB0vGxaV2Q9n5Mj0tlqcsrUqR6pkVVU1z40dziazvZAOxZQm2bWVXVh1mhHzSnlyl133QXAt99+y2WXXebRa7s6Du6rdQW8e8V8hn/zAuTncxFwEUBICF1zM+k6rQ8MHQppaY5tfF56qU7nWrqjbdu2pKens2DBAo9d07G90Vis06faOT3vz5tmeoSrhPP2TWtmypW33367Sg2tvp3ZrkYFe7NFfq48YtmypUj37tZ/h4R4rWlZk23btskzzzzT4Bqa83bmVW/BXjPTMFN+o3KTsyEnQDn/wy6VMJbJzxVOUMoLjRZbz55SAJLdPE72t7hSBORw0lTHNj8eblpWx75SoD5rOSsKxINm6kPDTAUEe6ClpHzfoH+YzvPICuQCLpBpIKUVLvRqWJRcT6Tkg6zgZhGQOc3n+GTkzx5oc+bMadB1AukIwPrSMFMBY+XKlXLzzbmVQsz55KTamkwVa2aDSJMskGuhPNAmgmwFGU8zSQDZXzYdYzwpPqvFZGVlyZ49e8RmszWohlafaR2BRMNMBZQBAwoFhgjsEes4uKsFfioPqISEmt9vb3L1I0NKMCIg2SAzQQpB/gmSD1IEcifI6yA/EycRFPi8f+mpp57y+LSNYFJdmOnaTOWX2rQJB+7EOvXpNDARa5/+fwO1nwBlPw5uFSPL11S2JJR5WMu3+wDNgf7AJGAssYzkM85hjVr6cuTv0UcfZfXq1XVay6kcNMyUX7JOgLKf+pQITME6fOR2oqOlTidAvXB9KjFYqVQIHGtxEQtaRDEC63C5ZsBcYDTNuYjFbKNP+Xt9ubGHfdrG6tWrWblype8KEmA0zJRfcpwAdRfWQcORwCSioj5j0qQSfvGLY7VfpMLGic8Yw9yC/dzTtTMdW7ViJFAA9CaKsyyliEnAGQC/OC6vbdu2bNq0iREjRvDjjz9qDa0ONMyU35o/3zqtLSnpQvr23UtERE/efPM4Q4asoV+/fvz73/+u+QL24+BCQ5ktwm7god27WZCXR0fgT8BtLVZRzM3ALiCKqKh/M3ky1R8x14iioqIAuPvuu93esbYp0hUAyq/1728Plst4//3/x6xZg0lPT2fq1KkkJCSwfv16OnXq5PrNycnWDP5jx4gKDeVzm43ZQBGwEDBr1hB7rC3hfy0gPz+G0NADbN16PcnJn+Li+BKfMMbw6aefMmTIEACef/55tw5JaVJcjQp4+6ajmaq+Fi1aJLfddpuIiMyfP99xruWJEyJTpogMHmytpbRv07Ol6qLx41FRMmfyZCkpKZGHHnpIBg0aVL6ld1pamsTGxsqmTZt88fWqlZWVJYmJifLzzz/7uig+h07NUMGipKREjhw5Inv27JHSvDz5KilJfqo8szYkxDrXUsSayZ+SUj6zP/fYMenXr5888MADUlRUJHfeeWeVQLvzzjt9+A2rV1xcLIsXL27S0zY0zFRQWbp0qXSIjZU9550nr4FcDFaghYY6joMLCal2I8Xc3Fzp16+fTJkyRWw2mzz88MPy7bffOr3m4MGDsnnz5sb4OnV26tQpj++2EWg0zFRwKSiQRdHR0gHrFKWXQkLk8ubNZTmIxMaKRFgbK8rUqdVeIjc3V9asWSMi1saGJSUlMn/+/PIa2rp16yQ2NlYy/GwKvTe2Dwok1YWZjmYqv1PxLMvkZOt+Famp3JWby7zmzfkemNG7N++sXcv5l1wCJ05wtk0HALYv/q7aa0RFRTF06FA++eQTpkyZQklJCTt37mTkyJEUFBSQkJDA4sWLGTt2LJs2bfLqd3aHfR5au3bWFj91+n01Ba4Szts3rZmp6rhaKB0WJnLrrZVeOMfaHVauvtr6GRFhbbj4+OPyHMjrWNv5vM7UWhdb25uclfvQzp49KyIia9euldWrV3v3i9fThAlbpHnz3wmUBu3C8srQZmbjCfYDJbylpi1soCzQynaIlXHjrAd79HDsQxYRIbbmkfIDSGeQNzDSmpN12m3DHmgvvfSS2Gw2WbhwoZSUlDi95g9/+INfjXJu3CgSFZUlEC8wq0qg+Vnr2GM0zBpJU9iCxVtq21zw+mZbpLBNXNUn2lU9Im4fRlrSVmB1nXfbyM3NlZycHMnOzpaSkhL5/vvvZezYsX47bcPx+7IH2nNu7SwSqKoLM+0z86CMjKrbNIN1f8EC8KNuF7/k2PYZYCXwKvA/wGHO4ySfl9xEePYx6NLFWm/Uvbv10uPHy99VZML4K+PoSxb5ZGItVHeoaQF5VFQU0dHRPPbYY/zmN7+hS5cutGjRorwP7aabbiIlJYXk5GR27tzpke/cEI7fV1sgHRjn9HzQb5NdiUfCzBiTaIz5zhiz3xjzhCeuGYiqnpK9EWu+ufX4yy/7olSBw/k076uA14EdRHA9X3EhrcsWjZ87dIisDz6ARYvgyiutl48bBykp3Dkih9tYwmnaAB2pvMilLgvIX331Vfbs2cODDz7IggUL6NixI/fccw8AN910E3/729+47LLLKCkpadgXbiDn31db4BdOz/tysbxPuKquuXPD2nzgB6AbEA5kApfX9J5gbWY6725aKjBGIFmgsE57cDV1Gzdanf2O3+EhiaCDjAO5BOR42ROLQkKkJ8ix2FiRadOsF5ft0OqpraNzc3Nl4MCBsmXLFrHZbHLgwAGx2WxSULaVdnFxsfTp08enTc6msk12ZXixmdkX2C8iB0SkCPgYGO2B6wYc57+UBvgIsAG3A0VN7y+lmwYMsKYW2J1HS3ZykteBP2BoA5SER3BnaSkTQkL4z4kTsHQpAC8v60ZCglU7Hjasaq0kJga3FpBHRUWxbt06+vTpw8aNG+nSpQvvvfceI0aMoKCggNDQUJ577jnGjBnD5s2bPfL93eXYWcT5cXe/a9BwlXDu3LAa6u9UuH8n8EZN7wnWmpnrv5SFAtMlKioroP9SNuYI7a23Wp39p4gu/0XeB3KwbMdY+4TYUpDfg+witnyHWHut5NZbPbN1dHFxsdx44401Ln3q3Lmz5OXlefA34J5g3ya7Mrw1mgnc4iLMXnfxugeAbcC2zp07N9LXbnzVjWY++GCOzJ49WwoLC31dRLc1+ghtQUGVUctzYc2lfIlS2WOlIDNpLhF0k8oH3nqymeVqHtr//u//lj+fk5MjpaWl8uOPP3rmA1WNvBlmNwBrKtx/EniypvcEa83MztVfysLCQhk1apQkJSUFVKD5pF8mJcX6gC5d5CzIX0JCrFOV7EuUmjUTATkbEikxZAn8TuAKgWyvTU3Izc2VRx55RPLz88Vms0lJSYns2rWrvIa2f/9+v1z6FIy8GWahwAGgK44BgCtqek+wh1l17IGWnJwcMGvqnOd+5Qqs8v5cJvvs/mnTJDs2Vq4BmWmMc5KGhMhDvTIqDLakCticXuKNAZejR4/Ks88+KyUlJfLggw86NTnXrl2rgdYIqguzBg8AiIgNeAhYA+wB/ioiuxt63WAUHh7OkiVLuO+++zDG2P8Y+DXnuV9HgfuBD8sf8cpcJvsOsevWcd7y5ayNjWVIxd9VZCRs2MDhi+w93AZIwhpYd/DGgEuLFi1IS0tjypQpvPLKK3Ts2LF8HtqQIUNYvHgxCxcu9PwHq9q5Sjhv35pqzayi9PR0GTduXKM1OevbgV91Vv5ugQ4CH3ivZlZQ4NhQMT5e5NFHRTp3lkUg08PDpTQrq/w7+WJqgr0PberUqWKz2eS3v/2t7N271+k1P/zwg99tHxQs0OVM/qWwsFBGjhwpycnJXg+0hnTguw6M3QJ/qVNg1HsU1MUOsdmxsXLNZZfJ9OnTy5vpvlo+lpubK2vXrhURa/sgm80mL774YnmTMz093a+WPgUTDTM/ZA+0xx9/3Guf4YnaS3WBMXLkUvnggw/cfl+dg6bSDrFSUCDZ2dlyzTXXyFtvvVX+Ml9OTfj4449rnLahgeZ5GhiscDoAABpZSURBVGZ+qrCwUE6ePCk5OTleqaHVtni7rs1EV4Gxe/du6dChg8tA82YTMDs7W/Ly8uTUqVM+H0ipbfugtLQ0+eKLL3xaxmCjYebnnnzySa9M23BeYvWCwBqPjvjZA+3TTz91erxqiBaX/3ck+fLytR861bjq49Zbb5UZM2b4TaDNnz9fbDabvP/++1XKNG/ePB3l9BANMz/nrXlozqGyWSDWKdA80YG/Z88eOXr0qNP+X84hahO4ViBNbiRDTlGpyhYXZ/WRuenkyZNyzTXX+E2gnTlzRk6ePCklJSXy3XffyZgxY3TahhdomAWAwsJCSUpKks8//9xj16za3LMH2j89PuI3duzY8iZn1ZrZJgmjtXxOpflioaGOQKtHDe3kyZNy/fXXy65du8q/ry83xrznnnuq7UOzB9rOnTsbt1BBRsMsQNhrGOnp6R6roVXtiM+U6Ohz8uijxR65vl3FPrTKIRpBgfyNFtIF5BgR8tNtM6xpFxUDLSWlXp9rrxGOG7dOoqNLnbKysTfGdNWHZj/nU0Rk69atcu7cObHZbD4P3kClYRZASktLJSkpyaPTNip34K9fb5PevXuXn07kKbt375aOHTvKvn37nEJ0PNYSpTyQddfOEBGRjenpUnLVVY7kKdvGpz7Wrj0nISHXCMyQittHe3vOmSv27YO2bdsmNptNPv74oIwaVSzx8QVywQUi8fHFEh5+jURGbvJp8AYqDbMA4415aJVrAm+8sVliY2M9HminT58WEZGffvpJNqdZnf3bWg92/KuNj5eSc+ckISFB7r3iCimxP17PmpmIvVl7UsB1oDX2FtL2GvbYsWkSHV0i8GeBQQL5ZWVKK2vuVw007VarmYZZACosLJTHHntMsrOzG3yt6uZ83XbbZunSpYvk5OR4oMQO+fn50ikuTj6Ijnb+0AqBlvfww/IrY+RekJLo6HqPaopUHHA4KfCwwDmPjtrWR3p6sTRrdqPA/QJFAne6CLQuAnk+Dd5Ao2EWwE6fPi1PPvlkvWtotc35WrMmT0pLS+X777/3XKELCmR327bSAeSDzp2tNLX3jVW45YE8CJLTwEEPT82n8ySrTLkClQPtjQply61SVt2RuGbVhZkeaBIAIiMj+de//sXtt99OUVGR2++vejaBQ04OvPVWS3766Sd++ctfkpaW5ta1qz2ANjWVy0+eZO1ll/HBpZdS/Pzz1pOhznvyt4yO5o2MDGx9+zJnzpx676s/bVr1C8tjYqzzTxqbtUg/Cvhb2U8bsBCYWuFVUVXepzsS15OrhPP2TWtm7rP3oY0ZM8btOVXOc77+KXCb2M8lqFgT2LzZvT60Gpcr2bfxmTnT+U32PfsHD3aaMJuXlye/+tWv5N57761yXmVd+dsxf7XVFqurKWufWc3QZmbgKywsLD9Z251Ac/5HVSgwSiCpPNAqNsE2b94s9957b63XrNx0jSRfJvChzGaOTI5Mkb1PLBR735gUFVlvKipyTMdw0dlvD7TJkyfX+btV5k9bSNd2qLGrINPRzNppmAWRtWvXypgxY+rch1b1H5U90B6qtiawf//+GtcUVgzI3myRH3E+iPdU83Yibdo4Au3xxx1BVsME2by8PFm1alV5uQN9Hpar2qL91qKFyMUX+0fwBhINsyBSn6VPVf9RFUpU1BF5+OECl9f4xz/+UWOT0950jaBAtnG+XAyyjB7yPDPla8pCq02bqqeN13Hp0ujRKyQsbLJAScDXXOy1xauvFrngAuunhlf9aZgFGXugzazcJ1UDV02wOXPmVBuKNfWh2Wtm9smwT9NJ4EKBfRJKkRyILgu0hQurbONTm40bRaKj8wR+JXBvlUDTEGjaNMyCUGFhoWRnZ8upU6fqPW2jtlreG29sln790qs09exN19lYHf3PM1PgHYE0iYkR+Wn849b/XvWY1e9owtoDba7Pp1ko/1FdmOnUjAAWHh7Oeeedx7x587j99ttJTy9yPU2ilmssWbKE0tJSVqxY4fTcjBkwe3Y//v73QWzYMI9ly9IYNcp63H4A7dFIa7/+YawhlLuIibmJ++8pptO3ZVM87Pv5u8Fx7kBLYBXOUxm8dO6ACnyuEs7bN62ZeVZhYaF06zZSQkOTnaZcuNPHZLPZRETkq6++ksLCwhp221gj7aPzZc9T1n5ke59YaHX2gxyIjrdqZHXo6K+JP06AVf6DampmxnqucfXu3Vu2bdvW6J8brDIyYOTIInJzb8OqxdxU/lxMDHz2GfTvX+3bndx6660UFxdTWvp/rFgRXuGZM4SzhVBGs4oSBnLO8VSbNtbP7GzHY3Fx1gf36VOv7zNqlOsamLvfRwUfY8x2Eeld+XFtZgaBV16B3Nxw4FOsIFsDWCsFcnLg5Zfrfq0PP/yQ0tJS/vGP28qvATmE052PGcdX5PNLzlEM0LIldO9uhVhoKCxcCHPmQEoKHDxYryADRxO28kz4mBjrcQ0y5YqGWRBw9DEZ4CfgNmA0FQOtrux9aFFRFwJWTSuCcD6kkF9zmlNAFrFc36wFp/PzITcXrrwSjh+H8HB46imYMME627IB5s+3amBJSVYfYFKSdX/+/AZdVgUxDbMg0Lp1xXudgRnAJuyB5u5av/DwcN5773Wio2OAuYzjQ27hNAuIYCbwSdgdzFtxmNbx8XDsGHTubL3xwIGGf5kK+veH1FRYt876qTUyVRMNsyBQdZH108As4Fuiowvqtch6wAC4995mtG22ltNMoQgYyTn+Djxoe4Oh5+2FoUOtF2/fbv2sx8ilUp6iYRYEXPcxPU10dCbjxxfy178+XK/dNl6dV8KP0XsJoYTbgFNh52NCmtFMbFY16b33rBcePWp1+Ccne+DbKFU/GmZBwlUf08qVrRk4cD0LFy4kKSnJ/UBLTaXVqeMs6dmTiTExnFecRcjF3cAYKCmBEyes17VrZ314A/vJlGqI0NpfogJF//6u+pVu5/vvv+eFF14gOTmZlStXYoyp2wXL+sDC/+u/GDtuHIwcCd9/73je3uH/2GMaZMrnNMyagKeffhpjDIcPH8YYY00wrEug2fvA1qyBuXOt6RZLlsCsWVbT8s9/hnvu8WrZlaornTTbhGRkwNSp8/n553XceGMqM2aEM2BADW84exa6drVGLOPjrQ7/tDTIzLT6yA4e1BqZanQ6abaJmzHDmlW/e3cx2dkbWbEiiZEji5gxo4Y3RUZafWFxcVaAvfiiI8i0j0z5GW1mNgEZGbBggX3y7BNAMfACubkzWLDgdcYkFtDveKpV0+rWzRqVtAdVnz7W46mpVh9a5eeV8hMaZk2A84EmghVoUcBAeuT8jcuHj4eSXMcbKq+rjIy0ZvUr5ce0mdkEOJY7ASwAxgJTGMYhCrmZCSW55aswCQ21+shGjrT6zJQKEBpmTYDzcqe7gVC60JtlJJGMtfDpVvvTNpsj0FJTG7mkStWfNjObgGnTYP16q6kZSTFPcAk7SeXPWAufmgFOiwdsNuunh9daKuVNGmZNgH25044/b+Wj/BG05zjFWNXy/cCdYWF0Ki6u+kZda6kCiDYzm4j5c8+ypvlI2nMcgDCsMc33gf7FxRwID3d+Q0yMrrVUAaVBYWaMucUYs9sYU2qMqTKJTfmR1FTCs49B+/YAlAI7gXBgJjCoqAh7o1KAnXN1HpkKLA2tmf0LGAPU4egM5VP2/q/e1t+c+4DdwFNAT+AWYCtWkA1nJQOf6l/zhFql/EyDwkxE9ojId54qjPIie//XoUMQF8eTgH3qWQGwCOgE3MTdrKEHOTnWRNtNm3xSWqXcpn1mwaygwNqPf+5cKCqyturZtQuio+neogXTgS+AI8DbhDOQ1qQTCwwCDrh9foBSvlTraKYx5gugvYunZovI8rp+kDHmAeABgM72bZaV92zdak18PXbM8VibNtatwjY+7UwkYySMszyPjUuAi4CuWIG2gZycixq12ErVV61hJiJDPPFBIvI28DZYu2Z44ppNWUaGtUzp9GlrUuy0aTh2wDh5EoYMsQ4b6dIFxoyxNtLPzLRqZwsXwuHD0K0bz32czJnPDmOF1wtYpzt1B84HWrt9foBSPuPqME13b8AGoHddX6+HADfM9OmVD+itcODvli1OT9pAfh0ZKYeXL3cczpuSUn4tx2G/+wQOCpSWXzMkpFDatBktH330g+++rFKVUM0hwA2dmpFsjDkM3ACsMsasaXC6qho574DhUJRTwNk3F1Lyq0GOJ/v2pVl8PBedPUvCmDEcsS8crzCz33F+QHesJub9WOs3obQ0nOzsoUyYMIjJk3U1gPJzrhLO2zetmdVfUlLFGplN4A9yNRvlZ9o5VdXOgvxf+/Yi+fki8fEyD6RHaKgUVaqZ2WVkiNx4o0hIyD6BCwXeqXC5P4oxXWXt2gIffGOlnOGNmplqfM47YEAI39CSwUSVzewvfx3w1NGj/OHiiyE8nCeAT202wuLiOJuYWOW6/fvD+edDaWl3YB3wP8DXZc9ORWQNf/xjJPn5+R7/Tkp5goZZgHHeAaMZs+nCxdgYCZyr8Ex7YD1w+dGj1sgmcGFoNOPOe4l2XW5g6dL/VLm2Iyi7A5nA1RWe7c6RI3vo2bMnB3QBuvJDGmYBpuKBvxGc5UleYgFwJyG8E/ZbJhqDfZ5rR2BEZCQLgWeJoJPtIEv3TiQvbxK33prAAw84B5pzULap8tkdOvTg8ccfZ9CgQRpoyu9omAWYigf+JpNKJIU0A0bQhn2Tn6bfQ6/yLIbyuS9nz9KL85lHLKf5S9mDsygtncx77z3pNMO/6snoDjExMH06TJ06lZkzZzJr1izvfUml6sNVR5q3bzoA0ED5+bLnqQ9lZ+zg8g7/QpCuIeFyb+goOUpbOQWyBeQtHpAICgQOC3QX+LBCx36hJCYelf/85z/ll65x2kcFxcXFcuLECTlw4EAjf3nV1FHNAICGWaDZskUkLs45bcpuO0DiQD4B2QxyPkg4ayu85IjAGae3XXrp29K9e3enQMvIsEZNExKsnxkZrouyePFi6dKli/zwg85DU42nujDTzRkDydmzjiVKvXrBoEHw2mtgsyFY3fWfA/cCmzHEMZ8sJgBLgf7ABVUu2aPH/Vx33UkGDhzIhg0b6NChQzUno1c1fvx4Tp06xaBBg1i3bh3ddDNH5UMaZoEkNdURZFu2QFgYjBsHAwZgyra6vhpIJ5pEVrKb/sCVwPdYYebM3g/Wv/8ThISEsH37djp06OBWkaZOnYoxhh07dtCtW7eal1kp5U2uqmvevmkzs57mzLHahjNnioiIzWazmofTpomArGWwjCelrI/MZUu0xn4wEZH33ntPDh8+XK/iJSYukqioH+r0OUrVFzppNgjYm3Fr1kBxMevXr+eGG27gwOefA/Bx5CQ+YgLnqH6H2GbNrCbkZ5/B/PlVnz969CgJCQn85z9V56HVJCMDNmzI48wZa/sgO90XTTUWDbNAkpxsHdCbmQl9+jAkLY0nSkpI2LuXA23b0va+5Bp3uYiJgUcesYKnuj6xWbNmMXnyZBISEjhy5Eidi/bKK3Du3FTKNuEGfix/TvdFU41B+8wCSWSkVaUaOdIKtMxMpgBERfHBmDG88FokI26xgiMnxzoxTsTqWnP0j9X+MbNmzaJjx45ERUXVuWiO1QNTgVjgPKfnKy+MV8rTNMwCTZ8+cPCgNRhw4AB068aU5GSIjGTLli107Hg+qakNH1WcOHEiBQUFjB49mjfffJOOHTvW+Hrn1QO3VHle90VT3qbNzEAUGQkTJsBTT1k/y05RyszMJCEhwWNLjVq0aMEvf/nLOvWh1WX1gFLepDWzIHL//fdjs9lISEhg/fr1Hpn3ZV+2NHToUHbu3ElYWJjL19mXWVXeay0mxnq8Ls1bpRrCWCOdjat3796ybdu2Rv/cpuLdd9/luuuu44orrvDYNfft28cvfvELCgoKaNGiRbWv27TJ0WfnTj+dUnVljNkuIlXO6dUwC1IiwmOPPcaDDz7osZn527dvZ8KECaxfv97tybVKeUp1YaZ9ZkHKGMMll1zi0T60a6+9lnvvvZeBAwe6NW1DqcagfWZBbMqUKQAkJCSwdetW2rVr1+BrPvHEEwDMnj2bhQsXNvh6SnmKNjObgE2bNnHjjTdaSz5CPFMZLy4uJisri3/8o5QPP+yoazFVo9FmZhPWv39/srKy6NWrl8eanGFhYdx110puvTWBZcv+w4YNsGwZjBoFM2Z45COUcouGWRMRGxvLlClTPNaHlpEBW7feT2npZCABsOah6VpM5SvaZ9aE2PvQxo8fz1dffYUxpt7XeuUV+3yyWVh/EzOxTh1wrMXUKRmqMWnNrImZMmUKaWlplJSU8OmnR0hOhoQEaw17Rkbdr+N85N3jwH85Pa9rMVVj05pZExQTE8PYsWmkpt6PyHrAmoe2fr01W9/V1kCVOa/FdPUZDS+nUu7QmlkDZWRQ79qNr2RkQHr6UESewOrvsvrQ3Onv0rWYyt9omDXAjBnW6N2yZQTUaJ6jv2sK8ASQUv5cXfceq3jkXUW6FlP5ijYz6ykjo+qianDUbpKS/PcftHN/15Qqz9e1v2v+fOt76lpM5Q80zOrJUbuxOwGcDxi/H83zZH9XXU9yUsrbtJlZT861G4DfANOIIJ8JpDAycy4sXmwdD+dntL9LBSMNs3qqWrtZQAvSmEg7PmQikw4+DXfcAV27wtatvihitbS/SwUjDbN6qly7iaA5O8hiHwV8Zi7j3+NnQny8dc7lyJF+V0ObP986TiApyRqJTUqq/sQmpQKBhlk9Va7dJJPKpZzgNRPPpt9+Q6fFL1g1Mnugpab6tsAu9O9vFWvdOuun1shUINMwa4CKtZshXa25Wm1uH8aLr5ZtLR0WBkOHWv/toQXeSinXNMwayF67mTTXmkXf6VvrgF7A+pmWZv23h3Z7VUq5plMzPKXSAb0MHWoFWWam9Xhysq9LqFRQ0zDzFBcH9AJWkH32WflxcEop79Aw8yQXB/RSdkCvUsq7NMw8zX5Ar1KqUTVoAMAY86IxZq8x5htjTKoxppaFMkop5R0NHc1cC/QUkauAfcCTDS+SUkq5r0FhJiJpImIru/sVcGHDi6SUUu7z5DyzScDnHryeRwTi5olKKffVOgBgjPkCaO/iqdkisrzsNbMBGxV3+at6nQeABwA6d+5cr8K6a8aMqnuOubM1tFIqcDT4EGBjzN1Y+98MFpGCurynMQ4Bzsiwdn11tdFgTIw19UvXIioVeLxyCLAxJhHrrLFRdQ2yxuK8eeIZrIqjpa5bQyulAkdD+8zeAKKAtcaYncaYP3mgTB7hvHniHOAOKgeaUip4NGjSrIhc4qmCeJrz5om/B5KxAi0FCNWj0JQKMkG7a4bz5okRQCpWc3Odbg2tVBAK2jCrujV0BLCSmJihDBuWwQ032Gp4t1Iq0ARtmIGrraFDWLFCyM//A3fccQe23FxISYG5/nv4iFKqbho8NaM+GmNqRk3OnTtH8qBBRO/YQUphoaPj0L5dT58+PiubUqpmXpmaEagiREj94QcuKCzkTM+eMNO/Dx9RStWuSYYZqalEHD/Oq7160eLLL8n/3e/8/vARpVTNmmaY2Q8XGTqU5q1a0bJlSz18RKkA1zTDzH64yBo9fESpYNE0d5rVw0eUCjpNM8z08BGlgk7TDDPQw0eUCjJNN8xADx9RKog0zQEApVTQ0TBTSgUFDTOlVFDQMFNKBQUNM6VUUNAwU0oFBQ0zpVRQ0DBTSgUFDTOlVFDQMFNKBQUNM6VUUNAwU0oFBQ0zpVRQ0DBTSgUFDTOlVFDQMFNKBQUNM6VUUNAwU0oFBQ0zpVRQ0DBTSgUFDTOlVFDQMFNKBQUNM6VUUNAwU0oFBQ0zpVRQ0DBTSgWFBoWZMWaOMeYbY8xOY0yaMaaDpwqmlFLuaGjN7EURuUpEegErgd95oExKKeW2BoWZiORWuNsSkIYVRyml6ie0oRcwxjwH3AXkAAkNLpFSStWDEam5MmWM+QJo7+Kp2SKyvMLrngQiROSZaq7zAPBA2d2ewL/qVWLfOx/I8nUh6imQyw6BXX4tu+d0EZHYyg/WGmZ1ZYzpAqwSkZ51eO02EentkQ9uZFp23wnk8mvZva+ho5ndK9wdBextWHGUUqp+Gtpn9rwx5lKgFDgE/KbhRVJKKfc1KMxEZGw93/p2Qz7Xx7TsvhPI5deye5nH+syUUsqXdDmTUioo+CzMAnkplDHmRWPM3rLypxpjWvu6THVljLnFGLPbGFNqjPH7ESoAY0yiMeY7Y8x+Y8wTvi6PO4wx7xpjjhtjAm4qkjGmkzFmvTFmT9n/M4/4ukw18WXNLJCXQq0FeorIVcA+4Ekfl8cd/wLGABm+LkhdGGOaAX8EhgOXA+ONMZf7tlRueQ9I9HUh6skGzBCRHsD1wIP+/Lv3WZgF8lIoEUkTEVvZ3a+AC31ZHneIyB4R+c7X5XBDX2C/iBwQkSLgY2C0j8tUZyKSAWT7uhz1ISI/i8iOsv8+A+wBOvq2VNVr8HKmhgiSpVCTgP/zdSGCWEfg3xXuHwau81FZmixjzEXA1cA/fVuS6nk1zGpbCiUis4HZZUuhHgJcLoXyhbos4zLGzMaqiqc0ZtlqU9claAHCuHgsYGrxwcAY0wpYCjxaqUXlV7waZiIypI4vXQyswo/CrLayG2PuBkYAg8XP5re48XsPBIeBThXuXwgc8VFZmhxjTBhWkKWIyKe+Lk9NfDmaGbBLoYwxicAsYJSIFPi6PEFuK9DdGNPVGBMO3A6s8HGZmgRjjAEWAHtE5GVfl6c2Pps0a4xZCjgthRKR//ikMG4yxuwHmgMnyx76SkQCYimXMSYZeB2IBU4DO0VkmG9LVTNjzH8BrwLNgHdF5DkfF6nOjDEfAQOxdp44BjwjIgt8Wqg6MsbcCGwCdmH9OwX4bxH5m+9KVT1dAaCUCgq6AkApFRQ0zJRSQUHDTCkVFDTMlFJBQcNMKRUUNMyUUkFBw0wpFRQ0zJRSQeH/A2v2A97LOadzAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "X_rec = recoverData(Z, U, K)\n", + "print('Approximation of the first example: [{:.6f} {:.6f}]'.format(X_rec[0, 0], X_rec[0, 1]))\n", + "print(' (this value should be about [-1.047419 -1.047419])')\n", + "\n", + "# Plot the normalized dataset (returned from featureNormalize)\n", + "fig, ax = pyplot.subplots(figsize=(5, 5))\n", + "ax.plot(X_norm[:, 0], X_norm[:, 1], 'bo', ms=8, mec='b', mew=0.5)\n", + "ax.set_aspect('equal')\n", + "ax.grid(False)\n", + "pyplot.axis([-3, 2.75, -3, 2.75])\n", + "\n", + "# Draw lines connecting the projected points to the original points\n", + "ax.plot(X_rec[:, 0], X_rec[:, 1], 'ro', mec='r', mew=2, mfc='none')\n", + "for xnorm, xrec in zip(X_norm, X_rec):\n", + " ax.plot([xnorm[0], xrec[0]], [xnorm[1], xrec[1]], '--k', lw=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grader[5] = recoverData\n", + "grader.grade()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.4 Face Image Dataset\n", + "\n", + "In this part of the exercise, you will run PCA on face images to see how it can be used in practice for dimension reduction. The dataset `ex7faces.mat` contains a dataset `X` of face images, each $32 \\times 32$ in grayscale. This dataset was based on a [cropped version](http://conradsanderson.id.au/lfwcrop/) of the [labeled faces in the wild](http://vis-www.cs.umass.edu/lfw/) dataset. Each row of `X` corresponds to one face image (a row vector of length 1024). \n", + "\n", + "The next cell will load and visualize the first 100 of these face images similar to what is shown in this figure:\n", + "\n", + "![Faces](Figures/faces.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Load Face dataset\n", + "data = loadmat(os.path.join('Data', 'ex7faces.mat'))\n", + "X = data['X']\n", + "\n", + "# Display the first 100 faces in the dataset\n", + "utils.displayData(X[:100, :], figsize=(8, 8))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.4.1 PCA on Faces\n", + "\n", + "To run PCA on the face dataset, we first normalize the dataset by subtracting the mean of each feature from the data matrix `X`. After running PCA, you will obtain the principal components of the dataset. Notice that each principal component in `U` (each column) is a vector of length $n$ (where for the face dataset, $n = 1024$). It turns out that we can visualize these principal components by reshaping each of them into a $32 \\times 32$ matrix that corresponds to the pixels in the original dataset. \n", + "\n", + "The following cell will first normalize the dataset for you and then run your PCA code. Then, the first 36 principal components (conveniently called eigenfaces) that describe the largest variations are displayed. If you want, you can also change the code to display more principal components to see how they capture more and more details." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# normalize X by subtracting the mean value from each feature\n", + "X_norm, mu, sigma = utils.featureNormalize(X)\n", + "\n", + "# Run PCA\n", + "U, S = pca(X_norm)\n", + "\n", + "# Visualize the top 36 eigenvectors found\n", + "utils.displayData(U[:, :36].T, figsize=(8, 8))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.4.2 Dimensionality Reduction\n", + "\n", + "Now that you have computed the principal components for the face dataset, you can use it to reduce the dimension of the face dataset. This allows you to use your learning algorithm with a smaller input size (e.g., 100 dimensions) instead of the original 1024 dimensions. This can help speed up your learning algorithm.\n", + "\n", + "The next cell will project the face dataset onto only the first 100 principal components. Concretely, each face image is now described by a vector $z^{(i)} \\in \\mathbb{R}^{100}$. To understand what is lost in the dimension reduction, you can recover the data using only the projected dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5000, 100) (100,)\n", + "The projected data Z has a shape of: (5000, 100)\n" + ] + } + ], + "source": [ + "# Project images to the eigen space using the top k eigenvectors \n", + "# If you are applying a machine learning algorithm \n", + "K = 100\n", + "Z = projectData(X_norm, U, K)\n", + "\n", + "print('The projected data Z has a shape of: ', Z.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the next cell, an approximate recovery of the data is performed and the original and projected face images\n", + "are displayed similar to what is shown here:\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "From the reconstruction, you can observe that the general structure and appearance of the face are kept while the fine details are lost. This is a remarkable reduction (more than 10x) in the dataset size that can help speed up your learning algorithm significantly. For example, if you were training a neural network to perform person recognition (given a face image, predict the identity of the person), you can use the dimension reduced input of only a 100 dimensions instead of the original pixels." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Project images to the eigen space using the top K eigen vectors and \n", + "# visualize only using those K dimensions\n", + "# Compare to the original input, which is also displayed\n", + "K = 100\n", + "X_rec = recoverData(Z, U, K)\n", + "\n", + "# Display normalized data\n", + "utils.displayData(X_norm[:100, :], figsize=(6, 6))\n", + "pyplot.gcf().suptitle('Original faces')\n", + "\n", + "# Display reconstructed data from only k eigenfaces\n", + "utils.displayData(X_rec[:100, :], figsize=(6, 6))\n", + "pyplot.gcf().suptitle('Recovered faces')\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.5 Optional (ungraded) exercise: PCA for visualization\n", + "\n", + "In the earlier K-means image compression exercise, you used the K-means algorithm in the 3-dimensional RGB space. We reduced each pixel of the RGB image to be represented by 16 clusters. In the next cell, we have provided code to visualize the final pixel assignments in this 3D space. Each data point is colored according to the cluster it has been assigned to. You can drag your mouse on the figure to rotate and inspect this data in 3 dimensions." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\DELL\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:47: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('