Task1.ipynb

{
 "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.\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "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",
    "# tells matplotlib to embed plots within the notebook\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "**Required Exercises**\n",
    "\n",
    "| Section | Part                                           | Function                    \n",
    "|---------|:-                                              |:-                                         \n",
    "| 1       | [Warm up exercise](#section1)                  | [`warmUpExercise`](#warmUpExercise)      \n",
    "| 2       | [Compute cost for one variable](#section2)     | [`computeCost`](#computeCost)           \n",
    "| 3       | [Gradient descent for one variable](#section3) | [`gradientDescent`](#gradientDescent)     \n",
    "\n",
    "**Optional Exercises**\n",
    "\n",
    "| Section | Part                                                 | Function \n",
    "|:-------:|:-                                                    |:-                 \n",
    "| 4       | [Feature normalization](#section4)                   | [`featureNormalize`](#featureNormalize)      \n",
    "| 5       | [Compute cost for multiple variables](#section5)     | [`computeCostMulti`](#computeCostMulti)      \n",
    "| 6       | [Gradient descent for multiple variables](#section5) | [`gradientDescentMulti`](#gradientDescentMulti) \n",
    "| 7       | [Normal Equations](#section7)                        | [`normalEqn`](#normalEqn)         \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. \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": [
    "<a id=\"section1\"></a>\n",
    "## 1 Simple python and `numpy` function\n",
    "\n",
    "The first part of this assignment gives you practice with python and `numpy` syntax. 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",
    "<a id=\"warmUpExercise\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "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",
    "    return A\n",
    "\n",
    "#B=warmUpExercise()\n",
    "#print(B)"
   ]
  },
  {
   "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": 56,
   "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": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "warmUpExercise()"
   ]
  },
  {
   "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": 57,
   "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",
    "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",
    "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": 58,
   "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(figsize=(16.18,10.00))  # open a new figure\n",
    "    \n",
    "    # ====================== YOUR CODE HERE ======================= \n",
    "    \n",
    "    pyplot.plot(x, y, 'ko', ms=10, mec='k')\n",
    "    pyplot.ylabel('Profit in $10,000')\n",
    "    pyplot.xlabel('Population of City in 10,000s')\n",
    "    \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": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1164.96x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotData(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section2\"></a>\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",
    "\n",
    "#### 2.2.1 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": 60,
   "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",
    "\n",
    "# Assert raises an exception if the cell is run again without initializing X.\n",
    "assert X.shape == (97,), \"X already contains a stack ones.\"\n",
    "\n",
    "X = np.stack([np.ones(m), X], axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section2\"></a>\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",
    "<a id=\"computeCost\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "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",
    "    cost = (1/(2*m))*((y-np.dot(theta,X.transpose()))**2)\n",
    "    for i in range(97):\n",
    "        J+=cost[i]\n",
    "    \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": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 97)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta=np.array([0.0, 0.0, 0.0])\n",
    "theta.transpose().shape\n",
    "X.transpose().shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "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",
      "\n",
      "Great work! You may proceed.\n"
     ]
    }
   ],
   "source": [
    "J1 = computeCost(X, y, theta=np.array([0.0, 0.0]))\n",
    "print('With theta = [0, 0] \\nCost computed = %.2f' % J1)\n",
    "print('Expected cost value (approximately) 32.07\\n')\n",
    "\n",
    "# further testing of the cost function\n",
    "J2 = computeCost(X, y, theta=np.array([-1, 2]))\n",
    "print('With theta = [-1, 2]\\nCost computed = %.2f' % J2)\n",
    "print('Expected cost value (approximately) 54.24\\n')\n",
    "\n",
    "limit1 = 1.2\n",
    "est_Error1 = abs(J1 - 32) + abs(J2 - 54)\n",
    "\n",
    "if(est_Error1 <= limit1) : \n",
    "    print(\"Great work! You may proceed.\")\n",
    "else :\n",
    "    print(\"You may want to check your implementation.\")\n",
    "    print(\"[Estimated error : %.2f]\" % est_Error1)\n",
    "    assert False, \"******* Results don't match. *******\"\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section3\"></a>\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",
    "<div class=\"alert alert-box alert-warning\">\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",
    "<div>\n",
    "<a id=\"gradientDescent\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-64-d3f07f9c3c5e>, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-64-d3f07f9c3c5e>\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m    .shape[0]\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "x=np.array([1,2,3])\n",
    "z=np.array([[1,2,3],[1,2,3]])\n",
    "#y=np.dot(x,z.transpose())\n",
    ".shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "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",
    "    \n",
    "    for i in range(num_iters):\n",
    "        # ==================== YOUR CODE HERE =================================\n",
    "        h= np.dot(X,theta)\n",
    "        temp= theta- alpha*(np.dot((h-y),X))/m\n",
    "        theta=temp\n",
    "    \n",
    "        \n",
    "        # =====================================================================\n",
    "        \n",
    "        # save the cost J in every iteration\n",
    "        J_history.append(computeCost(X, y, theta))\n",
    "    \n",
    "    print(\"----------------------------------------------------\\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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------\n",
      "\n",
      "Theta found by gradient descent: -3.8958, 1.1930\n",
      "Expected theta values (approximately): [-3.6303, 1.1664]\n"
     ]
    }
   ],
   "source": [
    "# Initialize fitting parameters\n",
    "theta = np.zeros(2)\n",
    "\n",
    "# Model hyperparameters. \n",
    "# # ==================== YOUR CODE HERE =================================\n",
    "# Feel free to change these if they don't seem to working.\n",
    "\n",
    "alpha = 0.003\n",
    "iterations = 150000\n",
    "\n",
    "# QUESTION : What is the largest 'alpha' and smallest 'iterations' you can get away with ?\n",
    "\n",
    "# =====================================================================\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": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Theta found by gradient descent: -3.8958, 1.1930\n"
     ]
    }
   ],
   "source": [
    "print('Theta found by gradient descent: {:.4f}, {:.4f}'.format(*theta))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Great work! Proceed to the Optional Exercises.\n"
     ]
    }
   ],
   "source": [
    "# Validate:\n",
    "\n",
    "limit2 = 1\n",
    "est_Error2 = abs(theta[0] + 3.6303) + abs(theta[1] - 1.664)\n",
    "\n",
    "if(est_Error2 <= limit2) : \n",
    "    print(\"Great work! Proceed to the Optional Exercises.\")\n",
    "else :\n",
    "    print(\"You may want to check your implementation.\")\n",
    "    print(\"[Estimated error : %.2f]\" % est_Error2)\n",
    "    assert False, \"******* Results don't match. *******\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the linear fit\n",
    "pyplot.plot(X[:, 1], y,'.')\n",
    "pyplot.plot(X[:, 1], np.dot(X, [-3.6303, 1.1664]), '-', c='m', linewidth=.5)\n",
    "pyplot.plot(X[:, 1], np.dot(X, theta), '--', c='green', linewidth=.5)\n",
    "pyplot.legend(['Training data', 'Optimal Value', 'Your Output']);\n",
    "\n",
    "# You can try adding futher details to your graph.\n",
    "# After that, do post your final graph on the group! \n",
    "# Save it as a .png file [you can use inbuilt pyplot functions].\n",
    "# Also try adding grid lines and other stuff!"
   ]
  },
  {
   "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": "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",
    "<div class=\"alert alert-block alert-success\">\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",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\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",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.476971375975181"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#d= np.arange(-10,10,.2);\n",
    "J_history[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For population = 35,000, we predict a profit of 2798.37\n",
      "\n",
      "For population = 70,000, we predict a profit of 44554.55\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": [
    "### 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": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "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(-1, 3, 20))\n",
    "pyplot.xlabel('theta0')\n",
    "pyplot.ylabel('theta1')\n",
    "pyplot.plot(theta[0], theta[1], 'ro', ms=10)#, lw=1)\n",
    "pyplot.title('Contour, showing minimum')\n",
    "pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100,)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta0_vals = np.linspace(-10, 10, 100)\n",
    "theta1_vals = np.linspace(-1, 4, 100)\n",
    "theta1_vals.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# This import registers the 3D projection, but is otherwise unused.\n",
    "from mpl_toolkits.mplot3d import Axes3D  # noqa: F401 unused import\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "from matplotlib.ticker import LinearLocator, FormatStrFormatter\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d')\n",
    "\n",
    "# Make data.\n",
    "X = np.arange(-5, 5, 0.25)\n",
    "Y = np.arange(-5, 5, 0.25)\n",
    "X, Y = np.meshgrid(X, Y)\n",
    "R = np.sqrt(X**2 + Y**2)\n",
    "Z = np.sin(R)\n",
    "\n",
    "# Plot the surface.\n",
    "surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm,\n",
    "                       linewidth=0, antialiased=False)\n",
    "\n",
    "# Customize the z axis.\n",
    "ax.set_zlim(-1.01, 1.01)\n",
    "ax.zaxis.set_major_locator(LinearLocator(10))\n",
    "ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))\n",
    "\n",
    "# Add a color bar which maps values to colors.\n",
    "fig.colorbar(surf, shrink=0.5, aspect=5)\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "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. \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",
    "<a id=\"section4\"></a>\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": []
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "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('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",
    "<div class=\"alert alert-block alert-warning\">\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",
    "</div>\n",
    "<a id=\"featureNormalize\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 328,
   "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",
    "    mu=np.mean(X)\n",
    "    sigma=np.std(X)\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": 329,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1001.9255319148937"
      ]
     },
     "execution_count": 329,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mu=np.mean(X)\n",
    "mu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computed mean: 1001.9255319148937\n",
      "Computed standard deviation: 1143.0528202028345\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": [
    "After the `featureNormalize` function is tested, we now add the intercept term to `X_norm`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add intercept term to X\n",
    "X = np.concatenate([np.ones((m, 1)), X_norm], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.000e+00, 2.104e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.600e+03, 3.000e+00],\n",
       "       [1.000e+00, 2.400e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.416e+03, 2.000e+00],\n",
       "       [1.000e+00, 3.000e+03, 4.000e+00],\n",
       "       [1.000e+00, 1.985e+03, 4.000e+00],\n",
       "       [1.000e+00, 1.534e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.427e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.380e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.494e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.940e+03, 4.000e+00],\n",
       "       [1.000e+00, 2.000e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.890e+03, 3.000e+00],\n",
       "       [1.000e+00, 4.478e+03, 5.000e+00],\n",
       "       [1.000e+00, 1.268e+03, 3.000e+00],\n",
       "       [1.000e+00, 2.300e+03, 4.000e+00],\n",
       "       [1.000e+00, 1.320e+03, 2.000e+00],\n",
       "       [1.000e+00, 1.236e+03, 3.000e+00],\n",
       "       [1.000e+00, 2.609e+03, 4.000e+00],\n",
       "       [1.000e+00, 3.031e+03, 4.000e+00],\n",
       "       [1.000e+00, 1.767e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.888e+03, 2.000e+00],\n",
       "       [1.000e+00, 1.604e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.962e+03, 4.000e+00],\n",
       "       [1.000e+00, 3.890e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.100e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.458e+03, 3.000e+00],\n",
       "       [1.000e+00, 2.526e+03, 3.000e+00],\n",
       "       [1.000e+00, 2.200e+03, 3.000e+00],\n",
       "       [1.000e+00, 2.637e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.839e+03, 2.000e+00],\n",
       "       [1.000e+00, 1.000e+03, 1.000e+00],\n",
       "       [1.000e+00, 2.040e+03, 4.000e+00],\n",
       "       [1.000e+00, 3.137e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.811e+03, 4.000e+00],\n",
       "       [1.000e+00, 1.437e+03, 3.000e+00],\n",
       "       [1.000e+00, 1.239e+03, 3.000e+00],\n",
       "       [1.000e+00, 2.132e+03, 4.000e+00],\n",
       "       [1.000e+00, 4.215e+03, 4.000e+00],\n",
       "       [1.000e+00, 2.162e+03, 4.000e+00],\n",
       "       [1.000e+00, 1.664e+03, 2.000e+00],\n",
       "       [1.000e+00, 2.238e+03, 3.000e+00],\n",
       "       [1.000e+00, 2.567e+03, 4.000e+00],\n",
       "       [1.000e+00, 1.200e+03, 3.000e+00],\n",
       "       [1.000e+00, 8.520e+02, 2.000e+00],\n",
       "       [1.000e+00, 1.852e+03, 4.000e+00],\n",
       "       [1.000e+00, 1.203e+03, 3.000e+00]])"
      ]
     },
     "execution_count": 332,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section5\"></a>\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",
    "<div class=\"alert alert-block alert-warning\">\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",
    "</div>\n",
    "\n",
    "<a id=\"computeCostMulti\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00,\n",
       "        1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00,\n",
       "        1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00,\n",
       "        1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00,\n",
       "        1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00,\n",
       "        1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00,\n",
       "        1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00,\n",
       "        1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00, 1.000e+00],\n",
       "       [2.104e+03, 1.600e+03, 2.400e+03, 1.416e+03, 3.000e+03, 1.985e+03,\n",
       "        1.534e+03, 1.427e+03, 1.380e+03, 1.494e+03, 1.940e+03, 2.000e+03,\n",
       "        1.890e+03, 4.478e+03, 1.268e+03, 2.300e+03, 1.320e+03, 1.236e+03,\n",
       "        2.609e+03, 3.031e+03, 1.767e+03, 1.888e+03, 1.604e+03, 1.962e+03,\n",
       "        3.890e+03, 1.100e+03, 1.458e+03, 2.526e+03, 2.200e+03, 2.637e+03,\n",
       "        1.839e+03, 1.000e+03, 2.040e+03, 3.137e+03, 1.811e+03, 1.437e+03,\n",
       "        1.239e+03, 2.132e+03, 4.215e+03, 2.162e+03, 1.664e+03, 2.238e+03,\n",
       "        2.567e+03, 1.200e+03, 8.520e+02, 1.852e+03, 1.203e+03],\n",
       "       [3.000e+00, 3.000e+00, 3.000e+00, 2.000e+00, 4.000e+00, 4.000e+00,\n",
       "        3.000e+00, 3.000e+00, 3.000e+00, 3.000e+00, 4.000e+00, 3.000e+00,\n",
       "        3.000e+00, 5.000e+00, 3.000e+00, 4.000e+00, 2.000e+00, 3.000e+00,\n",
       "        4.000e+00, 4.000e+00, 3.000e+00, 2.000e+00, 3.000e+00, 4.000e+00,\n",
       "        3.000e+00, 3.000e+00, 3.000e+00, 3.000e+00, 3.000e+00, 3.000e+00,\n",
       "        2.000e+00, 1.000e+00, 4.000e+00, 3.000e+00, 4.000e+00, 3.000e+00,\n",
       "        3.000e+00, 4.000e+00, 4.000e+00, 4.000e+00, 2.000e+00, 3.000e+00,\n",
       "        4.000e+00, 3.000e+00, 2.000e+00, 4.000e+00, 3.000e+00]])"
      ]
     },
     "execution_count": 333,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "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",
    "    h=np.dot(theta,X.T)\n",
    "    cost= (1/(2*m))*((y-h)**2)\n",
    "    for i in range(m):\n",
    "        J+=cost[i]\n",
    "    # ==================================================================\n",
    "    return J\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "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",
    "        h=np.dot(theta,X.T)\n",
    "        # ======================= YOUR CODE HERE ==========================\n",
    "        temp= theta - (alpha/m)*(np.dot((h-y),X))\n",
    "        theta=temp\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": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.00000000e+00,  1.31415422e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -5.09640698e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00,  5.07908699e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -7.43677059e-01, -2.21098897e+00],\n",
       "       [ 1.00000000e+00,  1.27107075e+00, -2.10988971e-01],\n",
       "       [ 1.00000000e+00, -1.99450507e-02, -2.10988971e-01],\n",
       "       [ 1.00000000e+00, -5.93588523e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -7.29685755e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -7.89466782e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -6.44465993e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -7.71822042e-02, -2.10988971e-01],\n",
       "       [ 1.00000000e+00, -8.65999486e-04, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -1.40779041e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00,  3.15099326e+00,  7.89011029e-01],\n",
       "       [ 1.00000000e+00, -9.31923697e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00,  3.80715024e-01, -2.10988971e-01],\n",
       "       [ 1.00000000e+00, -8.65782986e-01, -2.21098897e+00],\n",
       "       [ 1.00000000e+00, -9.72625673e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00,  7.73743478e-01, -2.10988971e-01],\n",
       "       [ 1.00000000e+00,  1.31050078e+00, -2.10988971e-01],\n",
       "       [ 1.00000000e+00, -2.97227261e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -1.43322915e-01, -2.21098897e+00],\n",
       "       [ 1.00000000e+00, -5.04552951e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -4.91995958e-02, -2.10988971e-01],\n",
       "       [ 1.00000000e+00,  2.40309445e+00, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -1.14560907e+00, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -6.90255715e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00,  6.68172729e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00,  2.53521350e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00,  8.09357707e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -2.05647815e-01, -2.21098897e+00],\n",
       "       [ 1.00000000e+00, -1.27280274e+00, -3.21098897e+00],\n",
       "       [ 1.00000000e+00,  5.00114703e-02, -2.10988971e-01],\n",
       "       [ 1.00000000e+00,  1.44532608e+00, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -2.41262044e-01, -2.10988971e-01],\n",
       "       [ 1.00000000e+00, -7.16966387e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -9.68809863e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00,  1.67029651e-01, -2.10988971e-01],\n",
       "       [ 1.00000000e+00,  2.81647389e+00, -2.10988971e-01],\n",
       "       [ 1.00000000e+00,  2.05187753e-01, -2.10988971e-01],\n",
       "       [ 1.00000000e+00, -4.28236746e-01, -2.21098897e+00],\n",
       "       [ 1.00000000e+00,  3.01854946e-01, -1.21098897e+00],\n",
       "       [ 1.00000000e+00,  7.20322135e-01, -2.10988971e-01],\n",
       "       [ 1.00000000e+00, -1.01841540e+00, -1.21098897e+00],\n",
       "       [ 1.00000000e+00, -1.46104938e+00, -2.21098897e+00],\n",
       "       [ 1.00000000e+00, -1.89112638e-01, -2.10988971e-01],\n",
       "       [ 1.00000000e+00, -1.01459959e+00, -1.21098897e+00]])"
      ]
     },
     "execution_count": 336,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mu1=np.mean(X[:,1])\n",
    "mu2=np.mean(X[:,2])\n",
    "std1=np.std(X[:,1])\n",
    "std2=np.std(X[:,2])\n",
    "X[:,1]=(X[:,1]-mu1)/std1\n",
    "X\n",
    "X[:,2]=((X[:,2]-mu2/std2))\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.1 Optional 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",
    "<div class=\"alert alert-block alert-warning\">\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",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\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",
    "</div>\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",
    "8use 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": 340,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "theta computed from gradient descent: [331318.33720194 109447.79646966  -8738.01911236]\n",
      "Theta found by gradient descent: 331318.33720194, 109447.79646966, -8738.01911236\n",
      "Predicted price of a 1650 sq-ft, 3 br house (using gradient descent): $284475\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\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 = .4\n",
    "num_iters = 450\n",
    "\n",
    "\n",
    "# init theta and run gradient descent\n",
    "theta = np.array([1,-2,.5])\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=1)\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",
    "print('Theta found by gradient descent: {:.8f}, {:.8f}, {:.8f}'.format(*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",
    "feature= np.array([1,(1650-mu1)/std1,(3-mu2)/std2])# You should change this\n",
    "price=np.dot(feature,theta)\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": [
    "<a id=\"section7\"></a>\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": 322,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.3815423416850708e+18\n"
     ]
    }
   ],
   "source": [
    "print(min(J_history))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "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",
    "<a id=\"normalEqn\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "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",
    "    theta = np.dot((np.dot(np.linalg.pinv(np.dot(X,X.T)),X)).T,y)\n",
    "    \n",
    "    # =================================================================\n",
    "    return theta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(47, 47)"
      ]
     },
     "execution_count": 325,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(X,X.T).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Optional: 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": 326,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Theta computed from the normal equations: [ 1.  -2.   0.5]\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",
    "theta2 = 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",
    "feature2=np.array([1,1650,3])# You should change this\n",
    "price1=np.dot(feature2,theta2)\n",
    "# ============================================================\n",
    "\n",
    "print('Predicted price of a 1650 sq-ft, 3 br house (using normal equations): ${:.0f}'.format(price1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}