Linear Regression_Exercise.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Regression Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Generating our data.\n",
    "\n",
    "X = np.linspace(1.0, 10.0, 100)[:, np.newaxis]\n",
    "Y = np.sin(X) + 0.1 * np.power(X, 2) + 0.5 * np.random.randn(100, 1)\n",
    "X /= np.max(X)\n",
    "\n",
    "\n",
    "X = np.hstack((np.ones_like(X), X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((100, 2), (100, 1))"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape, Y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "order = np.random.permutation(len(X))\n",
    "portion = 20\n",
    "\n",
    "\"\"\"\n",
    "    Split your data into train and test using the order and portion variable\n",
    "\"\"\"\n",
    "train_x = X[order[portion:]]\n",
    "train_y = Y[order[portion:]]\n",
    "\n",
    "test_x = X[order[:portion]] \n",
    "test_y = Y[order[:portion]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((80, 2), (80, 1))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_x.shape, train_y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def get_gradient(w, x, y):\n",
    "    \"\"\"\n",
    "        Enter code for error, mse and gradient\n",
    "    \"\"\"\n",
    "    y_estimate = x.dot(w).flatten()\n",
    "    error = y.flatten() - y_estimate\n",
    "    mse = (1.0/len(x)) * np.sum(np.square(error))\n",
    "    #mse = np.mean(error**2)\n",
    "    gradient = (-1/len(x))*np.sum(x.T @ error)\n",
    "    #gradient = (-1.0/len(x)) * error*x\n",
    "    return gradient, mse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iterations: 100 -Error : 12.9461\n",
      "Iterations: 200 -Error : 12.1245\n",
      "Iterations: 300 -Error : 11.4135\n",
      "Iterations: 400 -Error : 10.7981\n",
      "Iterations: 500 -Error : 10.2656\n",
      "Iterations: 600 -Error : 9.8048\n",
      "Iterations: 700 -Error : 9.4060\n",
      "Iterations: 800 -Error : 9.0609\n",
      "Iterations: 900 -Error : 8.7623\n",
      "Iterations: 1000 -Error : 8.5038\n",
      "Iterations: 1100 -Error : 8.2801\n",
      "Iterations: 1200 -Error : 8.0866\n",
      "Iterations: 1300 -Error : 7.9191\n",
      "Iterations: 1400 -Error : 7.7741\n",
      "Iterations: 1500 -Error : 7.6487\n",
      "Iterations: 1600 -Error : 7.5401\n",
      "Iterations: 1700 -Error : 7.4461\n",
      "Iterations: 1800 -Error : 7.3648\n",
      "Iterations: 1900 -Error : 7.2945\n",
      "Iterations: 2000 -Error : 7.2336\n",
      "Iterations: 2100 -Error : 7.1809\n",
      "Iterations: 2200 -Error : 7.1353\n",
      "Iterations: 2300 -Error : 7.0958\n",
      "Iterations: 2400 -Error : 7.0617\n",
      "Iterations: 2500 -Error : 7.0321\n",
      "Iterations: 2600 -Error : 7.0066\n",
      "Iterations: 2700 -Error : 6.9844\n",
      "Iterations: 2800 -Error : 6.9653\n",
      "Iterations: 2900 -Error : 6.9487\n",
      "Iterations: 3000 -Error : 6.9344\n",
      "Iterations: 3100 -Error : 6.9219\n",
      "Iterations: 3200 -Error : 6.9112\n",
      "Iterations: 3300 -Error : 6.9019\n",
      "Iterations: 3400 -Error : 6.8939\n",
      "Iterations: 3500 -Error : 6.8869\n",
      "Iterations: 3600 -Error : 6.8809\n",
      "Iterations: 3700 -Error : 6.8757\n",
      "Iterations: 3800 -Error : 6.8711\n",
      "Iterations: 3900 -Error : 6.8672\n",
      "Iterations: 4000 -Error : 6.8639\n",
      "Iterations: 4100 -Error : 6.8609\n",
      "Iterations: 4200 -Error : 6.8584\n",
      "Iterations: 4300 -Error : 6.8562\n",
      "Iterations: 4400 -Error : 6.8543\n",
      "Iterations: 4500 -Error : 6.8527\n",
      "Iterations: 4600 -Error : 6.8513\n",
      "Iterations: 4700 -Error : 6.8500\n",
      "Iterations: 4800 -Error : 6.8490\n",
      "Iterations: 4900 -Error : 6.8480\n",
      "Iterations: 5000 -Error : 6.8473\n",
      "Iterations: 5100 -Error : 6.8466\n",
      "Iterations: 5200 -Error : 6.8460\n",
      "Iterations: 5300 -Error : 6.8455\n",
      "Iterations: 5400 -Error : 6.8450\n",
      "Iterations: 5500 -Error : 6.8446\n",
      "Iterations: 5600 -Error : 6.8443\n",
      "Iterations: 5700 -Error : 6.8440\n",
      "Iterations: 5800 -Error : 6.8437\n",
      "Iterations: 5900 -Error : 6.8435\n",
      "Iterations: 6000 -Error : 6.8433\n",
      "Iterations: 6100 -Error : 6.8432\n",
      "Iterations: 6200 -Error : 6.8430\n",
      "Iterations: 6300 -Error : 6.8429\n",
      "Iterations: 6400 -Error : 6.8428\n",
      "Iterations: 6500 -Error : 6.8427\n",
      "Iterations: 6600 -Error : 6.8426\n",
      "Iterations: 6700 -Error : 6.8426\n",
      "Iterations: 6800 -Error : 6.8425\n",
      "Iterations: 6900 -Error : 6.8425\n",
      "Iterations: 7000 -Error : 6.8424\n",
      "Iterations: 7100 -Error : 6.8424\n",
      "Iterations: 7200 -Error : 6.8423\n",
      "Iterations: 7300 -Error : 6.8423\n",
      "Iterations: 7400 -Error : 6.8423\n",
      "Iterations: 7500 -Error : 6.8423\n",
      "Iterations: 7600 -Error : 6.8423\n",
      "Iterations: 7700 -Error : 6.8422\n",
      "Iterations: 7800 -Error : 6.8422\n",
      "Iterations: 7900 -Error : 6.8422\n",
      "Iterations: 8000 -Error : 6.8422\n",
      "Iterations: 8100 -Error : 6.8422\n",
      "Iterations: 8200 -Error : 6.8422\n",
      "Iterations: 8300 -Error : 6.8422\n",
      "Iterations: 8400 -Error : 6.8422\n",
      "Iterations: 8500 -Error : 6.8422\n",
      "Iterations: 8600 -Error : 6.8422\n",
      "Iterations: 8700 -Error : 6.8422\n",
      "Iterations: 8800 -Error : 6.8422\n",
      "Iterations: 8900 -Error : 6.8422\n",
      "Iterations: 9000 -Error : 6.8422\n",
      "Iterations: 9100 -Error : 6.8421\n",
      "Iterations: 9200 -Error : 6.8421\n",
      "Iterations: 9300 -Error : 6.8421\n",
      "Iterations: 9400 -Error : 6.8421\n",
      "Iterations: 9500 -Error : 6.8421\n",
      "Iterations: 9600 -Error : 6.8421\n",
      "Iterations: 9700 -Error : 6.8421\n",
      "Iterations: 9800 -Error : 6.8421\n",
      "Iterations: 9900 -Error : 6.8421\n",
      "Iterations: 10000 -Error : 6.8421\n",
      "Iterations: 10100 -Error : 6.8421\n",
      "Iterations: 10200 -Error : 6.8421\n",
      "Iterations: 10300 -Error : 6.8421\n",
      "Iterations: 10400 -Error : 6.8421\n",
      "Iterations: 10500 -Error : 6.8421\n",
      "Iterations: 10600 -Error : 6.8421\n",
      "Iterations: 10700 -Error : 6.8421\n",
      "Iterations: 10800 -Error : 6.8421\n",
      "Iterations: 10900 -Error : 6.8421\n",
      "Iterations: 11000 -Error : 6.8421\n",
      "Iterations: 11100 -Error : 6.8421\n",
      "Iterations: 11200 -Error : 6.8421\n",
      "Iterations: 11300 -Error : 6.8421\n",
      "Iterations: 11400 -Error : 6.8421\n",
      "Iterations: 11500 -Error : 6.8421\n",
      "Iterations: 11600 -Error : 6.8421\n",
      "Iterations: 11700 -Error : 6.8421\n",
      "Iterations: 11800 -Error : 6.8421\n",
      "Iterations: 11900 -Error : 6.8421\n",
      "Iterations: 12000 -Error : 6.8421\n",
      "Iterations: 12100 -Error : 6.8421\n",
      "Iterations: 12200 -Error : 6.8421\n",
      "Iterations: 12300 -Error : 6.8421\n",
      "Iterations: 12400 -Error : 6.8421\n",
      "Iterations: 12500 -Error : 6.8421\n",
      "Iterations: 12600 -Error : 6.8421\n",
      "Iterations: 12700 -Error : 6.8421\n",
      "Iterations: 12800 -Error : 6.8421\n",
      "Iterations: 12900 -Error : 6.8421\n",
      "Iterations: 13000 -Error : 6.8421\n",
      "Iterations: 13100 -Error : 6.8421\n",
      "Iterations: 13200 -Error : 6.8421\n",
      "Iterations: 13300 -Error : 6.8421\n",
      "Iterations: 13400 -Error : 6.8421\n",
      "Iterations: 13500 -Error : 6.8421\n",
      "Iterations: 13600 -Error : 6.8421\n",
      "Iterations: 13700 -Error : 6.8421\n",
      "Iterations: 13800 -Error : 6.8421\n",
      "Iterations: 13900 -Error : 6.8421\n",
      "w = [2.87112689 2.12163168]\n",
      "Test Cost = 8.432461111539787\n"
     ]
    }
   ],
   "source": [
    "w = np.random.randn(2)\n",
    "alpha = 0.0003\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "    Using the get_gradient function, run the Linear regression\n",
    "    use while loop\n",
    "\"\"\"\n",
    "thresh = 10e-8\n",
    "prev_error=0\n",
    "i = 0\n",
    "while True:\n",
    "    gradient, error = get_gradient(w, train_x, train_y)\n",
    "    new_w = w - alpha*gradient\n",
    "    #if (np.abs(prev_error-error) <= thresh): # comparing loss\n",
    "    if (np.sum(np.abs(w-new_w)) <= thresh): # comparing weight\n",
    "        break\n",
    "    i += 1 \n",
    "    if i% 100 == 0:\n",
    "        print(\"Iterations: %d -Error : %.4f\" %(i, error))\n",
    "        \n",
    "    prev_error = error\n",
    "    w = new_w ## Change to your value\n",
    "    \n",
    "print(\"w =\", w)\n",
    "print( \"Test Cost =\", get_gradient(w, test_x, test_y)[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iterations: 0 -Error : 26.0971\n",
      "Iterations: 100 -Error : 23.3142\n",
      "Iterations: 200 -Error : 20.9060\n",
      "Iterations: 300 -Error : 18.8219\n",
      "Iterations: 400 -Error : 17.0183\n",
      "Iterations: 500 -Error : 15.4575\n",
      "Iterations: 600 -Error : 14.1068\n",
      "Iterations: 700 -Error : 12.9379\n",
      "Iterations: 800 -Error : 11.9264\n",
      "Iterations: 900 -Error : 11.0510\n",
      "Iterations: 1000 -Error : 10.2934\n",
      "Iterations: 1100 -Error : 9.6379\n",
      "Iterations: 1200 -Error : 9.0705\n",
      "Iterations: 1300 -Error : 8.5795\n",
      "Iterations: 1400 -Error : 8.1547\n",
      "Iterations: 1500 -Error : 7.7870\n",
      "Iterations: 1600 -Error : 7.4688\n",
      "Iterations: 1700 -Error : 7.1934\n",
      "Iterations: 1800 -Error : 6.9551\n",
      "Iterations: 1900 -Error : 6.7489\n",
      "Iterations: 2000 -Error : 6.5704\n",
      "Iterations: 2100 -Error : 6.4160\n",
      "Iterations: 2200 -Error : 6.2823\n",
      "Iterations: 2300 -Error : 6.1666\n",
      "Iterations: 2400 -Error : 6.0665\n",
      "Iterations: 2500 -Error : 5.9799\n",
      "Iterations: 2600 -Error : 5.9050\n",
      "Iterations: 2700 -Error : 5.8401\n",
      "Iterations: 2800 -Error : 5.7839\n",
      "Iterations: 2900 -Error : 5.7354\n",
      "Iterations: 3000 -Error : 5.6933\n",
      "Iterations: 3100 -Error : 5.6569\n",
      "Iterations: 3200 -Error : 5.6254\n",
      "Iterations: 3300 -Error : 5.5982\n",
      "Iterations: 3400 -Error : 5.5746\n",
      "Iterations: 3500 -Error : 5.5542\n",
      "Iterations: 3600 -Error : 5.5366\n",
      "Iterations: 3700 -Error : 5.5213\n",
      "Iterations: 3800 -Error : 5.5080\n",
      "Iterations: 3900 -Error : 5.4966\n",
      "Iterations: 4000 -Error : 5.4867\n",
      "Iterations: 4100 -Error : 5.4781\n",
      "Iterations: 4200 -Error : 5.4707\n",
      "Iterations: 4300 -Error : 5.4643\n",
      "Iterations: 4400 -Error : 5.4587\n",
      "Iterations: 4500 -Error : 5.4539\n",
      "Iterations: 4600 -Error : 5.4498\n",
      "Iterations: 4700 -Error : 5.4462\n",
      "Iterations: 4800 -Error : 5.4430\n",
      "Iterations: 4900 -Error : 5.4404\n",
      "Iterations: 5000 -Error : 5.4380\n",
      "Iterations: 5100 -Error : 5.4360\n",
      "Iterations: 5200 -Error : 5.4343\n",
      "Iterations: 5300 -Error : 5.4327\n",
      "Iterations: 5400 -Error : 5.4314\n",
      "Iterations: 5500 -Error : 5.4303\n",
      "Iterations: 5600 -Error : 5.4293\n",
      "Iterations: 5700 -Error : 5.4285\n",
      "Iterations: 5800 -Error : 5.4277\n",
      "Iterations: 5900 -Error : 5.4271\n",
      "Iterations: 6000 -Error : 5.4266\n",
      "Iterations: 6100 -Error : 5.4261\n",
      "Iterations: 6200 -Error : 5.4257\n",
      "Iterations: 6300 -Error : 5.4253\n",
      "Iterations: 6400 -Error : 5.4250\n",
      "Iterations: 6500 -Error : 5.4247\n",
      "Iterations: 6600 -Error : 5.4245\n",
      "Iterations: 6700 -Error : 5.4243\n",
      "Iterations: 6800 -Error : 5.4241\n",
      "Iterations: 6900 -Error : 5.4240\n",
      "Iterations: 7000 -Error : 5.4238\n",
      "Iterations: 7100 -Error : 5.4237\n",
      "Iterations: 7200 -Error : 5.4236\n",
      "Iterations: 7300 -Error : 5.4236\n",
      "Iterations: 7400 -Error : 5.4235\n",
      "Iterations: 7500 -Error : 5.4234\n",
      "Iterations: 7600 -Error : 5.4234\n",
      "Iterations: 7700 -Error : 5.4233\n",
      "Iterations: 7800 -Error : 5.4233\n",
      "Iterations: 7900 -Error : 5.4232\n",
      "Iterations: 8000 -Error : 5.4232\n",
      "Iterations: 8100 -Error : 5.4232\n",
      "Iterations: 8200 -Error : 5.4232\n",
      "Iterations: 8300 -Error : 5.4231\n",
      "Iterations: 8400 -Error : 5.4231\n",
      "Iterations: 8500 -Error : 5.4231\n",
      "Iterations: 8600 -Error : 5.4231\n",
      "Iterations: 8700 -Error : 5.4231\n",
      "Iterations: 8800 -Error : 5.4231\n",
      "Iterations: 8900 -Error : 5.4231\n",
      "Iterations: 9000 -Error : 5.4231\n",
      "Iterations: 9100 -Error : 5.4231\n",
      "Iterations: 9200 -Error : 5.4231\n",
      "Iterations: 9300 -Error : 5.4230\n",
      "Iterations: 9400 -Error : 5.4230\n",
      "Iterations: 9500 -Error : 5.4230\n",
      "Iterations: 9600 -Error : 5.4230\n",
      "Iterations: 9700 -Error : 5.4230\n",
      "Iterations: 9800 -Error : 5.4230\n",
      "Iterations: 9900 -Error : 5.4230\n",
      "w = [2.1395563  3.39043521]\n",
      "Test Cost = 6.786487816209554\n"
     ]
    }
   ],
   "source": [
    "w = np.random.randn(2)#.reshape(-1,1)\n",
    "alpha = 0.0003\n",
    "\n",
    "\"\"\"\n",
    "    Using the get_gradient function, run the Linear regression\n",
    "    use iteration of 10000\n",
    "\"\"\"\n",
    "for i in range(10000):\n",
    "    gradient, error = get_gradient(w, train_x, train_y)\n",
    "    new_w = w - alpha*gradient\n",
    "    if i% 100 == 0:\n",
    "        print(\"Iterations: %d -Error : %.4f\" %(i, error))\n",
    "        \n",
    "    w = new_w ## Change to your value\n",
    "\n",
    "print(\"w =\", w)\n",
    "print( \"Test Cost =\", get_gradient(w, test_x, test_y)[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotting the Model we obtained"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "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": [
    "plt.plot(X[:,1], X.dot(w), c='g', label='Model')\n",
    "plt.scatter(train_x[:,1], train_y, c='b', label='Train Set')\n",
    "plt.scatter(test_x[:,1], test_y, c='r', label='Test Set')\n",
    "plt.grid()\n",
    "plt.legend(loc='best')\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('Y')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate contour plot of the cost function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3/dist-packages/matplotlib/contour.py:1000: UserWarning: The following kwargs were not used by contour: 'label'\n",
      "  s)\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": [
    "w1 = np.linspace(-w[1]*3, w[1]*3, 300)\n",
    "w0 = np.linspace(-w[0]*3, w[0]*3, 300)\n",
    "J_vals = np.zeros(shape=(w1.size, w0.size))\n",
    "\n",
    "for t1, element in enumerate(w1):\n",
    "    for t2, element2 in enumerate(w0):\n",
    "        wT = [0, 0]\n",
    "        wT[1] = element\n",
    "        wT[0] = element2\n",
    "        J_vals[t1, t2] = get_gradient(wT, train_x, train_y)[1]\n",
    "\n",
    "plt.scatter(w[0], w[1], marker='*', color='r', s=40, label='Solution Found')\n",
    "CS = plt.contour(w0, w1, J_vals, np.logspace(-10,10,50), label='Cost Function')\n",
    "plt.clabel(CS, inline=1, fontsize=10)\n",
    "plt.title(\"Contour Plot of Cost Function\")\n",
    "plt.xlabel(\"w0\")\n",
    "plt.ylabel(\"w1\")\n",
    "plt.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extra Exercises.\n",
    "\n",
    "Describe what you see in the both diagrams you have."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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": 4
}