diff --git a/Phase 3 - 2020 (Summer)/Week 2 (Apr 5 - Apr 11)/Kishlay-190102041_Final.ipynb b/Phase 3 - 2020 (Summer)/Week 2 (Apr 5 - Apr 11)/Kishlay-190102041_Final.ipynb new file mode 100644 index 000000000..ee4e8f444 --- /dev/null +++ b/Phase 3 - 2020 (Summer)/Week 2 (Apr 5 - Apr 11)/Kishlay-190102041_Final.ipynb @@ -0,0 +1,1531 @@ +{ + "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": [], + "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", + "\n", + "# define the submission/grader object for this exercise\n", + "\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": 2, + "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": 3, + "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": 3, + "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": 4, + "metadata": {}, + "outputs": [], + "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": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "97\n" + ] + } + ], + "source": [ + "# Read comma separated data\n", + "data = np.loadtxt(os.path.join('ex1data1.txt'), delimiter=',')\n", + "X, y = data[:, 0], data[:, 1]\n", + "\n", + "m = y.size # number of training examples\n", + "print(m)\n", + "# print(y)" + ] + }, + { + "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": 6, + "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", + " 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": "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": 7, + "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": 8, + "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": "code", + "execution_count": 9, + "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": "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": 10, + "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", + "\n", + " Ttr=np.zeros((2,1))\n", + " Ttr[0,0]=theta[0]\n", + " Ttr[1,0]=theta[1]\n", + " tod=np.dot(X,Ttr)\n", + " sum=0\n", + " for i in range(0,m):\n", + " pred=tod[i]\n", + " sum += (pred-y[i])**2\n", + " \n", + " J=sum/(2*m)\n", + " \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": 11, + "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": [ + "# print(y)\n", + "J = computeCost(X, y, theta=np.array([0.0, 0.0]))\n", + "print('With theta = [0, 0] \\nCost computed = %.2f' % J)\n", + "print('Expected 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": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# grader[2] = c/omputeCost\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": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def Test1(T0,T1,X,y):\n", + " sum1=0\n", + " for i in range(0,y.size):\n", + " sum1 += (T0+T1*X[i,1]-y[i])\n", + " return float(sum1)\n", + "\n", + "def Test2(T0,T1,X,y):\n", + " sum2=0\n", + " for i in range(0,y.size):\n", + " sum2 += (T0+T1*X[i,1]-y[i])*X[i,1]\n", + " return float(sum2)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "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", + " Ttr=np.zeros((2,1))\n", + " Ttr[0,0]=theta[0]\n", + " Ttr[1,0]=theta[1]\n", + " tod=np.dot(X,Ttr)\n", + " \n", + " for i in range(num_iters):\n", + " # ==================== YOUR CODE HERE =================================\n", + " temp0=(theta[0]-(alpha/m)*Test1(theta[0],theta[1],X,y))\n", + " temp1=(theta[1]-(alpha/m)*Test2(theta[0],theta[1],X,y))\n", + " theta[0]=temp0\n", + " theta[1]=temp1\n", + " # =====================================================================\n", + " \n", + " # save the cost J in every iteration\n", + " J_history.append(computeCost(X, y, theta))\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": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Theta found by gradient descent: -3.6303, 1.1664\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 = 1500\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": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\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": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For population = 35,000, we predict a profit of 4519.77\n", + "\n", + "For population = 70,000, we predict a profit of 45342.45\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": 18, + "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": 19, + "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": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " X[:,0] X[:, 1] y\n", + "--------------------------\n", + " 2104 3 399900\n", + " 1600 3 329900\n", + " 2400 3 369000\n", + " 1416 2 232000\n", + " 3000 4 539900\n", + " 1985 4 299900\n", + " 1534 3 314900\n", + " 1427 3 198999\n", + " 1380 3 212000\n", + " 1494 3 242500\n" + ] + } + ], + "source": [ + "# Load data\n", + "data = np.loadtxt(os.path.join('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": 21, + "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", + " mu=np.mean(X,axis=0)\n", + " sigma=np.std(X-mu,axis=0)\n", + " X_norm=(X-mu)/sigma \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": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computed mean: [2000.68085106 3.17021277]\n", + "Computed standard deviation: [7.86202619e+02 7.52842809e-01]\n" + ] + } + ], + "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": 23, + "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": 24, + "metadata": {}, + "outputs": [], + "source": [ + "X = np.concatenate([np.ones((m, 1)), X_norm], axis=1)\n", + "# print(X)" + ] + }, + { + "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": 25, + "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", + " sum=0\n", + " # ======================= YOUR CODE HERE ===========================\n", + " Ttr=np.zeros((len(theta),1))\n", + " for i in range (0,len(theta)):\n", + " Ttr[i,0]=theta[i]\n", + " \n", + " tod=np.dot(X,Ttr)\n", + " sum=0\n", + " for i in range(0,m):\n", + " sum += (tod[i]-y[i])**2\n", + " \n", + " J=sum/(2*m)\n", + " # ==================================================================\n", + " return J" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# grader[5] = computeCostMulti\n", + "# grader.grade()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "def sum0(X,y,theta):\n", + " sum=0\n", + " for i in range (0,y.size):\n", + " sum += (theta[0]*X[i,0]+theta[1]*X[i,1]+theta[2]*X[i,2]-y[i])*X[i,0]\n", + " return sum\n", + "\n", + "def sum1(X,y,theta):\n", + " sum=0\n", + " for i in range (0,y.size):\n", + " sum += (theta[0]*X[i,0]+theta[1]*X[i,1]+theta[2]*X[i,2]-y[i])*X[i,1]\n", + " return sum\n", + "\n", + "def sum2(X,y,theta):\n", + " sum=0\n", + " for i in range (0,y.size):\n", + " sum += (theta[0]*X[i,0]+theta[1]*X[i,1]+theta[2]*X[i,2]-y[i])*X[i,2]\n", + " return sum" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "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", + " T0=theta[0]-alpha*((1/m)*sum0(X,y,theta))\n", + " T1=theta[1]-alpha*((1/m)*sum1(X,y,theta))\n", + " T2=theta[2]-alpha*((1/m)*sum2(X,y,theta))\n", + " theta[0]=T0\n", + " theta[1]=T1\n", + " theta[2]=T2\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": 29, + "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": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta computed from gradient descent: [340412.65957447 109447.75525931 -6578.31364383]\n", + "Predicted price of a 1650 sq-ft, 3 br house (using gradient descent): $293081\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "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.3\n", + "num_iters = 100\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 = theta[0]*1+theta[1]*(1650-2000.68085106)/786.202619+theta[2]*(3-3.17021277)/0.752842809\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": 31, + "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": 32, + "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", + " Part1=(np.linalg.inv(np.transpose(X).dot(X)))\n", + " Part2=(np.transpose(X).dot(y))\n", + " theta=Part1.dot(Part2)\n", + " \n", + " # =================================================================\n", + " return theta" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You should now submit your solutions.*" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "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": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Theta computed from the normal equations: [89597.9095428 139.21067402 -8738.01911233]\n", + "Predicted price of a 1650 sq-ft, 3 br house (using normal equations): $293081\n" + ] + } + ], + "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 = theta[0]+theta[1]*1650+theta[2]*3\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 +}