C1_W2_Multiple_Variable_Linear_Regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a317e492",
   "metadata": {},
   "source": [
    "## Multiple Vairable Linear Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b393e8ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing libraries\n",
    "import copy, math\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "np.set_printoptions(precision=2)  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38f35d73",
   "metadata": {},
   "source": [
    "## Goals: - \n",
    "    - Extend our regression model  routines to support multiple features\n",
    "    - Extend data structures to support multiple features\n",
    "    - Rewrite prediction, cost and gradient routines to support multiple features\n",
    "    - Utilize NumPy `np.dot` to vectorize their implementations for speed and simplicity"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "917c829f",
   "metadata": {},
   "source": [
    "# 2 Problem Statement\n",
    "\n",
    "You will use the motivating example of housing price prediction. The training dataset contains three examples with four features (size, bedrooms, floors and, age) shown in the table below.  Note that, unlike the earlier labs, size is in sqft rather than 1000 sqft. This causes an issue, which you will solve in the next lab!\n",
    "\n",
    "| Size (sqft) | Number of Bedrooms  | Number of floors | Age of  Home | Price (1000s dollars)  |   \n",
    "| ----------------| ------------------- |----------------- |--------------|-------------- |  \n",
    "| 2104            | 5                   | 1                | 45           | 460           |  \n",
    "| 1416            | 3                   | 2                | 40           | 232           |  \n",
    "| 852             | 2                   | 1                | 35           | 178           |  \n",
    "\n",
    "You will build a linear regression model using these values so you can then predict the price for other houses. For example, a house with 1200 sqft, 3 bedrooms, 1 floor, 40 years old.  \n",
    "\n",
    "Please run the following code cell to create your `X_train` and `y_train` variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "15a8f00e",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = np.array([[2104, 5, 1, 45], [1416, 3, 2, 40], [852, 2, 1, 35]])\n",
    "Y_train = np.array([460, 232, 178])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "419dd34c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train.shape = (3, 4), X_type = <class 'numpy.ndarray'>\n",
      "[[2104    5    1   45]\n",
      " [1416    3    2   40]\n",
      " [ 852    2    1   35]]\n",
      "Y_train.shape = (3,), Y_type = <class 'numpy.ndarray'>\n",
      "[460 232 178]\n"
     ]
    }
   ],
   "source": [
    "print(f\"X_train.shape = {X_train.shape}, X_type = {type(X_train)}\")\n",
    "print(X_train)\n",
    "print(f\"Y_train.shape = {Y_train.shape}, Y_type = {type(Y_train)}\")\n",
    "print(Y_train)  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc992abc",
   "metadata": {},
   "source": [
    "## Parameter vector w, b\n",
    "\n",
    "* $\\mathbf{w}$ is a vector with $n$ elements.\n",
    "  - Each element contains the parameter associated with one feature.\n",
    "  - in our dataset, n is 4.\n",
    "  - notionally, we draw this as a column vector\n",
    "\n",
    "$$\\mathbf{w} = \\begin{pmatrix}\n",
    "w_0 \\\\ \n",
    "w_1 \\\\\n",
    "\\cdots\\\\\n",
    "w_{n-1}\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "* $b$ is a scalar parameter.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "058491d7",
   "metadata": {},
   "source": [
    "For demonstration, $\\mathbf{w}$ and $b$ will be loaded with some initial selected values that are near the optimal. $\\mathbf{w}$ is a 1-D NumPy vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bb5de6f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w_init shape: (4,), b_init type: <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "b_init = 785.1811367994083\n",
    "w_init = np.array([ 0.39133535, 18.75376741, -53.36032453, -26.42131618])\n",
    "print(f\"w_init shape: {w_init.shape}, b_init type: {type(b_init)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "281be86f",
   "metadata": {},
   "source": [
    "### Model Prediction:- 1. Single Prediction Element by Element\n",
    "    $$ f_{\\mathbf{w},b}(\\mathbf{x}) =  w_0x_0 + w_1x_1 +... + w_{n-1}x_{n-1} + b \\tag{1}$$\n",
    "or in vector notation:\n",
    "$$ f_{\\mathbf{w},b}(\\mathbf{x}) = \\mathbf{w} \\cdot \\mathbf{x} + b  \\tag{2} $$ \n",
    "where $\\cdot$ is a vector `dot product`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "67f7c0ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_single_loop(x, w, b):\n",
    "    n = x.shape[0]\n",
    "    p = 0\n",
    "    for i in range(n):\n",
    "        p_i = x[i] * w[i]\n",
    "        p = p + p_i\n",
    "    p = p + b\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6eac4467",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_vec.shape : (4,), x_vec value : [2104    5    1   45]\n",
      "f_wb shape : (), prediciton : 459.9999976194083\n"
     ]
    }
   ],
   "source": [
    "# get a row from our training data\n",
    "x_vec = X_train[0,:]\n",
    "print(f\"x_vec.shape : {x_vec.shape}, x_vec value : {x_vec}\")\n",
    "\n",
    "# make a prediction\n",
    "f_wb = predict_single_loop(x_vec, w_init, b_init)\n",
    "print(f\"f_wb shape : {f_wb.shape}, prediciton : {f_wb}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40a941fd",
   "metadata": {},
   "source": [
    "### 2. Single Predicition Vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "768e1a0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(x,w,b):\n",
    "    p = np.dot(x, w) + b\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "47f867f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_vec shape (4,), x_vec value: [2104    5    1   45]\n",
      "f_wb shape (), prediction: 459.99999761940825\n"
     ]
    }
   ],
   "source": [
    "x_vec = X_train[0,:]\n",
    "print(f\"x_vec shape {x_vec.shape}, x_vec value: {x_vec}\")\n",
    "\n",
    "# make a prediction\n",
    "f_wb = predict(x_vec,w_init, b_init)\n",
    "print(f\"f_wb shape {f_wb.shape}, prediction: {f_wb}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0655242a",
   "metadata": {},
   "source": [
    "## Compute Cost with Multiple Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "76544e90",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(x, y, w, b):\n",
    "    n = x.shape[0]\n",
    "    cost = 0.0\n",
    "    for i in range(n):\n",
    "        f_wb_i = np.dot(x[i], w) + b\n",
    "        cost += (f_wb_i - y[i])**2\n",
    "    cost = cost / (2*n)\n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ec6d6a8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost at optimal w : 1.5578904880036537e-12\n"
     ]
    }
   ],
   "source": [
    "cost = compute_cost(X_train, Y_train, w_init, b_init)\n",
    "print(f'Cost at optimal w : {cost}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2af44ec2",
   "metadata": {},
   "source": [
    "### Gradient Descent With Multiple Variables\n",
    "Gradient descent for multiple variables:\n",
    "\n",
    "$$\\begin{align*} \\text{repeat}&\\text{ until convergence:} \\; \\lbrace \\newline\\;\n",
    "& w_j = w_j -  \\alpha \\frac{\\partial J(\\mathbf{w},b)}{\\partial w_j} \\tag{5}  \\; & \\text{for j = 0..n-1}\\newline\n",
    "&b\\ \\ = b -  \\alpha \\frac{\\partial J(\\mathbf{w},b)}{\\partial b}  \\newline \\rbrace\n",
    "\\end{align*}$$\n",
    "\n",
    "where, n is the number of features, parameters $w_j$,  $b$, are updated simultaneously and where  \n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "\\frac{\\partial J(\\mathbf{w},b)}{\\partial w_j}  &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - y^{(i)})x_{j}^{(i)} \\tag{6}  \\\\\n",
    "\\frac{\\partial J(\\mathbf{w},b)}{\\partial b}  &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - y^{(i)}) \\tag{7}\n",
    "\\end{align}\n",
    "$$\n",
    "* m is the number of training examples in the data set\n",
    "\n",
    "    \n",
    "*  $f_{\\mathbf{w},b}(\\mathbf{x}^{(i)})$ is the model's prediction, while $y^{(i)}$ is the target value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91e0b564",
   "metadata": {},
   "source": [
    "### Computing Gradient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b2445053",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_gradient(x, y, w, b):\n",
    "    m,n = x.shape\n",
    "    dj_dw = np.zeros((n,))\n",
    "    dj_db = 0\n",
    "    for i in range(m):\n",
    "        err = (np.dot(x[i], w) + b) - y[i]\n",
    "        for j in range(n):\n",
    "            dj_dw[j] = dj_dw[j] + err*x[i, j]\n",
    "        dj_db = dj_db + err\n",
    "    \n",
    "    dj_dw = dj_dw/m\n",
    "    dj_db = dj_db/m\n",
    "    \n",
    "    return dj_dw, dj_db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "fde6cec9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dj_db at initial w,b: -1.673925169143331e-06\n",
      "dj_dw at initial w,b: \n",
      " [-2.73e-03 -6.27e-06 -2.22e-06 -6.92e-05]\n"
     ]
    }
   ],
   "source": [
    "tmp_dj_dw, tmp_dj_db = compute_gradient(X_train, Y_train, w_init, b_init)\n",
    "print(f'dj_db at initial w,b: {tmp_dj_db}')\n",
    "print(f'dj_dw at initial w,b: \\n {tmp_dj_dw}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68d6c805",
   "metadata": {},
   "source": [
    "### Computing Gradient Descent with Mutiple Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c563fd30",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_descent(x, y, w_in, b_in, num_iters, alpha, compute_cost, compute_gradient):\n",
    "     # An array to store cost J and w's at each iteration primarily for graphing later\n",
    "    J_history = []\n",
    "    w = copy.deepcopy(w_in)  #avoid modifying global w within function\n",
    "    b = b_in\n",
    "    \n",
    "    for i in range(num_iters):\n",
    "        dj_dw, dj_db = compute_gradient(x, y, w, b)\n",
    "        \n",
    "        w = w - alpha * dj_dw\n",
    "        b = b - alpha * dj_db\n",
    "        \n",
    "        if i<100000:      # prevent resource exhaustion \n",
    "            J_history.append(compute_cost(x, y, w, b))\n",
    "\n",
    "        # Print cost every at intervals 10 times or as many iterations if < 10\n",
    "        if i% math.ceil(num_iters / 10) == 0:\n",
    "            print(f\"Iteration {i:4d}: Cost {J_history[-1]:8.2f}   \")\n",
    "        \n",
    "    return w, b, J_history #return final w,b and J history for graphing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5658ea36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration    0: Cost  2529.46   \n",
      "Iteration  100: Cost   695.99   \n",
      "Iteration  200: Cost   694.92   \n",
      "Iteration  300: Cost   693.86   \n",
      "Iteration  400: Cost   692.81   \n",
      "Iteration  500: Cost   691.77   \n",
      "Iteration  600: Cost   690.73   \n",
      "Iteration  700: Cost   689.71   \n",
      "Iteration  800: Cost   688.70   \n",
      "Iteration  900: Cost   687.69   \n",
      "b,w found by gradient descent: -0.00, [ 0.2   0.   -0.01 -0.07] \n",
      "prediction: 426.19, target value: 460\n",
      "prediction: 286.17, target value: 232\n",
      "prediction: 171.47, target value: 178\n"
     ]
    }
   ],
   "source": [
    "w_in = np.zeros_like(w_init)\n",
    "b_in = 0\n",
    "\n",
    "iteration = 1000\n",
    "alpha = 5.0e-7\n",
    "w_final, b_final, J_hist = gradient_descent(X_train, Y_train, w_in, b_in, iteration, alpha, compute_cost, compute_gradient)\n",
    "print(f\"b,w found by gradient descent: {b_final:0.2f}, {w_final} \")\n",
    "m,_ = X_train.shape\n",
    "for i in range(m):\n",
    "    print(f\"prediction: {np.dot(X_train[i], w_final) + b_final:0.2f}, target value: {Y_train[i]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c864957b",
   "metadata": {},
   "source": [
    "### plot Cost VS Iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "df28c7da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, (ax1, ax2) = plt.subplots(1,2, constrained_layout = True, figsize = (12, 4))\n",
    "ax1.plot(J_hist)\n",
    "\n",
    "ax2.plot(100 + np.arange(len(J_hist[100:])), J_hist[100:])\n",
    "ax1.set_title(\"Cost vs. iteration\");  ax2.set_title(\"Cost vs. iteration (tail)\")\n",
    "ax1.set_ylabel('Cost')             ;  ax2.set_ylabel('Cost') \n",
    "ax1.set_xlabel('iteration step')   ;  ax2.set_xlabel('iteration step') \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7239c31b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}