HW_regression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using grader version: 1.1\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "import grader\n",
    "%matplotlib inline  \n",
    "matplotlib.rcParams.update({'font.size': 16})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1: Linear Regression\n",
    "\n",
    "In this notebook we will generate data from a linear function:  $\\textbf{y}=\\textbf{X}\\beta+\\epsilon$ and then solve for $\\hat\\beta$ using OLS (ordinary least squares) and gradient descent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 1.1 : Generate data: $\\textbf{y}=\\textbf{X}\\beta+\\epsilon$\n",
    "Here we assume $y\\approx g(X,\\beta)=\\textbf{X}\\beta+\\epsilon$ where $g$ is linear in $\\beta$ with additive noise $\\epsilon$\n",
    "\n",
    "Your function should have the following properties:\n",
    "* output `y` as an np.array with shape (`M`,`1`)\n",
    "* `generate_linear_y` should work for any arbitrary `x`, `b`, and `eps`, as long as they are the appropriate dimensions\n",
    "* do not use for-loops to calculate each `y[i]` separately, as this will be very slow for large `M` and `N`.  Instead, you should leverage [numpy linear algebra](https://docs.scipy.org/doc/numpy/reference/generated/numpy.dot.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_linear_y(X,b):\n",
    "    y = np.dot (X , b)\n",
    "    \"\"\" Write a function that generates m data points from inputs X and b\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    X :   numpy.ndarray\n",
    "          x.shape must be (M,N)\n",
    "          Each row of `X` is a single data point of dimension N\n",
    "          Therefore `X` represents M data points\n",
    "        \n",
    "    b :   numpy.ndarray\n",
    "          b.shape must be (N,1)\n",
    "          Each element of `b` is a value of beta such that b=[[b1][b2]...[bN]]\n",
    "\n",
    "          \n",
    "    Returns\n",
    "    -------\n",
    "    y :   numpy.ndarray\n",
    "          y.shape = (M,1)\n",
    "          y[i] = X[i]b\n",
    "    \"\"\"\n",
    "    \n",
    "    # STUDENT CODE GOES HERE\n",
    "    \n",
    "    y = np.dot (X, b)\n",
    "    return (y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============================== ALL TESTS PASSED! ===============================\n",
      "Your submission code: bw31e37d936439ee86e5496116c51ebf72018be157ed61a638dd510046\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "# execute this cell to grade your work\n",
    "\n",
    "from grader import test_lineary\n",
    "test_lineary(generate_linear_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 1.2: Perform OLS Regression: $\\hat\\beta=(\\textbf{X}^T\\textbf{X})^{-1}\\textbf{X}^T\\textbf{y}$\n",
    "Now that we can generate noisy data from a linear system, let's estimate the values of $\\beta$ from data.\n",
    "\n",
    "Your function should have the following properties:\n",
    "* output `b` as an np.array with shape (`N`,`1`)\n",
    "* `regression_ols` should work for any arbitrary `X` and `y`, as long as they are the appropriate dimensions\n",
    "* if `X` is not full column rank, you should return `None`\n",
    "* leverage numpy linear algebra (e.g., [transpose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.transpose.html), [inverse](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.inv.html), [pseudo-inverse](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.pinv.html))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def regression_ols(X, y):\n",
    "    xtrans_product = np.dot(np.transpose(X), X)\n",
    "    xpseudo_inverse = np.linalg.inv(xtrans_product)\n",
    "    xtot_product = np.dot(xpseudo_inverse , np.transpose(X))\n",
    "    \n",
    "    b = np.dot(xtot_product , y)\n",
    "    return b\n",
    "    \n",
    "    \"\"\" Write a function that performs ordinary least squares\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    X :   numpy.ndarray\n",
    "          X.shape must be (M,N)\n",
    "          Each row of `X` is a single data point of dimension N\n",
    "          Therefore `X` represents M data points\n",
    "        \n",
    "    y :   numpy.ndarray\n",
    "          y.shape must be (M,1)\n",
    "          Each element of `y` is an output value such that y[i] ~ X[i]b\n",
    "          \n",
    "    Returns\n",
    "    -------\n",
    "    b :   numpy.ndarray\n",
    "          b.shape = (N,1)\n",
    "    \"\"\"\n",
    "    \n",
    "    # STUDENT CODE GOES HERE\n",
    "    xtrans_product = np.dot(np.transpose(X), X)\n",
    "    xpseudo_inverse = np.linalg.inv(xtrans_product)\n",
    "    xtot_product = np.dot(xpseudo_inverse , np.transpose(X))\n",
    "    \n",
    "    b = np.dot(xtot_product , y)\n",
    "    return b\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============================== ALL TESTS PASSED! ===============================\n",
      "Your submission code: bwe728dd7af2af2aeff04eab62c34f4f0e09cfadb521b92d0536908c46\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "# execute this cell to grade your work\n",
    "\n",
    "from grader import test_ols\n",
    "test_ols(regression_ols)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2: Gradient Descent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 2.1: Polynomial Function (1-D)\n",
    "\n",
    "Write a function, `poly` that computes $f(x)=C_0+C_1\\;x+C_2\\;x^2+...C_n\\;x^n$, evaluated at some specified value for $x$.\n",
    "\n",
    "That is, if we want to compute $f(x) = 0\\cdot x^0 + 2\\cdot x^1 + 4\\cdot x^2$, evaluated at $x=2$:\n",
    "\n",
    "$$\n",
    "f(x=2) = 0\\cdot 2 + 2\\cdot 2^1 + 4\\cdot 2^2 = 20\n",
    "$$\n",
    "\n",
    "Your function `poly` should behave as follows:\n",
    "\n",
    "        >>> poly([0, 2, 4], 2)\n",
    "        20\n",
    "\n",
    "where we specify the polynomial by simply specifying its coefficients in ascending order of power.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def poly(coefs,x):\n",
    "    \"\"\" Returns a polynomial with coefficients `coefs`, evaluated at `x`.\n",
    "    \n",
    "        Parameters\n",
    "        ----------\n",
    "        coefs : Tuple[float]\n",
    "            The polynomial coefficients in increasing order (C0, C1, C2, ...)\n",
    "            \n",
    "            This corresponds to the polynomial: C0 + C1*x + C2*(x**2) + ...\n",
    "            \n",
    "            If `coefs` is an empty tuple, then the polynomial is 0.\n",
    "            \n",
    "        x : float\n",
    "            The value at which to evaluate the derivative\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        float\n",
    "            The polynomial function at x\n",
    "        \n",
    "        Examples\n",
    "        -------\n",
    "        >>> # Using the polynomial: 0 + 2*x + 4*(x ** 2)\n",
    "        >>> # compute the polynomial when x = 2\n",
    "        >>> # i.e. 2*(2) + 4*(2 ** 2)\n",
    "        >>> poly([0, 2, 4], 2)\n",
    "        20\n",
    "    \"\"\"\n",
    "    \n",
    "    # STUDENT CODE GOES HERE\n",
    "\n",
    "    sum = 0\n",
    "    for i in range(len(coefs)): \n",
    "         sum += coefs[i] * x**i\n",
    "    \n",
    "    return sum\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============================== ALL TESTS PASSED! ===============================\n",
      "Your submission code: bw6f17c8e6d3ccc5beb34089e2cb28b549845a394250cafc588c179ef0\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "# execute this cell to grade your work\n",
    "\n",
    "from grader import test_poly\n",
    "test_poly(poly)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 2.2: Polynomial Gradient (1-D)\n",
    "\n",
    "Given that\n",
    "\n",
    "$$\n",
    "\\frac{d}{dx}x^n = nx^{n-1}\n",
    "$$\n",
    "\n",
    "Write a function, `poly_grad` that computes the derivative of a polynomial of arbitrary degree, evaluated at some specified value for $x$.\n",
    "\n",
    "That is, if we want to compute the derivative of $f(x) = 0\\;x^0 + 2\\;x^1 + 4\\;x^2$, at $x=2$:\n",
    "\n",
    "$$\n",
    "\\frac{df}{dx} = 0 + 2\\;x^0 + 8\\;x^1\\\\\n",
    "\\frac{df}{dx}\\Bigr|_{x=2} = 0 + 2 + 8\\;(2)^1 = 18\n",
    "$$\n",
    "\n",
    "Accordingly, your function `poly_grad` should behave as follows:\n",
    "\n",
    "        >>> poly_grad((0, 2, 4), 2)\n",
    "        18\n",
    "\n",
    "where we specify the polynomial by simply specifying its coefficients in ascending order of power.\n",
    "\n",
    "Because we are working with a single-variable function, we can simply evaluate the derivative rather than a gradient (i.e. `poly_grad` will return a number rather than a vector)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def poly_grad(coefs, x):\n",
    "    \"\"\" Computes the derivative of a polynomial with coefficients `coefs`, evaluated \n",
    "        at `x`.\n",
    "    \n",
    "        Parameters\n",
    "        ----------\n",
    "        coefs : Tuple[float]\n",
    "            The polynomial coefficients in increasing order (C0, C1, C2, ...)\n",
    "            \n",
    "            This corresponds to the polynomial: C0 + C1*x + C2*(x**2) + ...\n",
    "            \n",
    "            If `coefs` is an empty tuple, then the polynomial is 0.\n",
    "            \n",
    "        x : float\n",
    "            The value at which to evaluate the derivative\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        float\n",
    "            The derivative of the polynomial function at x\n",
    "        \n",
    "        Examples\n",
    "        -------\n",
    "        >>> # Using the polynomial: 0 + 2*x + 4*(x ** 2)\n",
    "        >>> # compute the derivative when x = 2\n",
    "        >>> # i.e. 8*(2) + 2 -> 18\n",
    "        >>> poly_grad([0, 2, 4], 2)\n",
    "        18\n",
    "    \"\"\"\n",
    "    \n",
    "    # STUDENT CODE GOES HERE\n",
    "    \n",
    "    df_dx = 0\n",
    "    \n",
    "    for i in range(len(coefs)): \n",
    "        df_dx += coefs[i] * i * x**(i-1)\n",
    "        \n",
    "    return df_dx\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============================== ALL TESTS PASSED! ===============================\n",
      "Your submission code: bw4cfca6da32da647198225460722b7ea1284f98c4b179e8dbae3f93d5\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "# execute this cell to grade your work\n",
    "\n",
    "from grader import test_polygrad\n",
    "test_polygrad(poly_grad)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 2.3: Gradient Descent (1-D)\n",
    "Now, implement vanilla gradient descent in order *minimize* the polynomial. Refer to the course material from this module for a detailed discussion of gradient descent.\n",
    "\n",
    "This function will not only iteratively update `x` to try to minimize `f(x)`, but it will also keep track of all of the values of `x` during this process. This will allow us to make some nice visualizations of the gradient descent process.\n",
    "\n",
    "A note about your implementation: do not worry about dividing $\\frac{df}{dx}$ by $\\left|\\frac{df}{dx}\\right|$. This is a case where doing so will actually slow down our minimization process. (If you don't know what I'm talking about, revisit the section on gradient descent in the module).\n",
    "\n",
    "After you implement gradient descent and produce the visualization, see if you can envision what the gradient descent trajectory would have looked like if you had normalized the step-size, $\\delta$, by $\\left|\\frac{df}{dx}\\right|$ so that each step taken was of an equal length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grad_descent(coefs, step_size=0.1, iterations=10, x=100.):\n",
    "    \"\"\" Returns a list of x-values visited when optimizing a polynomial through gradient descent \n",
    "    \n",
    "        Parameters\n",
    "        ----------\n",
    "        coefs : List[float]\n",
    "            Polynomial coefficients in increasing order\n",
    "            \n",
    "        step_size : Optional[float], default: 0.1\n",
    "            The magnitude of the step to take for each update of x\n",
    "            \n",
    "        iterations : Optional[int], default: 10\n",
    "            After this number of iterations, the grad_descent function should return\n",
    "            \n",
    "        x : Optional[float], default: 100.\n",
    "            The initial value of x\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        x_list : numpy.ndarray\n",
    "            A numpy array of the values of x that were visited, including the initial value of x.\n",
    "            The shape of x_list should be (iterations+1,)\n",
    "        \n",
    "        Notes\n",
    "        -----\n",
    "        Pseudo-code for this\n",
    "        - Initialize x_list to contain the initialized value `x`\n",
    "        - Until you've exhausted the total number of iterations\n",
    "          - Compute the gradient (just the derivative) of the polynomial with respect to x\n",
    "          - Update x using stepsize\n",
    "          - Add the new value of x to x_list\n",
    "        - Return x_list\n",
    "    \"\"\"\n",
    "    \n",
    "    # STUDENT CODE GOES HERE\n",
    "    \n",
    "   \n",
    "    x_list = [x]\n",
    "    for i in range(iterations):\n",
    "        grad = 0\n",
    "        for coef in range(len(coefs)):\n",
    "            xi = x_list[i]\n",
    "            grad += coefs[coef] * coef * xi**(coef-1)\n",
    "        x_new = xi - (step_size*grad)\n",
    "        x_list.append(x_new)\n",
    "    return x_list\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============================== ALL TESTS PASSED! ===============================\n",
      "Your submission code: bw794293b5706d6f85da86d164393511bb834cd222812a2016e68bb54c\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "# execute this cell to grade your work\n",
    "from grader import test_grad_descent\n",
    "test_grad_descent(grad_descent)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test it out on a toy example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\sanja\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:36: RuntimeWarning: divide by zero encountered in reciprocal\n",
      "C:\\Users\\sanja\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:36: RuntimeWarning: invalid value encountered in multiply\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for ** or pow(): 'list' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-ede22f3461cf>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     20\u001b[0m     \u001b[0mfig\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0max\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msubplots\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfigsize\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m14\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m8\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     21\u001b[0m     \u001b[0max\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpoly\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcoefs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mlabel\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'f(x)'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 22\u001b[1;33m     \u001b[0max\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mxhat\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpoly\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcoefs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mxhat\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'r'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mlinestyle\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m':'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mlabel\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'$f(\\\\hat x)$'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     23\u001b[0m     \u001b[0max\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mxhat\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpoly\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcoefs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mxhat\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mcolors\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0ms\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mzorder\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mnpoints\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     24\u001b[0m     \u001b[0max\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m30\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Start: {:.3f}'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mxhat\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcolor\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'green'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-6-cd49c8cd8665>\u001b[0m in \u001b[0;36mpoly\u001b[1;34m(coefs, x)\u001b[0m\n\u001b[0;32m     32\u001b[0m     \u001b[0msum\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     33\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcoefs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 34\u001b[1;33m          \u001b[0msum\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mcoefs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     35\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     36\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0msum\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for ** or pow(): 'list' and 'int'"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "coefs = [0,7,0,-5,1]\n",
    "npoints = 1001\n",
    "x = np.linspace(-2, 2, npoints)\n",
    "\n",
    "# Plot the function and derivative\n",
    "fig, ax = plt.subplots(figsize=(14,8))\n",
    "ax.plot(x, poly(coefs,x),label='f(x)')\n",
    "ax.plot(x,poly_grad(coefs,x),label='df(x)/dx')\n",
    "ax.plot(x,np.zeros(npoints),color = '0.5',linestyle='--')\n",
    "ax.legend()\n",
    "\n",
    "# Try a few different initializations\n",
    "for x0 in [-1.5,0.5]:\n",
    "    \n",
    "    # Perform gradient descent\n",
    "    xhat = grad_descent(coefs, step_size=0.01, iterations=20, x=x0)\n",
    "\n",
    "    # Plot\n",
    "    colors = ['green'] + ['gray'] * (len(xhat) - 2) + ['r']\n",
    "    fig, ax = plt.subplots(figsize=(14,8))\n",
    "    ax.plot(x, poly(coefs,x),label='f(x)')\n",
    "    ax.plot(xhat, poly(coefs,xhat),c='r',linestyle=':',label='$f(\\\\hat x)$')\n",
    "    ax.scatter(xhat, poly(coefs,xhat),c=colors,s=100, zorder=npoints+1)\n",
    "    ax.text(1, 30, 'Start: {:.3f}'.format(xhat[0]), color='green')\n",
    "    ax.text(1, 25, 'End:   {:.3f}'.format(xhat[-1]), color='red')\n",
    "    ax.text(1, 20, 'f($\\\\hat x$):   {:.3f}'.format(poly(coefs,xhat[-1])), color='k')\n",
    "    ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 2.4: Gradient Descent N-D\n",
    "Assume a linear function: \n",
    "\n",
    "$$y=f(X,\\beta) = \\beta_1x_1+\\beta_2x_2+...+\\beta_nx_n=X\\beta$$\n",
    "\n",
    "\n",
    "Given $m$ pairs of $(X,y)$, use gradient descent to solve for $\\beta$ that minimizes the squared residuals:\n",
    "\n",
    "$$S(\\beta)=(\\boldsymbol{y}-\\boldsymbol{X\\beta})^T(\\boldsymbol{y}-\\boldsymbol{X\\beta})$$\n",
    "\n",
    "Recall that the gradient of $S$ is:\n",
    "\n",
    "$$\\nabla S(\\beta)= 2\\boldsymbol{X}^T(\\boldsymbol{X\\beta}-\\boldsymbol{y})$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradS(X,y,beta):\n",
    "    \"\"\" Returns the gradient of S(beta), where S the sum of squared residuals \n",
    "        of the linear equation: y=X*beta\n",
    "    \n",
    "        Parameters\n",
    "        ----------\n",
    "        X :   numpy.ndarray\n",
    "              X.shape must be (M,N)\n",
    "              Each row of `X` is a single data point of dimension N\n",
    "              Therefore `X` represents M data points\n",
    "\n",
    "        y :   numpy.ndarray\n",
    "              y.shape must be (M,)\n",
    "              Each element of `y` is an output value such that y[i] ~ X[i]*beta\n",
    "\n",
    "        beta :  numpy.ndarray\n",
    "                beta.shape = (N,)\n",
    "\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        gS : numpy.ndarray\n",
    "             The gradient of S evaluated at beta\n",
    "             gS.shape = (N,)\n",
    "        \n",
    "        Notes\n",
    "        -----\n",
    "        You may find numpy.transpose() and numpy.dot() to be useful here.\n",
    "        \n",
    "        See:\n",
    "            https://docs.scipy.org/doc/numpy/reference/generated/numpy.transpose.html\n",
    "            https://docs.scipy.org/doc/numpy/reference/generated/numpy.dot.html\n",
    "        \n",
    "    \"\"\"\n",
    "    \n",
    "    # STUDENT CODE GOES HERE\n",
    "    \n",
    "    s = np.dot(2 * np.transpose(X), np.dot(X, beta) - y)\n",
    "    return s\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradS_des(X,y,beta0,step_size=0.001,iterations=20):\n",
    "    \"\"\" Returns the estimated beta value by minimizing the squared residuals S of \n",
    "        a linear equation using gradient descent \n",
    "    \n",
    "        Parameters\n",
    "        ----------\n",
    "        X :   numpy.ndarray\n",
    "              X.shape must be (M,N)\n",
    "              Each row of `X` is a single data point of dimension N\n",
    "              Therefore `X` represents M data points\n",
    "\n",
    "        y :   numpy.ndarray\n",
    "              y.shape must be (M,)\n",
    "              Each element of `y` is an output value such that y[i] ~ X[i]*beta\n",
    "\n",
    "        beta0 : numpy.ndarray\n",
    "                This is the initial guess for beta\n",
    "                beta0.shape = (N,)\n",
    "                \n",
    "        step_size : Optional[float], default: 0.001\n",
    "                    The magnitude of the step to take for each update of beta\n",
    "            \n",
    "        iterations : Optional[int], default: 20\n",
    "                    After this number of iterations, the gradS_des function should return\n",
    "\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        beta :  numpy.ndarray\n",
    "                This is the final estimate of beta after #iterations\n",
    "                beta.shape = (N,)\n",
    "                \n",
    "        \n",
    "        Notes\n",
    "        -----\n",
    "        Only return the final estimate of beta, not the estimates at each step like we did \n",
    "        for grad_descent() in Question 2.2 \n",
    "    \"\"\"\n",
    "    \n",
    "    # STUDENT CODE GOES HERE\n",
    "    initVal = beta0\n",
    "    iterCount = 0\n",
    "    while (iterCount < iterations):\n",
    "        num = gradS(X, y, initVal)\n",
    "        increment = num * step_size\n",
    "        if (increment > 0):\n",
    "            val = initVal - increment\n",
    "        else:\n",
    "            val = initVal + abs(increment)\n",
    "    initVal = val\n",
    "    iterCount += 1\n",
    "    return initVal\n",
    "\n",
    "\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# execute this cell to grade your work\n",
    "\n",
    "from grader import test_gradS\n",
    "test_gradS(gradS_des)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test it out on a toy example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "n = 10     # number of dimensions\n",
    "m = 100     # number of data points\n",
    "\n",
    "# Generate random X values between 0--10\n",
    "X = np.random.rand(m,n)*10\n",
    "\n",
    "# Generate random beta values between 0--1\n",
    "b = np.random.rand(n,1)*5\n",
    "\n",
    "# Generate Gaussian noise\n",
    "eps = np.random.randn(m,1)\n",
    "\n",
    "# This should call the function you created in Question 1.1\n",
    "y = generate_linear_y(X,b) + eps\n",
    "\n",
    "# Perform OLS by calling the function you created in Question 1.2\n",
    "beta_ols = regression_ols(X, y)\n",
    "\n",
    "# Perform gradient descent by calling the function you created in Question 2.4\n",
    "beta_gd1 = gradS_des(X,y,beta0=b+np.random.randn(n,1),step_size=0.00001,iterations=50)\n",
    "beta_gd2 = gradS_des(X,y,beta0=b+np.random.randn(n,1),step_size=0.00001,iterations=100)\n",
    "beta_gd3 = gradS_des(X,y,beta0=b+np.random.randn(n,1),step_size=0.00001,iterations=150)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot $\\beta$ (true) vs. $\\hat\\beta$ (estimated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bsort=np.sort(b,axis=0)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8,8))\n",
    "ax.plot(bsort,bsort,color='0.75',linestyle='--')\n",
    "ax.scatter(b,beta_gd1,label='$\\\\hat\\\\beta$ (GD,iter=50)')\n",
    "ax.scatter(b,beta_gd2,label='$\\\\hat\\\\beta$ (GD,iter=100)')\n",
    "ax.scatter(b,beta_gd3,label='$\\\\hat\\\\beta$ (GD,iter=150)')\n",
    "ax.scatter(b,beta_ols,label='$\\\\hat\\\\beta$ (OLS)')\n",
    "ax.set_xlabel('$\\\\beta$ (true)')\n",
    "ax.set_ylabel('$\\\\hat\\\\beta$')\n",
    "ax.legend()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}