Week2 - Linear regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear regression\n",
    "\n",
    "## Set up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#from Ipython.display import display, Math, Latex\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create data set of 100 examples and pne feature\n",
    "def generate_data(n):\n",
    "    \n",
    "    w0 = 4.0\n",
    "    w1 = 3.0\n",
    "\n",
    "    X = 10*np.random.rand(n,)\n",
    "\n",
    "    y = w0 + w1*X + np.random.randn(n,)\n",
    "\n",
    "    return X, y\n",
    "\n",
    "X, y = generate_data(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of training feature matrix:  (100,)\n",
      "shape of label matrix:  (100,)\n"
     ]
    }
   ],
   "source": [
    "print(\"shape of training feature matrix: \", X.shape)\n",
    "print(\"shape of label matrix: \", y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of training feature matrix:  (80,)\n",
      "shape of training label matrix:  (80,)\n",
      "shape of test feature matrix:  (20,)\n",
      "shape of test label matrix:  (20,)\n"
     ]
    }
   ],
   "source": [
    "# Let's divide this into training and test sets\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "#Sanity Check\n",
    "print(\"shape of training feature matrix: \", X_train.shape)\n",
    "print(\"shape of training label matrix: \", y_train.shape)\n",
    "print(\"shape of test feature matrix: \", X_test.shape)\n",
    "print(\"shape of test label matrix: \", y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to make plots\n",
    "\n",
    "def make_plot(x,y):\n",
    "    '''\n",
    "        Function to make plot\n",
    "\n",
    "        Args:\n",
    "            x: x values\n",
    "            y: y values\n",
    "        \n",
    "        Returns:\n",
    "            plot of x vs y\n",
    "    '''\n",
    "    sns.set_style(\"white\")\n",
    "    f = plt.figure(figsize=(8,8))\n",
    "    sns.set_context(\"notebook\", font_scale=1.5, rc={\"lines.linewidth\": 2.5})\n",
    "\n",
    "    plt.plot(X_train, y_train, \"b.\")\n",
    "    plt.title(\"Data Points\")\n",
    "    plt.grid(True)\n",
    "    plt.xlabel(\"$X_1$\", fontsize=18)\n",
    "    plt.ylabel(\"$y$\", rotation=0, fontsize=18)\n",
    "    plt.axis([0,10,0,40])\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfwAAAIFCAYAAAA3J09fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA7EUlEQVR4nO3de3hU1b3G8TeEhFASMSBNlHCNBYRwM4gGUSkQuatgETGABORmBLmVi02tPWChqAUT8BIBFYgcxAuiBaGBYgXTYxmsGAvhKGgSVE6IohAgJGTOH+mkDLmQZPbMnpn9/TyPD7D3zN6/7Kd93qy19lorwG632wUAAPxaPbMLAAAA7kfgAwBgAQQ+AAAWQOADAGABBD4AABZA4AMAYAH1zS4AsKoFCxbo7bffdjoWFBSkpk2bqmfPnpo8ebJ+8Ytf1Pn6BQUFatiwoX72s5+5WqpSU1O1cuVKp2MBAQEKCQlRq1atNHz4cI0bN0716tWuDeF4BtnZ2bWu6cKFC/rhhx8UERFR6+8CVkTgAyZbuHChwsPDJUnnzp1TTk6O3nzzTe3YsUMvvfSSbr755lpf84MPPtDcuXP19ttvGxL4DlOnTlXbtm0lSXa7XefOndOuXbu0ZMkS5ebm6re//W2trjdq1CjFxcXVuo7jx49rwoQJmjJlikaMGFHr7wNWROADJuvfv7+ioqKcjo0dO1b33nuvZs6cqYyMDDVq1KhW1zx48KB++uknI8uUJPXq1avCLyCjRo3S6NGj9dprr2ny5Mm1anF3795d3bt3r3UdeXl5+uqrr2r9PcDKGMMHvNC1116r+fPn6/vvv9ebb75pdjnVqlevngYOHKjS0lJ9+umnZpcDoAoEPuClBg4cqODgYH344Yflx+x2uzZu3Khf/epX6t69uzp37qyBAwcqLS1NjlWyFyxYUD7e3q9fP40dO7b8+9u3b9eYMWMUGxurmJgY9e3bV8uWLdOFCxdcqjUgIECSVFJSUn4sOztbDz/8sHr06KEuXbrovvvuU0ZGhtP3FixYoPbt2zv9e+DAgTp48KDGjBmjrl27qlevXlq8eLHOnz8vSXrrrbc0btw4SWXDIZd+f+PGjRo2bJi6du2qm2++WUlJSfrf//1fl342wF8Q+ICXatCggVq2bKnDhw+XH1uxYoWeeOIJXX/99Vq4cKFmz56tBg0a6JlnntFrr70mqayLPT4+XlJZIE6dOlWStHnzZs2cOVNhYWGaO3eu5s2bp+bNm2vNmjVasWKFS7X+/e9/lyR16tRJUtmQwqhRo3Tw4EElJiZq9uzZKi4uVlJSktLT06u91vfff6+JEyeqbdu2+s1vfqMbb7xR69evV0pKiiTppptuKv+ZRo0apWXLlkmStm7dqieeeEIdO3bUb37zGyUmJurAgQMaO3asTp8+7dLPB/gFOwBTzJ8/396uXTt7bm5ulZ+5//777TExMXa73W6/cOGC/cYbb7TPmjXL6TOnT5+2x8TE2KdMmVJ+LCUlpcK1Bw4caB81apS9tLS0/FhxcbH99ttvtw8dOrTaWh3X+8tf/mIvKCiwFxQU2E+ePGn/7LPP7P/1X/9lb9eunT0pKan88yNHjrR369bN/u2335YfO3/+vH348OH2Ll262AsKCpyeweXPZN26dU73HzRokL13797l//773/9ub9eunf3NN98sP/bQQw/ZhwwZ4vS9PXv22AcPHmzfv39/tT8fYAW8tAd4sZKSkvLu8qCgIH300UcqLi52+swPP/yg0NBQnT17ttprbd26VefOnSu/nlQ2de+qq6664ncdkpKSKhwLDAzU0KFD9fvf/16SdPLkSX366acaPXq0IiMjyz/XoEEDTZw4UbNnz9ZHH32koUOHVnmfQYMGOf27Q4cO2r59e7W1RUZGat++fVq5cqXuueceRUVF6Y477tAdd9xRo58N8HcEPuDFTp06pSZNmpT/OygoSHv27NGuXbt07Ngxff311/rxxx8lqXwMvypBQUH6xz/+offee09Hjx5VTk6OCgoKJEnNmzevUT3z589Xhw4dJJWN2zdq1EjR0dFOswiOHz8uSWrTpk2F70dHR0uSvvnmm2rvc+nPLEnBwcEqLS2t9jtJSUn65z//qdTUVKWmpur6669X3759NXLkSLVs2fLKPxzg5xjDB7zUmTNnlJubWx6wdrtdDz/8sGbMmKG8vDx1795d8+bN086dO3Xttdde8XqLFi1SYmKiDh06pBtuuEHTp0/XO++8ox49etS4pk6dOqlXr17q1auX4uLi1KVLlwpTBqv7xcMR2kFBQdXep7YL+EhlLfx33nlHr7zyisaOHauSkhKlpaVp8ODB+vjjj2t9PcDf0MIHvNT7778vu92ufv36SZL279+vv/71r3r44Yf16KOPln+upKREp06dUosWLaq81vHjx7Vhwwbdfffd5S+5OZw8edLQuh29BUePHq1w7tixY5Lk1NVvFMdqfXFxceWL+dhsNj344INav369evbsafg9AV9CCx/wQv/3f/+nlJQURUREaNiwYZLKuvcl6frrr3f67Ouvv65z5845TYlztJAdrW1Ht//l3/3ggw/01VdfOX3XVc2aNVNMTIy2bt2q7777rvz4hQsX9PLLLys4OFi33nqrS/cIDAyUJKdu/kcffVTz5s3TxYsXy4917NhRQUFBdeoxAPwNLXzAZBkZGeVL6xYVFeno0aPasmWLioqK9NJLLykkJERS2ap0oaGhWrJkiY4fP67GjRvrf/7nf7Rt2zY1aNBAhYWF5dd0jIGvXr1at99+u2677TZdd911euGFF1RUVKTIyEgdPHhQb7/9doXvGiE5OVkPPvigfvWrX2n06NFq1KiRtm7dqs8//1zJycm66qqrXLq+43lt3bpVdrtdw4cP18SJE5WcnKzx48dr4MCBstvteuedd1RUVKQHHnjAiB8L8GkEPmCyJUuWlP89KChIERER6tu3ryZNmuT04ts111yjtLQ0Pf3003r++ecVHBysNm3a6E9/+pMOHjyodevW6eTJk7rmmms0ZMgQ7dy5U2+99ZY+/vhj9evXT2lpaVq6dKnWrVsnu92uli1b6rHHHlNJSYmefPJJZWVlKSYmxpCfqXv37tq4caNSUlK0du1alZaWqkOHDlq1apX69+/v8vWjo6M1duxYvfXWW/rss8908803a+TIkQoKCtK6dev0pz/9SaWlpYqJianzfgSAvwmwX+nVXhc88sgjys7O1l/+8pfyY3v37tXy5cv1xRdfqGnTphozZowmTJjgrhIAAIDcOIb/zjvvOAW9JB04cKB8t63U1FQNGzZMy5Yt05o1a9xVBgAAkJta+CdOnNCwYcPUsGFDBQcHlwf/+PHjdfbsWb3++uvln33qqaf0+uuva9++fQoODja6FAAAIDe18JOTk3Xrrbc67XNdVFSk/fv3684773T67IABA/TTTz/pwIED7igFAADIDS/tbd68WZ9//rnee+89p/m+ubm5Ki4urrD6VqtWrSSVzc+95ZZbanSP8+fPKysrS82aNSufngMAgL+6ePGi8vPzFRMTUz5zp7YMDfzjx49ryZIlWrJkSYWlMR27VYWGhjodd6zSdebMmRrfJysrSwkJCS5WCwCAb0lPT6/V6piXMizw7Xa7HnvsMd1xxx0aMGBApeerU5uFMZo1ayap7Ad3x4pdKGPkNC1UjmfsGTxn9+MZu9d3332nhISE8vyrC8MCPz09XdnZ2Xr33XfLV+1yhHxJSYnCwsIkqcICH46WveN8TTi68SMjIxUVFeVy7ajciRMneL5uxjP2DJ6z+/GMPcOVYWzDAn/Hjh364Ycf1Lt37wrnOnXqpCeeeEKBgYHKyclxOuf4d2U7awEAAGMYFvi///3vK7TeV61apUOHDmnlypWKiorS9u3btXPnTj344IPle3Lv2LFDYWFhdAUBAOBGhgV+27ZtKxy7+uqrFRwcrM6dO0uSpk2bpsTERM2aNUvDhw/XJ598ojVr1mjOnDlq2LChUaUAAIDLeHQLqbi4OKWmpurLL79UUlKS3n33Xc2bN0+TJk3yZBkAAFiOWzfPWbp0aYVj8fHxio+Pd+dtAQDAZdgkGgAACyDwAQCwAAIfAAALIPABALAAAh8AAAsg8AEAsAACHwAACyDwAQCwAAIfAAALIPABALAAAh8AAAsg8AEAsAACHwAACyDwAQCwAAIfAAALIPABALAAAh8AAAsg8AEAsAACHwAACyDwAQCwAAIfAAALIPABALAAAh8AAAsg8AEAsAACHwAACyDwAQCwAAIfAAALIPABALAAAh8AAAsg8AEAsAACHwAACyDwAQCwAAIfAAALIPABALAAAh8AAAsg8AEAsAACHwAACyDwAQCwAAIfAAALIPABALAAAh8AAAsg8AEAsID6Rl/Qbrfr1Vdf1caNG/Xtt9+qdevWmjRpkoYNG1b+mfj4eOXk5FT4bmZmppo0aWJ0SQAAWJ7hgf/iiy8qJSVF06dPV7du3fS3v/1Nc+fOVWBgoAYPHqzCwkLl5uZqzpw56tmzp9N3r7rqKqPLAQAAMjjwi4uLtXbtWo0ePVrTpk2TJMXFxSkrK0sbNmzQ4MGDlZ2dLbvdrn79+ik6OtrI2wMAgCoYGviBgYFav369rr76aqfjQUFBOnv2rCTp0KFDCgkJUevWrY28NQAAqIahL+3Vq1dP7du3V0REhOx2u06ePKm0tDR99NFHGjVqlCQpOztbjRs31uzZs9WjRw91795ds2bNUn5+vpGlAACASxg+hu+wc+dOzZgxQ5LUp08f3XXXXZKkw4cP6+TJk/rFL36hsWPH6ujRo0pJSdG4ceP09ttvKyQkpMb3yMrK0okTJ9xSP8rYbDazS/B7PGPP4Dm7H8/YfYxoFLst8Dt27KgNGzYoOztbzz77rCZPnqxXX31VycnJstvt6tq1qySpR48eio6O1gMPPKCtW7fqvvvuq/E9YmJiFBUV5a4fwfJsNptiY2PNLsOv8Yw9g+fsfjxj98rLy3P5Gm4L/BYtWqhFixa66aabFBoaqvnz5+uTTz7RjTfeWOGzsbGxCgsL0+HDh91VDgAAXiMzU9qzR+rTR4qL88w9DQ38U6dOac+ePYqLi1NERET58Y4dO0qSvv76ax07dkydOnVShw4dys+XlpaquLhY4eHhRpYDAIDXycyU+vWTLlyQgoOlXbs8E/qGvrRXWlqqBQsWaNOmTU7H9+3bJ0nq2rWrli5dqpUrVzqd3717t86fP19hXj4AAP5mz56ysL94sezPPXs8c19DW/hNmjTRAw88oLS0NIWEhKhz586y2Wx68cUXNXLkSLVt21YPP/ywli5dqsWLF6tv3746cuSIUlNT1a9fP918881GlgMAgKkq67rv06esZe9o4ffp45laDB/DX7hwoa699lq98cYbSk1NVWRkpGbMmKGJEydKkhITExUaGqp169Zp8+bNaty4se6//35Nnz7d6FIAADBNVV33cXFlf/fpMXypbJGdSZMmadKkSVV+ZuTIkRo5cqTRtwYAwGtU1nXvCHdH8HsSu+UBAOAGjq77wEDPdt1XxW3T8gAAsDKzuu6rQuADAOAmZnTdV4UufQAALIDABwDAAgh8AAAsgMAHAMACCHwAACyAwAcAwAIIfAAAriAzU1qypOxPX70f8/ABAKiGp7ezrex+LVq4fl1a+AAAVMPT29m6634EPgAA1fD0mvjuuh9d+gAAVMPTa+JXdr+8PNevS+ADAHAFnl4T3x33o0sfAAALIPABALAAAh8AAAsg8AEAsAACHwAACyDwAQCwAAIfAAALIPABALAAAh8AYGme3gnPLKy0BwCwLE/vhGcmWvgAAMvy9E54ZiLwAQCWVdud6Xy5+58ufQCAZdVmJzxf7/4n8AEAfiUzs3Zb2dZ0Z7rKuv8JfAAATODOVrij+99x7St1/3sbAh8A4DcubYWfPy+tW2dc4Du6/9etM+Z6nsZLewAAv9GnT9kLeJJkt0svv2z8C3avviq99FJZT4IvvbxH4AMA/EZcnDRhghQQUPbvkhJjp9r58jQ+Ah8A4FfGjZNCQmo+1a42ajuNz5swhg8A8Cu1mWrnrmvXdqaAJxD4AAC/U9Opdu64trfO16dLHwDgs8xe+a6y+3vrOD8tfACATzK7JV3V/b11vj4tfACATzK7JV3V/R3j/IsWeU93vkQLHwDgo8xuSVd3f3e+Q1BXBD4AwCe58218X7h/bRke+Ha7Xa+++qo2btyob7/9Vq1bt9akSZM0bNiw8s/s3btXy5cv1xdffKGmTZtqzJgxmjBhgtGlAAD8nNktabPvXxuGB/6LL76olJQUTZ8+Xd26ddPf/vY3zZ07V4GBgRo8eLAOHDigqVOnatCgQXr00Udls9m0bNky2e12TZw40ehyAACADA784uJirV27VqNHj9a0adMkSXFxccrKytKGDRs0ePBgpaSkqGPHjnrqqackSbfffrtKSkr0wgsvaOzYsQoODjayJAAAIIPf0g8MDNT69es1efJkp+NBQUEqKipSUVGR9u/frzvvvNPp/IABA/TTTz/pwIEDRpYDAAD+zdDAr1evntq3b6+IiAjZ7XadPHlSaWlp+uijjzRq1Cjl5uaquLhYbdq0cfpeq1atJEnHjh0zshwAAPBvbntLf+fOnZoxY4YkqU+fPrrrrrt06NAhSVJoaKjTZxs1aiRJOnPmTK3ukZWVpRMnThhQLapis9nMLsHv8Yw9g+fsfjxj98nPz3f5Gm4L/I4dO2rDhg3Kzs7Ws88+q8mTJ+vRRx+t9jv16tWuwyEmJkZRUVGulIlq2Gw2xcbGml2GX+MZewbP2f14xu6Vl5fn8jXcFvgtWrRQixYtdNNNNyk0NFTz588vP1dYWOj0WUfLPiwszF3lAABgaYaO4Z86dUpbtmyp0M3esWNHSWW/oQQGBionJ8fpvOPfl4/tAwAAYxga+KWlpVqwYIE2bdrkdHzfvn2SpM6dO6tHjx7auXOn7HZ7+fkdO3YoLCxMMTExRpYDAHADs3eoQ90Y2qXfpEkTPfDAA0pLS1NISIg6d+4sm82mF198USNHjlTbtm01bdo0JSYmatasWRo+fLg++eQTrVmzRnPmzFHDhg2NLAcAYDCzd6hzVWam7yyFazTDx/AXLlyoa6+9Vm+88YZSU1MVGRmpGTNmlK+iFxcXp9TUVKWkpCgpKUkRERGaN28eS+sCgA+obIc4XwlOX/9lxVWGB35QUJAmTZqkSZMmVfmZ+Ph4xcfHG31rAICbmbVDnREtc1/+ZcUI7JYHAKgxM3aIM6plbvZ2umYj8AEAteLpHeKMapn72na2RiPwAQBezciWuS9tZ2s0Ah8A4NWs3jI3CoEPAPB6Vm6ZG8XQhXcAAIB3IvABALAAAh8AAAsg8AEAsAACHwAACyDwAcBi2O3OmpiWBwAWYtQyta6sbW/lHevMROADgIUYsUxtZb80BAfX/buEvmfQpQ8AFuJYpjYwsO7L1Fb2S4MnvgvX0MIHAAsxYplaV9a2t/qOdWYi8AHAYqpapramY+uV/dJgs9X83qyLbw4CHwBQ67F1V9a2Z118czCGDwBgbN0CCHwAgCEv88G70aUPAGBs3QIIfACAJMbW/R1d+gAAWACBDwB+hrXyURm69AHAj3hq6dqq5uyzTr73IvABwI8YsVb+lVS1lj7r5Hs3uvQBwI94YnpdVXP2mcvv3WjhA4Af8cT0uqrWw2edfO9G4AOAn3H39Lqq1tJnLr93I/ABALVW1S8VzOX3XozhAwBgAQQ+APgI5tfDFXTpA4APYMobXEULHwB8AFPe4CoCHwB8ANvXwlV06QOAD2DKG1xF4AOAj2DKG1xBlz4AABZA4AMAYAEEPgAAFkDgAwBgAQQ+APgIVtqDKwx9S7+0tFSbNm3Sa6+9pry8PDVt2lT9+vXT9OnTFRoaKkkaP368Miv5X+sbb7yhzp07G1kOAPiNS1faCwyUJkyQxo3jrX3UnKGBv3r1aq1YsUITJ05UXFycjh07ppSUFH3xxRdas2aNJOnw4cMaN26chgwZ4vTd6OhoI0sBAJ+UmVn5XPtLV9q7eFF68UXp1VdZYhc1Z1jg2+12rV69WqNGjdKcOXMkSb169VJ4eLhmzZqlQ4cOqUmTJvrhhx902223qVu3bkbdGgD8QnXr5TtW2jt/XrLby/5zLLFL4KMmDBvDLyws1F133aWhQ4c6HW/btq0kKScnR4cPH5YktW/f3qjbAoDfqG69fMdKe1OmSA0asMQuas+wFn5oaKiSk5MrHM/IyJAkXX/99crIyFBwcLBSUlKUkZGhs2fP6pZbbtFjjz2mNm3aGFUKAPgkRyve0cK/PMwdK+2NG8cSu6g9t76l/+mnnyotLU39+/dXdHS0Dh8+rAsXLigkJEQrV67Uk08+qZycHCUkJCg/P9+dpQCA13O04hctqn5sPi5OWriQsEftBNjtdrs7Lmyz2TR16lQ1a9ZM6enpCg8P15EjR/T999/rlltuKf9cbm6uBg0apIkTJ2rWrFk1unZeXp769eunZ599Vs2aNXNH+QAAeI38/Hw9+uij2rVrl6Kioup0DbdsnrNt2zYtWLBArVu31urVqxUeHi5JateuXYXPtmjRorz1X1sxMTF1/sFxZTabTbGxsWaX4dd4xp7Bc3Y/nrF75eXluXwNw7v0X375Zc2ePVvdunVTenq6fv7zn0sqe4t/y5Yt2r9/f4XvnD9/vvyXAgAAYDxDA3/z5s1aunSpBg0apNWrVyssLKz8XEBAgNasWaM//OEPKi0tLT/++eefKycnRz179jSyFAAAcAnDuvQLCgr05JNPqnnz5kpISNC//vUvp/MtW7bUI488ohkzZmju3Lm699579c033+jZZ5/VDTfcoLvvvtuoUgAAwGUMC/wPP/xQ586d0/Hjx5WQkFDh/LJly3T33Xdr1apVeuGFF/TII48oJCRE8fHxmj17tgIDA40qBQAAXMawwL/nnnt0zz33XPFz/fv3V//+/Y26LQAAqAF2ywMAwAIIfAAALIDABwDAAgh8ADBIZqa0ZEnZnzU5DniSW1baAwCrqWpr2+q2vK3rfdg4B3VBCx8ADFDV1rbVbXl7uSv1BDh+efjtb8v+pMcAtUELHwAqUduWdFVb215py9tL73elnoDKfnmglY+aIvAB4DJ16YZ3bG17+S8JVR2/XE3CvKa/PACVIfAB4DJ1bUnHxVX+uaqOX6omYV7TXx6AyhD4AHAZM1rSNQ3zmvzyAFSGwAfgtxzj8JGRjVSbrdrNakkT5nAnAh+AX7p0HL5+/Xbq0KF2YUr4wt8wLQ+AX7p0HL6kJKDa6XCAFRD4APySYxw+MFCqX9/OG+2wPLr0AfilS8fhIyOPKC6ug9klAaYi8AH4Lcc4vM1WaHYpgOno0gcAwAIIfAAALIDABwAPYItcmI0xfABwM6O3yAXqghY+AFyBq63z2myRC7gLLXwAqIYRrXN2uYM3IPABoBrr1knnz0t2e933oGeXO3gDAh8AqpCZKb38clnYS2Wr9tW1dc7a/DAbY/gAUIU9e6SSkrK/BwRIEyYQ2vBdBD4AVOHS9fhDQqRx48yuCKg7uvQBoAqMvcOfEPgAUA3G3uEv6NIHAMACCHwAPoUlaoG6oUsfgM9giVqg7mjhA/AZLFEL1F2NAv/xxx9X+/btdeLEiQrnjh49qpiYGC1evNjw4gDgUpdOk2OJWqB2ahT43bt3lyR99tlnFc4tWbJEjRo10vTp042tDAAu45gmt2gR3flAbdUo8Lt27SpJOnjwoNPxPXv26G9/+5tmzJihxo0bG18dAFwmLk5auJCwB2qrRoHfpk0bXX311U6BX1xcrCVLlqhdu3a6//773VYgAABwXY3e0g8ICFDXrl114MAB2e12BQQEaN26dfrqq6/0yiuvKDAw0N11AgAAF9T4Lf2uXbvq9OnTOnr0qAoKCvTcc8+pf//+iqNfDQAAr1fjefiXvrj3j3/8QxcuXNCCBQvcVhgA82Vmso484C9qHPhdunRRvXr1tHnzZh04cEATJ05UixYt3FkbABOxyA3gX2rcpR8aGqrrr79e+/fvV9OmTTV16lR31gXAZCxyA/iXWq2017lzZ0nS7NmzFRoa6paCAHgHb17khvX0gdqrcZd+cXGxPv74Y8XExGj48OGVfqa0tFSbNm3Sa6+9pry8PDVt2lT9+vXT9OnTy39B+Oyzz7Rs2TJlZWWpUaNGGjFihKZPn66goCBjfiIAhvDWveAZagDqpsaBv3btWuXl5enpp59WQEBApZ9ZvXq1VqxYoYkTJyouLk7Hjh1TSkqKvvjiC61Zs0Zff/21xo8fr+7du2vFihX68ssvtXz5cp05c0aPP/64YT8UAGN4417wlQ01eFuNgDeqNvBPnTqlvXv3Kjs7W2vWrFFiYqK6detW6WftdrtWr16tUaNGac6cOZKkXr16KTw8XLNmzdKhQ4e0YcMGhYWF6bnnnlNwcLDuuOMOhYSEaPHixZoyZYoiIiIM/wEBuJ8n3+Z3DDU4WvjeNNQAeLNqx/D37t2rOXPm6M0339SDDz6ouXPnVvnZwsJC3XXXXRo6dKjT8bZt20qScnJytG/fPv3yl79UcHBw+fmBAwfq4sWL2rt3rys/BwA3qm7M3NHF/tvflv3p7nF11tMH6qbaFv7QoUMrBHhVQkNDlZycXOF4RkaGJCk6Olrffvut2rRp43S+SZMmCg0N1bFjx2paMwAPutKYuRld7N441AB4uxqP4dfFp59+qrS0NPXv319XXXWVJFX6dn+jRo105syZWl8/Kyur0i17YRybzWZ2CX7P25/xM8+01Pnz18huD9CFC3alp3+j4ODvys9HRjZS/frtJAWofn27IiOPyGYrNK/gKnj7c/YHPGP3yc/Pd/kabgt8m82mqVOnKioqSosXL9aFCxeq/Xy9erWaIShJiomJUVRUVF1LxBXYbDbFxsaaXYZf87ZnfPlYfGam9N57kt1edj4wMEAJCc0VG9u8/DuxsVKHDo7vBSguroMZpVfL256zP+IZu1deXp7L13BL4G/btk0LFixQ69attXr1aoWHh6uwsOw3fseflzpz5ozCwsLcUQqAGqqs637PHqmkpOx8QIA0YULlXel0sQPer/bN6it4+eWXNXv2bHXr1k3p6en6+c9/Lqms2z4iIkJff/210+cLCgpUWFhYYWwfgGdVNhZ/6eI7ISHSuHEmFwmgzgwN/M2bN2vp0qUaNGiQVq9eXaHVfuutt+qvf/2rU/f+jh07FBgYqJ49expZCoBaqmxlPd6IB/yHYV36BQUFevLJJ9W8eXMlJCToX//6l9P5li1b6qGHHtKf//xnTZ48WQ8++KC++uor/elPf9J9992n6667zqhSANSBI9zXrat4nKAHfJ9hgf/hhx/q3LlzOn78uBISEiqcX7Zsme6++26tXbtWy5Yt04wZMxQeHq7ExERNnz7dqDIAuOjVV8u69F99lVY94E8MC/x77rlH99xzzxU/16NHD73++utG3RaAgVi2FvBfhr+0B8B3efMOeQBc49aFdwD4Fm/dIQ+A6wh8AE54SQ/wT3TpAxZV3YY4APwPLXzAgq60IQ4A/0MLH7Cgyt7GB+DfCHzAgngbH7AeuvQBC+JtfMB6CHzAongbH7AWuvQBALAAAh8AAAsg8AEAsAACH4ATFuQB/BMv7QEox4I8gP+ihQ94iC+0nFmQB/BftPABD3BHyzkz0/h59I4FeRx1siAP4D8IfMADKms5uxLS7up6Z0EewH8R+IAHGN1yNvoXiEuxIA/gnwh8wAOMbjnT9Q6gtgh8wEOMbDnT9Q6gtgh8wEfR9Q6gNpiWBwCABRD4AABYAIEP+BlfWOAHgOcxhg/4EZbGBVAVWviAiQ4ebGRoa5ylcQFUhRY+YJLMTGnatHYqKTGuNc78fABVIfABk+zZIxUXB6i01LjV8pifD6AqBD5gkj59pKAgu0pKAgxtjTM/H0BlCHzAJHFx0vPPH9F333WgNQ7A7Qh8wERduhQqMdHsKgBYAW/pAz6K+fYAaoMWPuCDmG8PoLZo4QM+iPn2AGqLwAd8kGO+fWAg8+0B1Axd+oCXysysej498+0B1BaBD3ihmozRM98eQG3QpQ+/5qtvsjNGD8BotPDht3z5TXbWxAdgNAIffquyVrKvBD5j9ACMRuDDb/l6K5kxegBGcmvgHzp0SL/61a+0a9cuRUZGlh+Pj49XTk5Ohc9nZmaqSZMm7iwJFkIrGQD+w22B/+WXX2rKlCkqKSlxOl5YWKjc3FzNmTNHPXv2dDp31VVXuascWBStZAAoY3jgl5SUaNOmTXrmmWcUFBRU4Xx2drbsdrv69eun6Ohoo28PeJXq5tIDgCcZHvg2m01PP/20Jk6cqIiICCUnJzudP3TokEJCQtS6dWujbw2YprJg9+VZAgD8j+GBHx0drYyMDDVt2lRvvfVWhfPZ2dlq3LixZs+erX379unixYvq06ePHnvsMTVr1szocgC3qyrYfXmWAAD/Y3jgX3PNNdWeP3z4sE6ePKlf/OIXGjt2rI4ePaqUlBSNGzdOb7/9tkJCQmp8r6ysLJ04ccLVklENm81mdgleLz09UkVF16m0NEAXLtiVnv6NgoO/U2RkI9Wv305SgOrXtysy8ohstsIK3+cZewbP2f14xu6Tn5/v8jU8Pi0vOTlZdrtdXbt2lST16NFD0dHReuCBB7R161bdd999Nb5WTEyMoqKi3FWq5dlsNsXGxppdhmHcNZ5+4YK0dq2jhR+ghITmio1trthYqUMHxz0DFBfXocJ3/e0Zeyues/vxjN0rLy/P5Wt4PPC7dOlS4VhsbKzCwsJ0+PBhT5cDi3DneHp10/+YJQDAW3g08M+ePavt27erU6dO6tDhP62d0tJSFRcXKzw83JPlwELcPZ5OsAPwdh7dPKdBgwZaunSpVq5c6XR89+7dOn/+fIV5+YBR2D8egNV5tIUfGBiohx9+WEuXLtXixYvVt29fHTlyRKmpqerXr59uvvlmT5YDC2HVPQBW5/Ex/MTERIWGhmrdunXavHmzGjdurPvvv1/Tp0/3dCmwGLrdAViZWwN/xIgRGjFiRIXjI0eO1MiRI915a8CjWFEPgLdjtzzARayoB8AXePSlPcAfVTYDAAC8DYEPuIgZAAB8AV36gIuYAQDAFxD4gAGYAQDA29GlDwCABRD4AABYAIEPAIAFEPjwO5mZ0pIlZX8CAMrw0h68iqsr1rEIDgBUjsCH1zAirN29DS4A+Cq69OE1jFixjkVwAKBytPDhNRxh7Wjh1yWsWQQHACpH4MNrGBXWLIIDABUR+PAqhDUAuAdj+AAAWACBD7dwZS488+gBwHh06cNwrkyvYx49ALgHLXwYzpXpdUZMzQMAVETgw3CuzIVnHj0AuAdd+jCcK9PrmEcPAO5B4MMtXJlex9Q8ADAeXfoAAFgAgQ8AgAUQ+PBqzMkHAGMwhg+vxZx8ADAOLXx4LebkA4BxCHx4LebkA4Bx6NKH12JOPgAYh8CHV2NOPgAYgy59AAAsgMAHAMACCHxUi3nwAOAfGMNHlQ4ebKSkJObBA4A/oIWPKtlsYcyDBwA/QeCjSrGxp5kHDwB+gi59VKlLl0LmwQOAnyDwUS3mwQOAf6BLHwAACyDwAQCwAAIfAAALcGvgHzp0SJ06ddJ3333ndHzv3r2699571bVrV/Xt21dr1651ZxkAAFie2wL/yy+/1JQpU1RSUuJ0/MCBA5o6daratm2r1NRUDRs2TMuWLdOaNWvcVQoAAJZn+Fv6JSUl2rRpk5555hkFBQVVOJ+SkqKOHTvqqaeekiTdfvvtKikp0QsvvKCxY8cqODjY6JIAALA8w1v4NptNTz/9tCZMmKC5c+c6nSsqKtL+/ft15513Oh0fMGCAfvrpJx04cMDocgAAgNwQ+NHR0crIyNAjjzyiwMBAp3O5ubkqLi5WmzZtnI63atVKknTs2DGjy0EdODbMOXiwkdmlAAAMYniX/jXXXFPludOnT0uSQkNDnY43alQWLGfOnDG6HNRSZqbUr1/Z2vn167dThw4svAMA/sCjK+3Z7fZqz9erV7sOh6ysLJ04ccKVknCZ9PRIFRVdp9LSAEkBSk8/ruDg7674PdSdzWYzuwRL4Dm7H8/YffLz812+hkcDPywsTJJUWFjodNzRsnecr6mYmBhFRUUZUxwklbXs1651tPDtSkhortjY5maX5bdsNptiY2PNLsPv8Zzdj2fsXnl5eS5fw6OB37JlSwUGBionJ8fpuOPfl4/tw/Pi4lS+YU5k5BHFxXUwuyQAgAE8utJegwYN1KNHD+3cudOpe3/Hjh0KCwtTTEyMJ8tBFeLipIULy3bLAwD4B48vrTtt2jQdOHBAs2bN0gcffKAVK1ZozZo1mjJliho2bOjpcgAAsASPB35cXJxSU1P15ZdfKikpSe+++67mzZunSZMmeboUAAAsw61j+CNGjNCIESMqHI+Pj1d8fLw7bw0AAC7BbnkAAFgAge8ix6p0mZlmVwIAQNU8Oi3P31y6Kl1wcNl0NlalAwB4I1r4LtizpyzsL14s+3PPHrMrAgCgcgS+C/r0KWvZBwaW/dmnj9kVVY/hBwCwLrr0XXDpqnR9+nh3dz7DDwBgbQS+i+LifCM4Kxt+8IW6AQDGoEvfIqobfqCrHwD8Hy18i6hq+IGufgCwBgLfQiobfqCrHwCsgS59i/O1mQYAgLqhhW9xvjTTAABQdwQ+fGamAQCg7ujSBwDAAgh8k1Q2FY7pcQAAd6FL3wSVTYWTmB4HAHAfWvgmqGwqXE024qEHAABQV7TwPSgzsyzImzYta8U7WvOOqXCVHbv0u/QAAADqisD3kMsDe8UKqaDgP1PhMjOlBx8s++y4cSyQAwAwFoHvAZmZ0hNPSEVFUmlpWWAXFEgLF/7n/KW/DIwbV/EajgVyquoBAACgOgS+mznC3BH29epVDOyatN5ZIAcA4AoC380cYe4I+/79y1r7lwZ2TVvvLJADAKgrAt/NLg/zy8NeovUOAHA/At/NahrmtN4BAO5E4HsAYQ4AMBsL7wAAYAEEPgAAFkDg/xvL1gIA/Blj+GLZWgCA/6OFr5ptXAMAgC8j8PWfufKBgSxbCwDwT3Tpi4VvAAD+j8D/t8vnyju2suUXAACAPyDwK8FLfAAAf8MYfiV4iQ8A4G9o4f/bpV34Ve1eRzc/AMBXEfiqvAv/8pf46OYHAPgyuvRVeRd+XJy0cOF/Qp1ufgCALyPwVbN5+MzVBwD4Mrr0VbN5+MzVBwD4MgL/32qyZz372gMAfBVd+gAAWIApLfySkhLdeOONKioqcjr+s5/9TJ988okZJQEA4NdMCfxjx46pqKhIf/zjH9W6devy4/XqebbDgXn1AACrMCXwDx8+rHr16mnAgAFq2LChGSUwrx4AYCmmjOEfOnRILVu2NC3sJebVAwCsxZTAz87OVnBwsCZOnKju3bvrpptu0uOPP64zZ854rAbm1QMArMS0Lv0zZ85o5MiRmjp1qrKyspSamqpjx45p3bp1CggIqNF1srKydOLEiTrVEBwsrVrVSDZbmGJjTys4uFA2W50u5ddsPBS34xl7Bs/Z/XjG7pOfn+/yNUwJ/OXLl6tx48Zq3769JOmmm25S06ZN9etf/1offfSRbr311hpdJyYmRlFRUXWuIzZWSkys/NzlL/RZ8QU/m82m2NhYs8vwazxjz+A5ux/P2L3y8vJcvoYpgd+zZ88Kx/r8u0/98OHDNQ58I10a6JLzC30rVkgzZ/KCHwDAd3k88AsKCrR7927dcsstatGiRfnx8+fPS5LCw8M9XVKFN/YffND5hb4336x8cx0AAHyFx1/aCwgI0OOPP64NGzY4Hd+2bZsCAwNN6RK6/I19yfmFvnvv5QU/AIBv83gLv0mTJkpISND69esVGhqqHj16yGaz6YUXXlBCQoJatWrl6ZLK39h3tPDHjSv779Ix+86drTeGDwDwH6aM4c+fP18RERF68803lZaWpoiICM2YMUMPPfSQGeVUuRPepcHOxjkAAF9mSuAHBQVp0qRJmjRpkhm3rxSBDgDwZ+yWBwCABRD4AABYAIEPAIAFEPgAAFgAgQ8AgAUQ+AAAWACBDwCABRD4AABYAIEPAIAFEPgAAFgAgQ8AgAUQ+AAAWACBDwCABRD4AABYAIEPAIAFEPgAAFgAgQ8AgAUQ+AAAWACBDwCABRD4AABYAIEPAIAFEPgAAFgAgQ8AgAUQ+AAAWACBDwCABRD4AABYAIEPAIAFEPgAAFgAgQ8AgAUQ+AAAWACBDwCABRD4AABYAIEPAIAFEPgAAFgAgQ8AgAUQ+AAAWACBDwCABRD4AABYAIEPAIAFEPgAAFgAgQ8AgAWYFvjvvfeehgwZoi5dumjQoEHasmWLWaUAAOD3TAn8bdu2ae7cuerdu7dWrVqlnj17av78+Xr//ffNKAcAAL9X34ybLl++XIMGDdLChQslSbfddpt+/PFHPfvssxo4cKAZJQEA4Nc83sLPzc1VTk6O7rzzTqfjAwYM0NGjR5Wbm+vpkgAA8Hseb+EfPXpUktSmTRun461atZIkHTt2TC1atKj2GhcvXpQkfffdd26oEA75+fnKy8szuwy/xjP2DJ6z+/GM3cuRd478qwuPB/7p06clSaGhoU7HGzVqJEk6c+bMFa+Rn58vSUpISDC4OgAAvFd+fn55A7m2PB74dru92vP16l15lCEmJkbp6elq1qyZAgMDjSoNAACvdPHiReXn5ysmJqbO1/B44IeFhUmSCgsLnY47WvaO89UJCQlRjx49jC8OAAAvVdeWvYPHX9pzjN3n5OQ4Hf/666+dzgMAAON4PPBbtWqlqKioCnPud+7cqdatW+u6667zdEkAAPg9U+bhJyUlaeHChWrcuLH69OmjXbt2afv27Vq+fLkZ5QAA4PcC7Fd6i85N/vu//1tr167Vt99+qxYtWmjy5Mm65557zCgFAAC/Z1rgAwAAz2G3PAAALIDABwDAAgh8AAAswOcC/7333tOQIUPUpUsXDRo0SFu2bDG7JL9SWlqqjRs3atiwYerevbv69++vJUuW1GjJY9TNI488ovj4eLPL8Ev/+Mc/NHr0aHXt2lW9e/fWokWLKiz6Bdds3LhRgwYNUrdu3TRs2DBt3brV7JL8xqFDh9SpU6cK+8bs3btX9957r7p27aq+fftq7dq1NbqeTwX+tm3bNHfuXPXu3VurVq1Sz549NX/+/Apz+lF3q1ev1qJFi9SnTx+tWrVKiYmJ2rJlix599FGzS/NL77zzjv7yl7+YXYZf+uc//6nExEQ1a9ZMzz//vJKSkrR161YlJyebXZrf2LRpk5544gn16dNHzz33nHr16qVf//rX2r59u9ml+bwvv/xSU6ZMUUlJidPxAwcOaOrUqWrbtq1SU1M1bNgwLVu2TGvWrLniNX3qLf34+HjFxMQ4zdefOXOmsrOz+R+YAex2u26++WYNGTJEv/vd78qPb9u2TbNmzdKWLVt0ww03mFihfzlx4oSGDRumhg0bKjg4mOA32JgxYyRJ69evV0BAgCQpPT1dL7/8st599101bNjQzPL8wv3336/g4GCtW7eu/FhCQoLq1aun9evXm1iZ7yopKdGmTZv0zDPPKCgoSKdOndIHH3ygyMhISdL48eN19uxZvf766+Xfeeqpp/T6669r3759Cg4OrvLaPtPCz83NVU5Oju68806n4wMGDNDRo0eVm5trUmX+o7CwUHfddZeGDh3qdLxt27aSKi6HDNckJyfr1ltvVVxcnNml+J3vv/9e+/fv1+jRo8vDXioLo4yMDMLeIEVFReU7nTpcffXVOnXqlDkF+QGbzaann35aEyZM0Ny5c53OFRUVaf/+/ZXm4E8//aQDBw5Ue22fCfyjR49KqrjWvmMzgWPHjnm8Jn8TGhqq5ORkxcbGOh3PyMiQJF1//fVmlOWXNm/erM8//1y//e1vzS7FLx05ckR2u12NGzfWzJkz1a1bN8XGxup3v/udzp8/b3Z5fmPcuHH68MMPtX37dp05c0bvv/++9uzZo7vvvtvs0nxWdHS0MjIy9Mgjj1TYDTY3N1fFxcV1zkFTltati9OnT0sqC6VLOX675KUy9/j000+Vlpam/v37Kzo62uxy/MLx48e1ZMkSLVmyRE2aNDG7HL/0/fffS5IWLFig+Ph4Pf/888rOztaKFStUVFSkpUuXmlyhfxgyZIj+/ve/a+bMmeXHhg8froceesi8onzcNddcU+U5V3PQZwL/Sq8a1KvnM50VPsNms2nq1KmKiorS4sWLzS7HL9jtdj322GO64447NGDAALPL8VvFxcWSpBtvvLH8fZS4uDjZ7Xb98Y9/VFJSklq0aGFmiX5h2rRp+uSTT7Rw4UJ17NhRn376qZ577rny3kIYy9Uc9JmUDAsLk6QKU2ocv9E4zsMY27ZtU2Jioq699lq98sorCg8PN7skv5Cenq7s7Gw99thjKikpUUlJSfn/iS/9O1zjaPHcfvvtTsd79+4tu92u7OxsM8ryKwcOHNDevXuVnJys8ePHq2fPnpo0aZIWLFig9evX68iRI2aX6HdczUGfCXzHmMXlL459/fXXTufhupdfflmzZ89Wt27dlJ6erp///Odml+Q3duzYoR9++EG9e/dWp06d1KlTJ23ZskU5OTnq1KmT3n77bbNL9AutW7eWJF24cMHpuKPlf+mLfKibb775RlJZL8qlevToIUn64osvPF6Tv2vZsqUCAwMr5KDj31fKQZ8J/FatWikqKqrCnPudO3eqdevWuu6660yqzL9s3rxZS5cu1aBBg7R69Wp6Tgz2+9//Xm+88YbTf7/85S8VGRlZ/ne4Ljo6Ws2bN9e2bducjv/1r39V/fr11b17d5Mq8x+OcLHZbE7H//nPf0qSmjdv7umS/F6DBg3Uo0cP7dy506k3cMeOHQoLC1NMTEy13/eZMXxJSkpK0sKFC9W4cWP16dNHu3bt0vbt253m5aPuCgoK9OSTT6p58+ZKSEjQv/71L6fzLVu25CUzFzmmOF7q6quvVnBwsDp37mxCRf4pICBAc+fO1ezZszV37lyNGDFCWVlZev755zVmzBj+d2yATp06qX///nryySd1+vRp3XDDDcrKytKqVat0++23q2vXrmaX6JemTZumxMREzZo1S8OHD9cnn3yiNWvWaM6cOVecbupTgT9ixAhduHBBa9eu1ebNm9WiRQv98Y9/1ODBg80uzS98+OGHOnfunI4fP66EhIQK55ctW8Z0G/iMwYMHKzg4WKtWrdKUKVPUtGlTJSUlacqUKWaX5jeWL1+ulStX6pVXXlFBQYGaN2+uCRMmaPLkyWaX5rfi4uKUmpqqlJQUJSUlKSIiQvPmzdOECROu+F2fWmkPAADUjc+M4QMAgLoj8AEAsAACHwAACyDwAQCwAAIfAAALIPABALAAAh8AAAsg8AEAsAACH4CTDz74QO3bt1dKSkqFc4WFhRo+fLhiYmL08ccfm1AdgLoi8AE4ueOOO3TDDTdow4YN5dtuStLFixc1a9YsHTp0SEuXLlXPnj1NrBJAbRH4ACqYOnWqfvzxR23cuLH82KJFi/TBBx9o1qxZGjp0qInVAagL1tIHUEFpaamGDBmin376Sbt379b69ev11FNP6b777tOiRYvMLg9AHRD4ACq1ZcsWzZ8/X/369dPu3bvVu3dvvfDCC6pf36c22QTwbwQ+gEqVlJTozjvv1PHjx8vH9ENDQ80uC0AdMYYPoFJ5eXk6e/asJGnkyJGEPeDjaOEDqOD777/XqFGj9OOPPyooKEg/+9nP9P777yswMLDCZ7dt26b169fr8OHDCg8P1+7du02oGMCV0MIH4OTcuXOaMmWKvv32W61atUoPPfSQcnJytG3btko/37hxY40ZM0YzZ870bKEAaoXAB1Du4sWLmj17tj777DMtXbpUN910k+6//36Fh4crLS1NlXUI3nrrrRoyZIiaN29uQsUAaorAB1Bu8eLF2r17t9Nc+4YNG2r8+PE6cuSIdu3aZXKFAOqKwAcgSXrppZf02muv6b777tOUKVOczo0ZM0ZXXXWVnn/+eZOqA+AqAh+A/vznP+uZZ57Rbbfdpt/97ncVzoeGhmrMmDHKysrS3r17TagQgKt4Sx+AITIyMvSHP/yBt/QBL8WSWQBccvHiRZWUlKi4uFh2u11FRUUKCAhQcHCw2aUBuAQtfAAueeutt7Rw4UKnY82bN6elD3gZAh8AAAvgpT0AACyAwAcAwAIIfAAALIDABwDAAgh8AAAsgMAHAMACCHwAACzg/wGNdQCRqLJBjgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's visualise\n",
    "\n",
    "make_plot(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper function to add dummy feature to our feature matrix\n",
    "\n",
    "def add_dummy_feature(x):\n",
    "    '''   \n",
    "    Adds dummy feature to the dataset.\n",
    "\n",
    "        Args:\n",
    "            x: Training dataset\n",
    "\n",
    "        Returns:\n",
    "            Training dataset with an addition of dummy feature\n",
    "\n",
    "    '''\n",
    "    return np.column_stack((np.ones(x.shape[0]), x))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_add_dummy_feature (__main__.TestAddDummyFeature)\n",
      "Test case function for add_dummy_feature ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.002s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x1c73f2e8b50>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Testing\n",
    "\n",
    "import unittest\n",
    "\n",
    "class TestAddDummyFeature(unittest.TestCase):\n",
    "\n",
    "    def test_add_dummy_feature(self):\n",
    "        ''' Test case function for add_dummy_feature'''\n",
    "\n",
    "        train_matrix = np.array([[3,2,5],[9,4,7]])\n",
    "        train_matrix_with_dummy_feature = add_dummy_feature(train_matrix)\n",
    "\n",
    "        #test the shape\n",
    "        self.assertEqual(train_matrix_with_dummy_feature.shape, (2,4))\n",
    "\n",
    "        # and contents\n",
    "        np.testing.assert_array_equal(train_matrix_with_dummy_feature,np.array([[1,3,2,5],[1,9,4,7]]))\n",
    "         \n",
    "unittest.main(argv=[''], defaultTest='TestAddDummyFeature', verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before adding dummy feature:\n",
      " [4.84837015 7.90996557 1.18285481 0.78349442 1.39000645]\n",
      "\n",
      "\n",
      "After adding dummy feature:\n",
      " [[1.         4.84837015]\n",
      " [1.         7.90996557]\n",
      " [1.         1.18285481]\n",
      " [1.         0.78349442]\n",
      " [1.         1.39000645]]\n"
     ]
    }
   ],
   "source": [
    "# Let's add dummy feature to training set\n",
    "print(\"Before adding dummy feature:\\n\", X_train[:5])\n",
    "print(\"\\n\")\n",
    "\n",
    "X_train_with_dummy = add_dummy_feature(X_train)\n",
    "\n",
    "print(\"After adding dummy feature:\\n\", X_train_with_dummy[:5,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(X,w):\n",
    "    '''\n",
    "    Prediction of ouotput label for a given input\n",
    "\n",
    "    Args:\n",
    "        X: Feature matrix of shape (n, m+1).\n",
    "        w: weight vector of shape (m+1,)\n",
    "\n",
    "    Returns:\n",
    "        y: Predicted label vector of shape (n,) \n",
    "\n",
    "    '''\n",
    "    #check to make sure the feature matrix and weight vector have compatible shapes\n",
    "    assert X.shape[-1] == w.shape[0], \"X and w don't have compatible dimensions\"\n",
    "    return X @ w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_predict (__main__.TestPredict)\n",
      "Test case predict function of linear regression ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.002s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x1c73f24c820>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's test the function\n",
    "import unittest\n",
    "\n",
    "class TestPredict(unittest.TestCase):\n",
    "\n",
    "    def test_predict(self):\n",
    "        '''Test case predict function of linear regression'''\n",
    "        # Set up\n",
    "        train_matrix = np.array([[1,3,2,5],[1,9,4,7]])\n",
    "        weight_vector = np.array([1,1,1,1])\n",
    "        expected_label_vector = np.array([11,21])\n",
    "\n",
    "        #call\n",
    "        predicted_label_vector = predict(train_matrix, weight_vector)\n",
    "\n",
    "        #asserts\n",
    "        #test the shape\n",
    "        self.assertEqual(predicted_label_vector.shape, (2,))\n",
    "\n",
    "        # and the contents\n",
    "        np.testing.assert_array_equal(expected_label_vector, predicted_label_vector)\n",
    "\n",
    "unittest.main(argv=[''], defaultTest='TestPredict', verbosity=2, exit=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Demonstration on synthetic dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.84371484, 0.08406513])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Randomly initialise weight vector \n",
    "\n",
    "w = np.random.rand(2,)\n",
    "w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predicted labels\n",
    "\n",
    "y_hat = predict(X_train_with_dummy, w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.25129369, 1.5086671 , 0.94315168, 0.9095794 , 0.96056591,\n",
       "       1.25969056, 1.19456708, 1.66179871, 1.10668616, 1.57518569])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_hat[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([33.05413045, 29.21693778, 30.77271757, 20.05794122, 31.28789829,\n",
       "        5.15471063, 15.15501549, 16.74192119, 25.45752211, 15.6535051 ])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loss function implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss(X, y, w):\n",
    "    '''Calculates loss for a model based on known labels\n",
    "    \n",
    "    Args:\n",
    "        X: Feature matrix for given inputs\n",
    "        y: Output label vector as predicted by the given model\n",
    "        w: Weight vector\n",
    "\n",
    "    Returns:\n",
    "        Loss\n",
    "    '''\n",
    "\n",
    "    err = predict(X,w) - y\n",
    "\n",
    "    return (1/2)*(np.transpose(err) @ err)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_loss_function (__main__.TestLossFunction)\n",
      "Test case for loss function of linear regression ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.003s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x1c73d1a26e0>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test cases\n",
    "\n",
    "class TestLossFunction((unittest.TestCase)):\n",
    "    \n",
    "    def test_loss_function(self):\n",
    "        '''Test case for loss function of linear regression'''\n",
    "\n",
    "        # Set up\n",
    "        feature_matrix = np.array([[1,3,2,5],[1,9,4,7]])\n",
    "        weight_vector = np.array([1,1,1,1])\n",
    "        label_vector = np.array([6,11])\n",
    "        expected_loss = np.array([62.5])\n",
    "\n",
    "        # call\n",
    "        loss_value = loss(feature_matrix, label_vector, weight_vector)\n",
    "\n",
    "        #asserts\n",
    "        #test the shape\n",
    "        self.assertEqual(loss_value.shape, ())\n",
    "\n",
    "        #and contents\n",
    "        np.testing.assert_array_equal(expected_loss, loss_value)\n",
    "\n",
    "unittest.main(argv=[''], defaultTest = 'TestLossFunction', verbosity = 2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's generate some data\n",
    "\n",
    "X, y = generate_data(100)\n",
    "\n",
    "# Function to preprocess, Add dummy feature, test-train split\n",
    "\n",
    "def preprocess(x, y):\n",
    "\n",
    "    X = add_dummy_feature(x)\n",
    "\n",
    "    return train_test_split(X, y)\n",
    "\n",
    "X_train, X_test, y_train, y_test = preprocess(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Normal Equation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normal_equation(X,y):\n",
    "    '''Estimates parameters of the linear regression model with normal equation.\n",
    "    \n",
    "    Args: \n",
    "        X: Feature matrix for given inputs.\n",
    "        y: Actual label vector.\n",
    "\n",
    "    Returns:\n",
    "        Weight vector\n",
    "    '''\n",
    "\n",
    "    return np.linalg.pinv(X) @ y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_normal_equation (__main__.TestNormalEquation)\n",
      "Test case for weeight estimation for linear regression with Normal equation method ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.008s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x1c73f2eae60>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "class TestNormalEquation(unittest.TestCase):\n",
    "    \n",
    "    def test_normal_equation(self):\n",
    "        '''\n",
    "            Test case for weeight estimation for linear regression with Normal equation method\n",
    "        ''' \n",
    "\n",
    "        #Set up\n",
    "\n",
    "        feature_matrix = X_train\n",
    "        label_vector = y_train\n",
    "        expected_weight_vector = np.array([4., 3.])\n",
    "\n",
    "        #call\n",
    "        estimated_weight_vector = normal_equation(feature_matrix, label_vector)\n",
    "\n",
    "        #asserts\n",
    "        #test the shape\n",
    "        self.assertEqual(estimated_weight_vector.shape, (2,))\n",
    "\n",
    "        #and contents\n",
    "        np.testing.assert_array_almost_equal(estimated_weight_vector, expected_weight_vector, decimal=0)\n",
    "\n",
    "unittest.main(argv=[''], defaultTest='TestNormalEquation', verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gradient Descent(GD)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Gradient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_gradient(X, y, w):\n",
    "    '''Calculates gradients of loss dunction wrt weight vector on training set\n",
    "    \n",
    "    Arguments:\n",
    "\n",
    "        X: Feature matrix for training data.\n",
    "        y: Label vector for training data\n",
    "        w: Weight vector\n",
    "\n",
    "    Returns:\n",
    "        A vector of gradients.\n",
    "    '''\n",
    "\n",
    "    return np.transpose(X) @ (predict(X, w) - y)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_calculate_gradient (__main__.TestCalculateGradient)\n",
      "Test case for gradient descent ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.003s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x1c73f5ea440>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class TestCalculateGradient(unittest.TestCase):\n",
    "\n",
    "    def test_calculate_gradient(self):\n",
    "\n",
    "        '''\n",
    "        Test case for gradient descent\n",
    "        '''\n",
    "\n",
    "        #Set up\n",
    "        feature_matrix = np.array([[1,3,2,5],[1,9,4,7]])\n",
    "        weight_vector = np.array([1,1,1,1])\n",
    "        label_vector = np.array([6,11])\n",
    "        expected_grad = np.array([15,105,50,95])\n",
    "\n",
    "        #Call\n",
    "        grad = calculate_gradient(feature_matrix, label_vector, weight_vector)\n",
    "\n",
    "        #asserts\n",
    "        #test the shape\n",
    "        self.assertEqual(grad.shape, (4, ))\n",
    "\n",
    "        #and contents\n",
    "        np.testing.assert_array_almost_equal(expected_grad, grad, decimal=0)\n",
    "\n",
    "unittest.main(argv=[''], defaultTest='TestCalculateGradient', verbosity=2,exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Weight Updates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_weights(w, grad, lr):\n",
    "    '''\n",
    "    Updates the weights based on the gradient of loss function.\n",
    "\n",
    "    Weight updates are carried out with the fiollowing formula:\n",
    "        w_new := w_old - lr * grad\n",
    "\n",
    "    Args:\n",
    "        1. w: Weight vector\n",
    "        2. grad: gradient of loss w.r.t w\n",
    "        3. lr: learning rate\n",
    "\n",
    "    Returns:\n",
    "        Updated weight vector\n",
    "    '''\n",
    "\n",
    "    return (w - lr*grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_update_weight (__main__.TestUpdateWeights) ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.002s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x1c73f5ea6e0>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class TestUpdateWeights(unittest.TestCase):\n",
    "\n",
    "    def test_update_weight(self):\n",
    "\n",
    "        #setup\n",
    "        weight_vector = np.array([1,1,1,1])\n",
    "        grad_vector = np.array([15, 105, 50, 95])\n",
    "        lr = 0.001\n",
    "        expected_w_new = np.array([0.985, 0.895, 0.95, 0.905])\n",
    "\n",
    "        #call\n",
    "        w_new = update_weights(weight_vector, grad_vector, lr)\n",
    "\n",
    "        #asserts\n",
    "        # test the shape\n",
    "        self.assertEqual(expected_w_new.shape, (4, ))\n",
    "\n",
    "        #and contents\n",
    "        np.testing.assert_array_almost_equal(expected_w_new, w_new, decimal=1)\n",
    "\n",
    "unittest.main(argv=[''], defaultTest='TestUpdateWeights', verbosity=2, exit=False) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_descent(X:np.ndarray, y:np.ndarray, lr:float, num_epochs:int):\n",
    "    '''Estimates parameters of linear regression model through gradient descent.\n",
    "    \n",
    "    Arguments:\n",
    "        X: Feature matrix for training data\n",
    "        y: Label vector for training data\n",
    "        lr: learning rate\n",
    "        num_epochs: Number of training steps\n",
    "\n",
    "    Returns:\n",
    "        Weight vector: Final weight vector\n",
    "        Error vector across different iterations\n",
    "        Weight vectors acrss different iterations\n",
    "    '''\n",
    "\n",
    "    w_all = [] #all paramenter across iterations\n",
    "    err_all = [] # all arrors across iterations\n",
    "\n",
    "    # parameter vector initialised to zero\n",
    "    w = np.zeros((X.shape[1]))\n",
    "\n",
    "    #Gradient descent loop\n",
    "    print()\n",
    "    for i in np.arange(0, num_epochs):\n",
    "        w_all.append(w)\n",
    "\n",
    "        #calculate arror due to the current weight vector:\n",
    "        err_all.append(loss(X, y, w))\n",
    "\n",
    "        #Gradient Calulation\n",
    "        dJdW = calculate_gradient(X, y, w)\n",
    "\n",
    "        # Print stats every 100 iterations\n",
    "        if (i%100) == 0:\n",
    "            print(\"iteration #: %d, loss: %4.2f\" %(i, err_all[-1]))\n",
    "\n",
    "        #Weight vector update.\n",
    "        w = update_weights(w, dJdW, lr)\n",
    "\n",
    "    return w, err_all, w_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_gradient_descend (__main__.TestGradientDescent)\n",
      "Test case for weight estimation for linear regression with gradient descent method ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.032s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "iteration #: 0, loss: 17744.10\n",
      "iteration #: 100, loss: 118.17\n",
      "iteration #: 200, loss: 90.00\n",
      "iteration #: 300, loss: 70.97\n",
      "iteration #: 400, loss: 58.11\n",
      "iteration #: 500, loss: 49.41\n",
      "iteration #: 600, loss: 43.54\n",
      "iteration #: 700, loss: 39.57\n",
      "iteration #: 800, loss: 36.89\n",
      "iteration #: 900, loss: 35.08\n",
      "iteration #: 1000, loss: 33.85\n",
      "iteration #: 1100, loss: 33.03\n",
      "iteration #: 1200, loss: 32.47\n",
      "iteration #: 1300, loss: 32.09\n",
      "iteration #: 1400, loss: 31.84\n",
      "iteration #: 1500, loss: 31.66\n",
      "iteration #: 1600, loss: 31.55\n",
      "iteration #: 1700, loss: 31.47\n",
      "iteration #: 1800, loss: 31.41\n",
      "iteration #: 1900, loss: 31.38\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x1c73f24c460>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class TestGradientDescent(unittest.TestCase):\n",
    "\n",
    "    def test_gradient_descend(self):\n",
    "        '''\n",
    "        Test case for weight estimation for linear regression with gradient descent method\n",
    "        '''\n",
    "\n",
    "        # Set up\n",
    "        feature_matrix = X_train\n",
    "        label_vector = y_train\n",
    "        expected_weights = np.array([4., 3.])\n",
    "\n",
    "        #call\n",
    "        w, err_all, w_all = gradient_descent(feature_matrix, label_vector, lr=0.0001, num_epochs=2000)\n",
    "\n",
    "        #asserts\n",
    "        #test the shape\n",
    "        self.assertEqual(w.shape, (2, ))\n",
    "\n",
    "        #and contents\n",
    "        np.testing.assert_array_almost_equal(expected_weights, w, decimal=0)\n",
    "\n",
    "unittest.main(argv=[''], defaultTest='TestGradientDescent', verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Model trajectory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "iteration #: 0, loss: 17744.10\n",
      "iteration #: 100, loss: 213.06\n"
     ]
    }
   ],
   "source": [
    "w, err_all, w_all = gradient_descent(X_train, y_train, lr = 0.00001, num_epochs=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function matplotlib.pyplot.show(close=None, block=None)>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_b = np.c_[np.ones((X.shape[0], 1)), X] # add X0 = 1 to each instance\n",
    "X_new = np.array([[0],[10]])\n",
    "X_new_b = np.c_[np.ones((2, 1)), X_new] # add x0 =1 to each instance\n",
    "\n",
    "for j in range(0, len(w_all)):\n",
    "    if j%10 != 0: continue\n",
    "    y_hat = predict(X_new_b, w_all[j])\n",
    "    style = \"b-\" if j > 0 else \"r--\"\n",
    "    plt.plot(X_new_b[:,1], y_hat, style)\n",
    "\n",
    "plt.plot(X_train[:, 1], y_train, \"b.\")\n",
    "plt.xlabel(\"$x_1$\", fontsize=18)\n",
    "plt.ylabel(\"$y$\", rotation=0, fontsize=18) \n",
    "plt.title('Gradient Descent', fontsize=18)\n",
    "plt.axis([0,10,0,40])\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_learning_curve(err_all):\n",
    "    plt.plot(err_all)\n",
    "    plt.xlabel('Iteration #')\n",
    "    plt.ylabel('Loss: $J(\\mathbf{w})$')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "iteration #: 0, loss: 17744.10\n",
      "iteration #: 100, loss: 118.17\n",
      "iteration #: 200, loss: 90.00\n",
      "iteration #: 300, loss: 70.97\n",
      "iteration #: 400, loss: 58.11\n",
      "iteration #: 500, loss: 49.41\n",
      "iteration #: 600, loss: 43.54\n",
      "iteration #: 700, loss: 39.57\n",
      "iteration #: 800, loss: 36.89\n",
      "iteration #: 900, loss: 35.08\n",
      "iteration #: 1000, loss: 33.85\n",
      "iteration #: 1100, loss: 33.03\n",
      "iteration #: 1200, loss: 32.47\n",
      "iteration #: 1300, loss: 32.09\n",
      "iteration #: 1400, loss: 31.84\n",
      "iteration #: 1500, loss: 31.66\n",
      "iteration #: 1600, loss: 31.55\n",
      "iteration #: 1700, loss: 31.47\n",
      "iteration #: 1800, loss: 31.41\n",
      "iteration #: 1900, loss: 31.38\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "w, err_all, w_all = gradient_descent(X_train, y_train, lr = 0.0001, num_epochs=2000 )\n",
    "plot_learning_curve(err_all)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variations of GD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = generate_data(100)\n",
    "X_train, X_test, y_train, y_test = preprocess(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mini Batch Gradient Descent(MBGD)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "t0, t1 = 200, 100000\n",
    "\n",
    "def learning_schedule(t):\n",
    "    return t0/(t + t1)\n",
    "\n",
    "def mini_batch_gd(X: np.ndarray, y: np.ndarray, num_iters: int, minibatch_size: int):\n",
    "\n",
    "    '''Estimates parametrs of linear regression model through gradient descent.\n",
    "    \n",
    "    Args:\n",
    "        1. X: Feature matrix for training data.\n",
    "        2. y: Label vector for training data.\n",
    "        3. num_iters: Number of iterations.\n",
    "\n",
    "    Returns:\n",
    "        Weight vector: Final weight vector\n",
    "        Error vector across different iterations\n",
    "        Weight vector acosss different iterations\n",
    "    '''\n",
    "\n",
    "    w_all = [] # all parameters across iterations.\n",
    "    err_all = [] # error across iterations\n",
    "\n",
    "    # Parameter vector initialised to [0,0]\n",
    "    w = np.zeros((X.shape[1]))\n",
    "    t = 0\n",
    "\n",
    "    for epoch in range(num_iters):\n",
    "        shuffled_indices = np.random.permutation(X.shape[0])\n",
    "        X_shuffled = X[shuffled_indices]\n",
    "        y_shuffled = y[shuffled_indices]\n",
    "\n",
    "        for i in range(0, X.shape[0], minibatch_size):\n",
    "            t += 1\n",
    "            xi = X_shuffled[i:i+minibatch_size]\n",
    "            yi = y_shuffled[i:i+minibatch_size]\n",
    "            err_all.append(loss(xi, yi, w))\n",
    "\n",
    "            gradients = 2/minibatch_size * calculate_gradient(xi, yi, w)\n",
    "            lr = learning_schedule(t)\n",
    "\n",
    "            w = update_weights(w, gradients, lr)\n",
    "            w_all.append(w)\n",
    "\n",
    "    return w, err_all, w_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "TestMiniBatchGradientDescent (unittest.loader._FailedTest) ... ERROR\n",
      "\n",
      "======================================================================\n",
      "ERROR: TestMiniBatchGradientDescent (unittest.loader._FailedTest)\n",
      "----------------------------------------------------------------------\n",
      "AttributeError: module '__main__' has no attribute 'TestMiniBatchGradientDescent'\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.001s\n",
      "\n",
      "FAILED (errors=1)\n"
     ]
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "class TestMiniBatchGradientDescent(unittest.TestCase):\n",
    "    \n",
    "    def test_minibatch_gd(self):\n",
    "        '''\n",
    "        Test case for weight estimation for linear regression with minibatch gradient descent method.\n",
    "        '''\n",
    "\n",
    "        #set up\n",
    "        feature_matrix = X_train\n",
    "        label_vector = y_train\n",
    "        expected_weights = np.array([4., 3.])\n",
    "\n",
    "        #call\n",
    "        w, err_all, w_all = mini_batch_gd(feature_matrix, label_vector, 200, 8)\n",
    "\n",
    "        #asserts\n",
    "        #test the shape\n",
    "        self.assertEqual(w.shape, (2, ))\n",
    "\n",
    "        # And contents\n",
    "        np.testing.assert_almost_equal(expected_weights, w, decimal=0)\n",
    "    \n",
    "    unittest.main(argv=[''], defaultTest='TestMiniBatchGradientDescent', verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# learning curves\n",
    "\n",
    "w, err_all, w_all = mini_batch_gd(X_train, y_train, 20, 8)\n",
    "plot_learning_curve(err_all)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1c73f79d660>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# different batch sizes\n",
    "\n",
    "batch_sizes = [1, 2, 4, 8, 16, 32, 64]\n",
    "mbgd_stats = {}\n",
    "\n",
    "for batch_size in batch_sizes:\n",
    "    w, err_all, w_all = mini_batch_gd(X_train, y_train, 100, batch_size)\n",
    "    mbgd_stats[batch_size] = err_all\n",
    "    legend = 'batch size: %d' %batch_size\n",
    "    plt.plot(err_all, label=legend)\n",
    "\n",
    "plt.xlabel('iteration #')\n",
    "plt.ylabel('Loss: $J(\\mathbf{w})$')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stochastic Gradient Descent(MBGD)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sgd(X: np.ndarray, y: np.ndarray, num_epochs: int):\n",
    "\n",
    "    '''Estimates parametrs of linear regression model through stochastic gradient descent.\n",
    "    \n",
    "    Args:\n",
    "        1. X: Feature matrix for training data.\n",
    "        2. y: Label vector for training data.\n",
    "        3. num_epochs: Number of epochs.\n",
    "\n",
    "    Returns:\n",
    "        Weight vector: Final weight vector\n",
    "        Error vector across different iterations\n",
    "        Weight vector acosss different iterations\n",
    "    '''\n",
    "\n",
    "    w_all = [] # all parameters across iterations.\n",
    "    err_all = [] # error across iterations\n",
    "\n",
    "    # Parameter vector initialised to [0,0]\n",
    "    w = np.zeros((X.shape[1]))\n",
    "\n",
    "    for epoch in range(num_epochs):\n",
    "        for i in range(X.shape[0]):\n",
    "            random_index = np.random.randint(X.shape[0])\n",
    "            xi = X[random_index: random_index + 1]\n",
    "            yi = y[random_index: random_index + 1]\n",
    "            err_all.append(loss(xi, yi, w))\n",
    "\n",
    "            gradients = 2 * calculate_gradient(xi, yi, w)\n",
    "            lr = learning_schedule(epoch * X.shape[0] + i)\n",
    "\n",
    "            w = update_weights(w, gradients, lr)\n",
    "            w_all.append(w)\n",
    "\n",
    "    return w, err_all, w_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_minibatch_gd (__main__.TestMiniBatchGradientDescent)\n",
      "Test case for weight estimation for linear regression with minibatch gradient descent method. ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.064s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "class TestStochasticGradientDescent(unittest.TestCase):\n",
    "    \n",
    "    def test_sgd(self):\n",
    "        '''\n",
    "        Test case for weight estimation for linear regression with stochastic gradient descent method.\n",
    "        '''\n",
    "\n",
    "        #set up\n",
    "        feature_matrix = X_train\n",
    "        label_vector = y_train\n",
    "        expected_weights = np.array([4., 3.])\n",
    "\n",
    "        #call\n",
    "        w, err_all, w_all = sgd(feature_matrix, label_vector, 200, 8)\n",
    "\n",
    "        #asserts\n",
    "        #test the shape\n",
    "        self.assertEqual(w.shape, (2, ))\n",
    "\n",
    "        # And contents\n",
    "        np.testing.assert_almost_equal(expected_weights, w, decimal=0)\n",
    "    \n",
    "    unittest.main(argv=[''], defaultTest='TestMiniBatchGradientDescent', verbosity=2, exit=False)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "w, err_all, w_all = sgd(X_train, y_train, 10)\n",
    "plot_learning_curve(err_all)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## End to end implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinReg(object):\n",
    "    '''\n",
    "    Linear regression Model\n",
    "    ------------------------------------\n",
    "    y = X@w\n",
    "    X: A feature matrix\n",
    "    w: weight vector\n",
    "    y; Label Vector\n",
    "    '''\n",
    "\n",
    "    def __init__(self):\n",
    "        self.t0 = 200\n",
    "        self.t1 = 100000\n",
    "\n",
    "    def predict(self, X:np.ndarray) -> np.ndarray:\n",
    "        ''' Prediction of ouotput label for a given input\n",
    "\n",
    "            Args:\n",
    "                X: Feature matrix of shape (n, m+1).\n",
    "                w: weight vector of shape (m+1,)\n",
    "\n",
    "            Returns:\n",
    "                y: Predicted label vector of shape (n,) \n",
    "\n",
    "        '''\n",
    "\n",
    "        y = X @ self.w\n",
    "        return y\n",
    "\n",
    "    def loss(self, X: np.ndarray, y: np.ndarray) -> float:\n",
    "        '''Calculates loss for a model based on known labels\n",
    "    \n",
    "        Args:\n",
    "            X: Feature matrix for given inputs\n",
    "            y: Output label vector as predicted by the given model\n",
    "            w: Weight vector\n",
    "\n",
    "        Returns:\n",
    "            Loss\n",
    "        '''\n",
    "\n",
    "        err = self.predict(X) - y\n",
    "        return (1/2)*(np.transpose(err) @ err)\n",
    "\n",
    "    def rmse(self, X: np.ndarray, y: np.ndarray) -> float:\n",
    "        '''Calculate root mean square error of prediction wrt actual label.\n",
    "        \n",
    "        Args:\n",
    "            X: Feature matrix for the given inputs\n",
    "            y: output label vector as predicted by the given model\n",
    "\n",
    "        Returns:\n",
    "            Loss\n",
    "        '''\n",
    "\n",
    "        return np.sqrt((2/X.shape[0]) * self.loss(X, y))\n",
    "\n",
    "    def fit(self, X:np.ndarray, y:np.ndarray) -> float:\n",
    "        '''Estimates parameters of the linear regression model with normal equation.\n",
    "    \n",
    "        Args: \n",
    "            X: Feature matrix for given inputs.\n",
    "            y: Actual label vector.\n",
    "\n",
    "        Returns:\n",
    "            Weight vector\n",
    "        '''\n",
    "        self.w = np.linalg.pinv(X) @ y \n",
    "        return self.w\n",
    "\n",
    "    def calculate_gradient(self, X:np.ndarray, y:np.ndarray) -> np.ndarray:\n",
    "        '''Calculates gradients of loss dunction wrt weight vector on training set\n",
    "    \n",
    "        Arguments:\n",
    "\n",
    "            X: Feature matrix for training data.\n",
    "            y: Label vector for training data\n",
    "            w: Weight vector\n",
    "\n",
    "        Returns:\n",
    "            A vector of gradients.\n",
    "        '''\n",
    "\n",
    "        return np.transpose(X) @ (self.predict(X) - y)\n",
    "    \n",
    "    def update_weights(self, grad: np.ndarray, lr: float) -> np.ndarray:\n",
    "        '''\n",
    "        Updates the weights based on the gradient of loss function.\n",
    "\n",
    "        Weight updates are carried out with the fiollowing formula:\n",
    "            w_new := w_old - lr * grad\n",
    "\n",
    "        Args:\n",
    "            1. w: Weight vector\n",
    "            2. grad: gradient of loss w.r.t w\n",
    "            3. lr: learning rate\n",
    "\n",
    "        Returns:\n",
    "            Updated weight vector\n",
    "        '''\n",
    "\n",
    "        return (self.w - lr*grad)\n",
    "\n",
    "    def learning_schedule(self, t) -> float:\n",
    "        lr = (self.t0) / (t + self.t1)\n",
    "        return lr\n",
    "\n",
    "    def gd(self, X:np.ndarray, y:np.ndarray, num_epochs:int, lr:float) -> np.ndarray:\n",
    "        '''Estimates parameters of linear regression model through gradient descent.\n",
    "    \n",
    "        Arguments:\n",
    "            X: Feature matrix for training data\n",
    "            y: Label vector for training data\n",
    "            lr: learning rate\n",
    "            num_epochs: Number of training steps\n",
    "\n",
    "        Returns:\n",
    "            Weight vector: Final weight vector\n",
    "            Error vector across different iterations\n",
    "            Weight vectors acrss different iterations\n",
    "        '''\n",
    "        self.w = np.zeros((X.shape[1])) # parameter vector initialised to zero\n",
    "        self.w_all = [] #all paramenter across iterations\n",
    "        self.err_all = [] # all arrors across iterations\n",
    "\n",
    "\n",
    "\n",
    "        #Gradient descent loop\n",
    "        for i in np.arange(0, num_epochs):\n",
    "\n",
    "            #Gradient Calulation\n",
    "            dJdW = self.calculate_gradient(X, y)\n",
    "\n",
    "            self.w_all.append(self.w)\n",
    "\n",
    "            #calculate arror due to the current weight vector:\n",
    "            self.err_all.append(self.loss(X, y))\n",
    "\n",
    "            #Weight vector update.\n",
    "            self.w = self.update_weights(dJdW, lr)\n",
    "\n",
    "        return self.w\n",
    "    \n",
    "    def mbgd(self, X: np.ndarray, y: np.ndarray, num_epochs: int, batch_size: int) -> np.ndarray:\n",
    "\n",
    "        '''Estimates parametrs of linear regression model through gradient descent.\n",
    "    \n",
    "        Args:\n",
    "            1. X: Feature matrix for training data.\n",
    "            2. y: Label vector for training data.\n",
    "            3. num_iters: Number of iterations.\n",
    "\n",
    "        Returns:\n",
    "            Weight vector: Final weight vector\n",
    "            Error vector across different iterations\n",
    "         Weight vector acosss different iterations\n",
    "        \n",
    "        '''\n",
    "        # Parameter vector initialised to [0,0]\n",
    "        self.w = np.zeros((X.shape[1]))\n",
    "        \n",
    "        self.w_all = [] # all parameters across iterations.\n",
    "        self.err_all = [] # error across iterations\n",
    "\n",
    "        mini_batch_id = 0\n",
    "\n",
    "        for epoch in range(num_epochs):\n",
    "            shuffled_indices = np.random.permutation(X.shape[0])\n",
    "            X_shuffled = X[shuffled_indices]\n",
    "            y_shuffled = y[shuffled_indices]\n",
    "\n",
    "            for i in range(0, X.shape[0], batch_size):\n",
    "                mini_batch_id += 1\n",
    "                xi = X_shuffled[i: i + batch_size]\n",
    "                yi = y_shuffled[i: i + batch_size]\n",
    "            \n",
    "                self.w_all.append(self.w)\n",
    "                self.err_all.append(self.loss(xi, yi))\n",
    "\n",
    "                dJdW = 2/batch_size * self.calculate_gradient(xi, yi)\n",
    "\n",
    "                self.w = self.update_weights(dJdW, self.learning_schedule(mini_batch_id))\n",
    "            \n",
    "        return self.w\n",
    "    \n",
    "    def sgd(self, X: np.ndarray, y: np.ndarray, num_epochs: int) -> np.ndarray:\n",
    "\n",
    "        '''Estimates parametrs of linear regression model through stochastic gradient descent.\n",
    "    \n",
    "        Args:\n",
    "            1. X: Feature matrix for training data.\n",
    "            2. y: Label vector for training data.\n",
    "            3. num_epochs: Number of epochs.\n",
    "\n",
    "        Returns:\n",
    "            Weight vector: Final weight vector\n",
    "            Error vector across different iterations\n",
    "            Weight vector acosss different iterations\n",
    "        '''\n",
    "\n",
    "        self.w_all = [] # all parameters across iterations.\n",
    "        self.err_all = [] # error across iterations\n",
    "\n",
    "        # Parameter vector initialised to [0,0]\n",
    "        self.w = np.zeros((X.shape[1]))\n",
    "\n",
    "        for epoch in range(num_epochs):\n",
    "            for i in range(X.shape[0]):\n",
    "                random_index = np.random.randint(X.shape[0])\n",
    "                xi = X[random_index: random_index + 1]\n",
    "                yi = y[random_index: random_index + 1]\n",
    "            \n",
    "                self. err_all.append(self.loss(xi, yi))\n",
    "                self.w_all.append(self.w)\n",
    "\n",
    "                gradients = 2 * self.calculate_gradient(xi, yi)\n",
    "                lr = self.learning_schedule(epoch * X.shape[0] + i)\n",
    "\n",
    "                self.w = self.update_weights(gradients, lr)\n",
    "            \n",
    "\n",
    "        return self.w"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Application on synthetic data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = generate_data(100)\n",
    "X_train, X_test, y_train, y_test = preprocess(X,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight vector(normal equation):  [3.93483441 3.00599003]\n"
     ]
    }
   ],
   "source": [
    "lin_reg = LinReg()\n",
    "lin_reg.fit(X_train, y_train)\n",
    "print(\"weight vector(normal equation): \", lin_reg.w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight vector(gd):  [3.61701071 3.05346857]\n"
     ]
    }
   ],
   "source": [
    "lin_reg.gd(X_train, y_train, 1000, lr=1e-4)\n",
    "print(\"weight vector(gd): \", lin_reg.w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight vector(mbgd):  [3.9245774  3.00570334]\n"
     ]
    }
   ],
   "source": [
    "lin_reg.mbgd(X_train, y_train, 1000, 16)\n",
    "print(\"weight vector(mbgd): \", lin_reg.w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight vector(sgd):  [3.98372304 2.96677878]\n"
     ]
    }
   ],
   "source": [
    "lin_reg.sgd(X_train, y_train, 1000)\n",
    "print(\"weight vector(sgd): \", lin_reg.w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Regression on multiple features and single label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import make_regression\n",
    "\n",
    "X, y, coef = make_regression(n_samples=200, n_features=10, n_informative=10, n_targets=1, shuffle=True, coef=True, noise=0.5, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of feature matrix;  (200, 10)\n",
      "Shape of label vector:  (200,)\n",
      "Shape of coef vector:  (10,)\n"
     ]
    }
   ],
   "source": [
    "print(\"shape of feature matrix; \", X.shape)\n",
    "print(\"Shape of label vector: \", y.shape)\n",
    "print(\"Shape of coef vector: \", coef.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weight vectors used to generate data:  [40.05104636 10.32532207 51.90989393  6.18447832 41.09157343 28.46940664\n",
      " 88.97621358  9.68032193 15.48694157 44.96944303]\n"
     ]
    }
   ],
   "source": [
    "print(\"Weight vectors used to generate data: \", coef)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = preprocess(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weight vector(normal eqn):  [1.65817942e-03 3.99659958e+01 1.02976703e+01 5.19228628e+01\n",
      " 6.27304055e+00 4.11664793e+01 2.84708067e+01 8.89522698e+01\n",
      " 9.74152695e+00 1.54699680e+01 4.50024647e+01]\n"
     ]
    }
   ],
   "source": [
    "lin_reg.fit(X_train, y_train) #Normal equation for weight vector estimation\n",
    "print(\"Weight vector(normal eqn): \", lin_reg.w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Check if the coefficient are close enough\n",
    "np.testing.assert_almost_equal(coef, lin_reg.w[1:], decimal=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight vector(gd):  [1.96668122e-03 3.99661060e+01 1.02980282e+01 5.19230683e+01\n",
      " 6.27378431e+00 4.11662825e+01 2.84707443e+01 8.89512465e+01\n",
      " 9.74178379e+00 1.54722782e+01 4.50025091e+01]\n"
     ]
    }
   ],
   "source": [
    "lin_reg.gd(X_train, y_train, 1000, lr=1e-4)\n",
    "print(\"weight vector(gd): \", lin_reg.w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_learning_curve(lin_reg.err_all[:1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight vector(mbgd):  [1.65054754e-03 3.99659400e+01 1.02977020e+01 5.19228330e+01\n",
      " 6.27311545e+00 4.11663973e+01 2.84707927e+01 8.89521891e+01\n",
      " 9.74155577e+00 1.54698989e+01 4.50025667e+01]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lin_reg.mbgd(X_train, y_train, 1000, 16)\n",
    "print(\"weight vector(mbgd): \", lin_reg.w)\n",
    "plot_learning_curve(lin_reg.err_all[:1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Check if the coefficient are close enough\n",
    "np.testing.assert_almost_equal(coef, lin_reg.w[1:], decimal=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight vector(mbgd):  [1.84491116e-02 3.99455615e+01 1.02920173e+01 5.19188466e+01\n",
      " 6.28595598e+00 4.11506272e+01 2.84678604e+01 8.89366816e+01\n",
      " 9.75118702e+00 1.54443298e+01 4.50166256e+01]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lin_reg.sgd(X_train, y_train, 1000)\n",
    "print(\"weight vector(mbgd): \", lin_reg.w)\n",
    "plot_learning_curve(lin_reg.err_all[:1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.testing.assert_almost_equal(coef, lin_reg.w[1:], decimal=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "369f2c481f4da34e4445cda3fffd2e751bd1c4d706f27375911949ba6bb62e1c"
  },
  "kernelspec": {
   "display_name": "Python 3.10.2 64-bit",
   "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.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}