IIT Guwahati-Week 3-Linear Regression Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "M0YYLw6N_KCE"
   },
   "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": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Rqms0xsm_KCF"
   },
   "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": {
    "colab_type": "text",
    "id": "rbzq6tZr_KCJ"
   },
   "source": [
    "Complete the function to return an identity matrix of size 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8EfxnhE2_KCJ"
   },
   "outputs": [],
   "source": [
    "def warmUpExercise():\n",
    "    \"\"\"\n",
    "    Example function in Python which computes the identity matrix.\n",
    "    Do not hard code kindly use numpy\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": {
    "colab_type": "text",
    "id": "jDl4Msj9_KCM"
   },
   "source": [
    "Your output should match this\n",
    "\n",
    "[array([[ 1.,  0.,  0.,  0.,  0.],<br>\n",
    "       [ 0.,  1.,  0.,  0.,  0.],<br>\n",
    "       [ 0.,  0.,  1.,  0.,  0.],<br>\n",
    "       [ 0.,  0.,  0.,  1.,  0.],<br>\n",
    "       [ 0.,  0.,  0.,  0.,  1.]]))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gkqOdcLn_KCM"
   },
   "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": {
    "colab_type": "text",
    "id": "cidgOF0__KCP"
   },
   "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 `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": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lLkbuDrM_KCP"
   },
   "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "06sqjf8D_KCS"
   },
   "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",
    "<div class=\"alert alert-block alert-warning\">\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",
    "</div>\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": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mtBRxxhF_KCS"
   },
   "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",
    "    \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",
    "    # =============================================================\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9gBFxSv4_KCV"
   },
   "source": [
    "Now run the defined function with the loaded data to visualize the data. \n",
    "\n",
    "![](Figures/dataset1.png)\n",
    "\n",
    "Execute the next cell to visualize the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "y4HqF5zT_KCV"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x12e7c263518>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotData(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JNdFstlL_KCa"
   },
   "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": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vNUkRFE-_KCa"
   },
   "outputs": [],
   "source": [
    "# IF NEEDED YOU CAN UNCOMMENT THE BELOW LINE AND RUN TO LEARN MORE ABOUT THE FUNCTION\n",
    "?pyplot.plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kjXBs0ID_KCc"
   },
   "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",
    "#### 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",
    "<div class=\"alert alert-block alert-warning\">\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",
    "</div>\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": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "p9n9P0wW_KCd"
   },
   "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": {
    "colab_type": "text",
    "id": "4-KOAfJR_KCf"
   },
   "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": 22,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0CSB132b_KCf"
   },
   "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",
    "    # ====================== YOUR CODE HERE =====================\n",
    "    y_pred = np.dot(X,theta)\n",
    "    sqrd_error = np.sum(np.square(y_pred-y))\n",
    "    J = sqrd_error/(2*m)\n",
    "    \n",
    "    # ===========================================================\n",
    "    return J"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7tVbRXA4_KCi"
   },
   "source": [
    "Once you have completed the function, You can initialize $\\theta$ differently . You will see the cost printed to the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "E_CwU1Zp_KCi"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "With theta = [0, 0] \n",
      "Cost computed = 54.24\n"
     ]
    }
   ],
   "source": [
    "# YOU CAN CHANGE THE VALUE OF A,B FOR DIFFERENT INITIALIZATIONS OF THETA\n",
    "A = -1.0\n",
    "B = 2.0\n",
    "J = computeCost(X, y, theta=np.array([A, B]))\n",
    "print('With theta = [0, 0] \\nCost computed = %.2f' % J)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4ChnU_FD_KCl"
   },
   "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": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "904i3ztS_KCl"
   },
   "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",
    "        error = np.dot(X,theta)-y\n",
    "        temp0 = theta[0] - ((alpha/m) * np.sum(error*X[:,0]))\n",
    "        temp1 = theta[1] - ((alpha/m) * np.sum(error*X[:,1]))\n",
    "        theta = np.array([temp0,temp1])\n",
    "        # ==================== YOUR CODE HERE =================================\n",
    "        \n",
    "\n",
    "        # =====================================================================\n",
    "        \n",
    "        # save the cost J in every iteration\n",
    "        J_history.append(computeCost(X, y, theta))\n",
    "    \n",
    "    return theta, J_history"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VcqHtO8L_KCn"
   },
   "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": 29,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NfzadPye_KCo"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Theta found by gradient descent: -3.6303, 1.1664\n"
     ]
    }
   ],
   "source": [
    "# initialize fitting parameters\n",
    "# FEEL FREE TO CHANGE ANY PARAMETER\n",
    "A = 0.0\n",
    "B = 0.0\n",
    "theta = np.array([A,B]) \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))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "U9shyrD8_KCq"
   },
   "source": [
    "<h5>We will use your final parameters to plot the linear fit. The results should look like the following figure.</h5>\n",
    "<img src=\"https://i.ibb.co/FY8L2mn/graph-w3.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CDGtpQA4_KCq"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x12e7bc85d68>"
      ]
     },
     "metadata": {},
     "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": {
    "colab_type": "text",
    "id": "JmrCXl34_KCs"
   },
   "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": 31,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jcMSJyvI_KCs"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For population = 70000.0\n",
      "we predict a profit of 45342.45\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Now you can predict values for various population sizes.\n",
    "population_size = 70000\n",
    "population_size = population_size/10000\n",
    "\n",
    "predict1 = np.dot([1, population_size], theta)\n",
    "print('For population = ' + str(population_size*10000))\n",
    "print('we predict a profit of {:.2f}\\n'.format(predict1*10000))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "exercise1.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}