Fixing Model, still normalization problem

11 files changed, 506 insertions, 692 deletions

diff --git a/README.md b/README.md
index 6bde654..bf5871b 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,31 @@
 
 ft\_linear\_regression project of school 42
 
-# Explaination
+## Usage
 
-Check out the jupyter notebook, markdown version [here](./notebook/ft_linear_regression_notebook.md).
+```
+cd src
+python cli.py --help
+```
+
+### Train model
+
+```
+python cli.py train
+```
+
+### Output model cost
+
+```
+python cli.py cost
+```
+
+### Plot model and dataset
+
+```
+python cli.py plot
+```
+
+## Notebook
+
+Check out the jupyter notebook where I try to explain the algorithm [here](./ft_linear_regression_notebook.ipynb).
diff --git a/ft_linear_regression_notebook.ipynb b/ft_linear_regression_notebook.ipynb
new file mode 100644
index 0000000..5f14eea
--- /dev/null
+++ b/ft_linear_regression_notebook.ipynb
@@ -0,0 +1,471 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# ft_linear_regression\n",
+    "\n",
+    "Project in which I need to build a linear regression model for a simple dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "%matplotlib inline\n",
+    "\n",
+    "data = np.genfromtxt('../data.csv', delimiter=',')[1:]\n",
+    "km = data[:, 0]\n",
+    "price = data[:, 1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "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": [
+    "def plot_data():\n",
+    "    plt.scatter(km, price)\n",
+    "    plt.xlabel(\"km\")\n",
+    "    plt.ylabel(\"price\")\n",
+    "plot_data()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This dataset contains information about cars, their cost and the the number of kilometers they've made.\n",
+    "\n",
+    "We can see just by looking at the data that their is a **linear relationship**, when the distance made diminish, the price rize.\n",
+    "\n",
+    "We can try to trace an approximate line which goes *through* the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "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": [
+    "plot_data()\n",
+    "plt.plot([200_000, 20_000], [3_500, 8_500], color='r')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can use this hypothetical line to predict new data, for example predict the price of a car knowing only it's distance traveled.\n",
+    "\n",
+    "The equation of a line is in the form:\n",
+    "\n",
+    "$$\n",
+    "\\boxed {\n",
+    "    y = \\theta_1 x + \\theta_0\n",
+    "}\n",
+    "$$\n",
+    "\n",
+    "Where $\\theta_1$ is the slope of the line and $\\theta_0$ the y-intercept. If we managed to tweak those values correctly we can find the best fitting line for our data (or at least very close to it).\n",
+    "\n",
+    "If we switch to a function, we get $h(x) = \\theta_1 x + \\theta_0$, $h$ is our **hypothesis function**."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "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": [
+    "def h(x, theta1, theta0):\n",
+    "    return x * theta1 + theta0\n",
+    "\n",
+    "theta1 = -0.03\n",
+    "theta0 = 9000\n",
+    "\n",
+    "line_xs = [km.min(), km.max()]\n",
+    "line_ys = [h(x, theta1, theta0) for x in line_xs]\n",
+    "plt.plot(line_xs, line_ys, color='r')\n",
+    "\n",
+    "plot_data()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can adjust our prediction by changing $\\theta_1$ and $\\theta_0$.\n",
+    "\n",
+    "Now, we need a way to know if our line correctly predicts the data or not, so that if not, we can slightly change it to better fit the data.\n",
+    "\n",
+    "Introducing the **error function** $J$ (also called cost function):\n",
+    "\n",
+    "$$\n",
+    "\\begin{align}\n",
+    "J(\\theta_1, \\theta_0) &= \\frac{1}{2n} \\sum_{i=1}^{n}(h(x_i) - y_i)^2 \\\\\n",
+    "                      &= \\frac{1}{2n} \\sum_{i=1}^{n}((\\theta_1 x_i + \\theta_0) - y_i)^2\n",
+    "\\end{align}\n",
+    "$$\n",
+    "\n",
+    "It's the sum of the square of the distance between what we predicted and the actual data.\n",
+    "$n$ is the number of entry we got, we divide by it to normalize the result."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def error_function(xs, ys, theta1, theta0):\n",
+    "    return (1 / (2 * len(xs))) * sum(\n",
+    "        [(h(x, theta1, theta0) - y) ** 2\n",
+    "         for x, y in zip(xs, ys)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "386217.6189791666\n"
+     ]
+    }
+   ],
+   "source": [
+    "xs = km\n",
+    "ys = price\n",
+    "\n",
+    "print(error_function(xs, ys, theta1, theta0))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The error value is pretty high, this means that the approximated line is garbage.\n",
+    "\n",
+    "The process of learning will be done by reducing this error function. To make that happen, we need to know *how* we are going to change $\\theta_1$ and $\\theta_0$.\n",
+    "\n",
+    "Here comes partial derivatives:\n",
+    "\n",
+    "$$\n",
+    "\\begin{align}\n",
+    "    \\theta_1 &:= \\theta_1 - \\alpha \\frac{\\partial}{\\partial \\theta_1} J(\\theta_1, \\theta_0) \\\\\n",
+    "    \\theta_0 &:= \\theta_0 - \\alpha \\frac{\\partial}{\\partial \\theta_0} J(\\theta_1, \\theta_0)\n",
+    "\\end{align}\n",
+    "$$\n",
+    "\n",
+    "First of all $\\alpha$ is the **learning rate** we multiply the change we want to make by it, it describes how *fast* we are changing the hypothesis component.\n",
+    "\n",
+    "The partial derivative of $J$ by regard to $\\theta_1$ for example is how the error function changes if we consider $\\theta_0$ has a constant.\n",
+    "\n",
+    "We compute the *next* $\\theta_0$ by subtracting learning rate * partial derivative from it.\n",
+    "\n",
+    "Lets expand theses partial derivatives:\n",
+    "\n",
+    "$$\n",
+    "\\newcommand{\\partialthetazero}{\\frac{\\partial}{\\partial \\theta_0}}\n",
+    "\\begin{align}\n",
+    "    &  \\partialthetazero \\left[ J(\\theta_1, \\theta_0) \\right] \\\\\n",
+    "    =& \\partialthetazero \\left[ \\frac{1}{2n} \\sum_{i=1}^{n}((\\theta_1 x_i + \\theta_0) - y_i)^2 \\right] \\\\\n",
+    "    =& \\frac{1}{2n} \\sum_{i=1}^{n} \\partialthetazero \\left[ ((\\theta_1 x_i + \\theta_0) - y_i)^2 \\right] \\\\\n",
+    "    =& \\frac{1}{2n} \\sum_{i=1}^{n} 2((\\theta_1 x_i + \\theta_0) - y_i) \\partialthetazero \\left[ ((\\theta_1 x_i + \\theta_0) - y_i) \\right] \\\\\n",
+    "    =& \\boxed{ \\frac{1}{n} \\sum_{i=1}^{n} ((\\theta_1 x_i + \\theta_0) - y_i) }\n",
+    "\\end{align}\n",
+    "$$\n",
+    "\n",
+    "And for $\\theta_1$:\n",
+    "\n",
+    "$$\n",
+    "\\newcommand{\\partialthetaone}{\\frac{\\partial}{\\partial \\theta_1}}\n",
+    "\\begin{align}\n",
+    "    &  \\partialthetaone \\left[ J(\\theta_1, \\theta_0) \\right] \\\\\n",
+    "    =& \\partialthetaone \\left[ \\frac{1}{2n} \\sum_{i=1}^{n}((\\theta_1 x_i + \\theta_0) - y_i)^2 \\right] \\\\\n",
+    "    =& \\frac{1}{2n} \\sum_{i=1}^{n} \\partialthetaone \\left[ ((\\theta_1 x_i + \\theta_0) - y_i)^2 \\right] \\\\\n",
+    "    =& \\frac{1}{2n} \\sum_{i=1}^{n} 2((\\theta_1 x_i + \\theta_0) - y_i) \\partialthetaone \\left[ ((\\theta_1 x_i + \\theta_0) - y_i) \\right] \\\\\n",
+    "    =& \\boxed { \\frac{1}{n} \\sum_{i=1}^{n} ((\\theta_1 x_i + \\theta_0) - y_i) x_i }\n",
+    "\\end{align}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def theta0_partial(xs, ys, theta1, theta0):\n",
+    "    return sum([h(x, theta1, theta0) - y\n",
+    "                for x, y in zip(xs, ys)]) / len(xs)\n",
+    "\n",
+    "def theta1_partial(xs, ys, theta1, theta0):\n",
+    "    return sum([(h(x, theta1, theta0) - y) * x\n",
+    "                for x, y in zip(xs, ys)]) / len(xs)\n",
+    "\n",
+    "\n",
+    "def gradient_descent(xs, ys, theta1, theta0, alpha, iterations):\n",
+    "    for _ in range(iterations):\n",
+    "        next_theta1 = theta1 - alpha * theta1_partial(xs, ys, theta1, theta0)\n",
+    "        next_theta0 = theta0 - alpha * theta0_partial(xs, ys, theta1, theta0)\n",
+    "        theta1 = next_theta1\n",
+    "        theta0 = next_theta0\n",
+    "    return theta1, theta0\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The gradient descent work by repeating the formula above a certain amount of times.\n",
+    "\n",
+    "But before actually running the algorithm, the data need to be normalized. This means that they will be in a range like 0 < x < 1 but they will keep their relative distance to each other.\n",
+    "\n",
+    "If we don't do this, our values will go to infinity or some do some sneaky floating point arithmetic stuff.\n",
+    "\n",
+    "Here is how we normalize:\n",
+    "\n",
+    "$$\n",
+    "X_{normalized} = \\frac{X - X_{min}}{X_{max} - X_{min}}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1.         0.53846366 0.58774948 0.74910295 0.70520633 0.42330989\n",
+      " 0.66282974 0.30447119 0.56011257 0.28144044 0.27236171 0.18498763\n",
+      " 0.23537893 0.34362347 0.20313587 0.24470638 0.11670144 0.3228958\n",
+      " 0.17526405 0.19702811 0.1432559  0.21004509 0.         0.17913321]\n",
+      "[240000. 139800. 150500. 185530. 176000. 114800. 166800.  89000. 144500.\n",
+      "  84000.  82029.  63060.  74000.  97500.  67000.  76025.  48235.  93000.\n",
+      "  60949.  65674.  54000.  68500.  22899.  61789.]\n"
+     ]
+    }
+   ],
+   "source": [
+    "#from sklearn.preprocessing import normalize\n",
+    "#X, Y = normalize([xs, ys])\n",
+    "\n",
+    "def normalize(x):\n",
+    "    return (x - x.min()) / (x.max() - x.min())\n",
+    "\n",
+    "def denormalize(x, x_ref):\n",
+    "    return x * (x_ref.max() - x_ref.min()) + x_ref.min()\n",
+    "\n",
+    "X = normalize(xs)\n",
+    "Y = normalize(ys)\n",
+    "\n",
+    "print(X)\n",
+    "print(denormalize(X, xs))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAFxpJREFUeJzt3X2MXfV95/H312MDQwJMic0GP9tgjyDJZk2mPAQ1jxADUjBtlwYi2k0WlaYruqtt5AqUVTaiWwXWalepFiUlWZSkUkvTFlmWQuXdzYOijeosw7oND5XBOGA8JsVgm0R4ANt8949zb3xnfGfmzsx9OmfeL8nyzLm/zP3+ZsafHH7nd843MhNJUrUs6nUBkqT2M9wlqYIMd0mqIMNdkirIcJekCjLcJamCDHdJqiDDXZIqyHCXpApa3Ks3Xrp0aa5du7ZXby9JpfTYY4+9nJnLZhrXs3Bfu3Yto6OjvXp7SSqliHi+lXEuy0hSBRnuklRBhrskVZDhLkkVZLhLUgXNGO4R8WBEvBQRT0zxekTEn0bE3oj4cURc1v4yJUmz0cpWyK8D/x345hSvXw9sqP25Avhy7W/NwfbdY2zbuYeDR8dZPjTI1s3D3LRpRa/LklQyM565Z+YPgMPTDNkCfDMLu4ChiLiwXQUuJNt3j3H3w48zdnScBMaOjnP3w4+zffdYr0uTVDLtWHNfAbzQ8PmB2jHN0radexg/fnLCsfHjJ9m2c0+PKpJUVl29oBoRd0TEaESMHjp0qJtvXQoHj47P6rgkTaUd4T4GrGr4fGXt2Gky84HMHMnMkWXLZnw0woKzfGhwVsclaSrtCPcdwG/Vds1cCbyamS+24esuOFs3DzO4ZGDCscElA2zdPNyjiiSV1Yy7ZSLiL4EPAUsj4gDwn4ElAJn5FeAR4AZgL3AM+HSniq26+q4Yd8tImq/IzJ688cjISPpUSEmanYh4LDNHZhrnHaqSVEGGuyRVkOEuSRVkuEtSBRnuklRBPeuhOl9lesBWu2st09wl9UYpw73+gK36c1jqD9gC+i7k2l1rmeYuqXdKuSxTpgdstbvWMs1dUu+UMtzL9ICtdtdaprlL6p1ShnuZHrDV7lrLNHdJvVPKcC/TA7baXWuZ5i6pd0p5QbVMD9hqd61lmruk3vHBYZJUIj44TJIWMMNdkirIcJekCjLcJamCDHdJqiDDXZIqyHCXpAoy3CWpggx3Seqk11+HJ56Agwe7+ralfPyAJPWVt96CF16Ap5+GPXsm/v3885AJ990Hf/AHXSvJcC8BOy9JfeLIkdPDe88eeOaZ4gy97u1vh+FhuOoq+NSnYONGuPLKrpZquPc5Oy9JXfbGG/Dss81D/OWXT40bGID164sQv/ba4u+NG4u/3/lOiOjdHDDc+950nZcMd2mO3noLxsaaL6M891zxet0731mE9q/+6qnw3rixCPYlS3o2hZkY7n2k2fKLnZekeTh6tHmAP/MMHDt2atzb3lYE9i//Mtx226kQ37ABzjuvd/XPg+HeJ6Zafhk6ewlHjh0/bbydl6SaN98sllGahfhLL50at2gRrFtXhPaHPzxxGWX58p4vo7Sb4d4nplp+OXPxIgaXDEx4zc5LWnAyi62EzdbBf/KTicsoF1xQhPbHPz5xGeWii+CMM3o3hy4z3PvEVMssr44f57994l+5W0YLw89+1vwM/Omn4bXXTo0bHCwC+7LL4NZbJ4b40FDv6u8jhnufWD40yFiTgF8+NMhNm1YY5qqO48dh377mIf7Tn54at2gRrF1bBPav/MrEZZQVK4rXNaWWwj0irgO+BAwAX8vMeye9vhr4BjBUG3NXZj7S5lorbevm4Qlr7uDyi0osswjqZsso+/bByYYlyKVLi8C+/vqJAb5+PZx1Vu/mUHIzhntEDAD3A9cCB4BHI2JHZj7VMOw/Ad/KzC9HxKXAI8DaDtRbWTa+Vin9/OfFzpNmyyg///mpcWedVew8ee974eabT4X4xo1w/vm9q7/CWjlzvxzYm5n7ACLiIWAL0BjuCZxb+/g8oLsPUagIl1/Ul06cKC5aNltGaXxeSgSsWVMEdv2uzHqIr1rlMkqXtRLuK4AXGj4/AFwxacwXgP8ZEb8HvA24ptkXiog7gDsAVq9ePdtaJXVKZrFtsNkyyrPPFgFfd/75ze/KvOii4kKn+kK7LqjeCnw9M/84Iq4C/jwi3p2ZbzUOyswHgAcARkZGsk3vLalVr73WfBllz55ip0rdmWfCxRfDu95V3JnZGOLveEfv6lfLWgn3MWBVw+cra8ca3Q5cB5CZfx8RZwFLgZeQ1F0nTxa30DdbRjlwYOLY1auL0P7N35y4jLJ6dfHsFJVWK+H+KLAhItZRhPotwCcnjdkPfBT4ekRcApwFHGpnoZIaZBYPsZpqGeXNN0+NHRpqflfmxRfD2Wf3bg7qqBnDPTNPRMSdwE6KbY4PZuaTEXEPMJqZO4DPAl+NiP9IcXH1U5npsos0X8eOwd69zUP86NFT45YsKcJ6eLi4M7MxxJcurdyt9ZpZ9CqDR0ZGcnR0tCfvLfWVkydh//7myyj7908cu3LlxOWT+t9r1sBi70lcCCLiscwcmWmcvw1St7z88qk94I0hvndv8QzxunPPLUJ78l2ZGzYUTy+UWmC4S+30+uvFbpRmZ+GHD58at3hxsXWw2Z2ZF1zgMormzXCXZmtyv8zGEN+/v7jYWbd8eRHaN988cRll3TqXUdRR/nZJUzl8eOpGD836Zb7//fDpT09cRjnnnN7VrwXNcNfC9sYbxZp3sxAvUb9MaTLDXdVX75fZbDvh88+f3i9zeHjiXZkl6JcpTWa4qzpm2y/ziiuKOzMbQ/zcc6f++lKJGO6as2YNvTv+VMtW+2UODBQXLTduhI98ZOLFzAr2y5QmM9w1J1M19AbmH/Cz7ZfZ7K7M9esXVL9MaTLDXXMyVUPvbTv3tB7us+2X+b73Ff0yG5dR7JcpNWW4a06mauh92vG59Mv8wAcmLqPYL1OaNcO9DXqy9tzjuiY09M5k2WtHuOjwATa9fgg++93Z98u86KLiGeKS2sJwn6eOrj33W10N/TK/9twoz/6f/8fqVw6w7vAY57zZcMZuv0yp5wz3eWrL2nMHzLmuFvtlXhLB6gtX8sQ5/4K/XXEJh5ev5Yrrr+LqG95vv0ypDxju89Ty2nOXTVtXm/plvm1wkCs4vaGupN4z3OdpwtrzpOPtNps19OVDgxx+6Qjrjhxk/eFi6WT94TGGf/YifPmTHe2X2a/XIKSFxHCfp62bhyesbQMMLhlg6+bhtr7PVGvoceIEW84/cdoZ+P968p84+59fnPA1Dp57AYsvGYYt13SsX2a/XoOQFhrDfZ7qgdXRM9VMvvq3u3jXc8+y/pUx1h8pzsLXHR5jzRd/CiePnxpb65d59seu4alzLuQvjp7FY2cu44216/n3H39vxwO2X69BSAuN4d4GN21a0Z7gOnZsykYP327ol/nmosU8/0sXsu/8FXzn4sv5zB03NO2XeSnwX+Zf1az06zUIaaEx3Lut3i+z2cXMF16YOLbeL/PWW/nS/mD34AU8+46VHDx3GScXFcsoK4YG+cy//UgPJtJcN69BSJqa4d4p9X6Zk0N8qn6ZH/zgxHXwSf0y1+we4ytdWNufr25dg5A0PcN9PsbHp2700Ngvc8mS4g7MjRvhhhsmhniL/TK7srbfBmWpU6q6yMZ+j100MjKSo6OjPXnvWan3y2y2jNKsX2bjNsL632vX2i9TUltExGOZOTLTOBOnbrb9Mq++uuiX2biM0gf9Mt1jLgkWWrjPpl9mfRnlYx+beCbex/0y3WMuqa564T7ffpnDw0UHnxL2y3SPuaS6cof7M8/Arl2nN3oYb9iKt4D6ZbrHXFJducP9G9+AP/oj+2XWuMdcUl25w/13fgduu81+mTXuMZdUV+5wX7Wq1xX0FfeYS6prKdwj4jrgS8AA8LXMvLfJmN8AvgAk8I+Z+ck21qkWte05N5JKbcZwj4gB4H7gWuAA8GhE7MjMpxrGbADuBq7OzCMRcUGnCpYkzayVM/fLgb2ZuQ8gIh4CtgBPNYz5beD+zDwCkJkvtbvQhaSbNyJ505NUTa00ulwBND6u8EDtWKONwMaI+GFE7Kot45wmIu6IiNGIGD106NDcKq64+o1IY0fHSU7diLR991ip30tSd7Wri/FiYAPwIeBW4KsRMTR5UGY+kJkjmTmybNmyNr11tUx3I1KZ30tSd7US7mNA47aUlbVjjQ4AOzLzeGb+BHiaIuw1S928EcmbnqTqaiXcHwU2RMS6iDgDuAXYMWnMdoqzdiJiKcUyzb421rlgTHXDUSduROrme0nqrhnDPTNPAHcCO4F/Ar6VmU9GxD0RcWNt2E7glYh4CvgesDUzX+lU0VW2dfMwg0smNqvu1I1I3XwvSd3l89z7kLtlJE2l1ee5G+6SVCI269CseAYvVYvhLpt8SBXUrn3uKjH3u0vVY7jL/e5SBRnucr+7VEGGu9zvLlWQF1Rlkw+pggx3ATb5kKrGZRlJqiDP3DUjb3CaHb9f6geGu6blDU6z4/dL/cJlGU3LG5xmx++X+oXhrml5g9Ps+P1SvzDcNS1vcJodv1/qF4a7puUNTrPj90v9wguqmpY3OM2O3y/1C5t1SFKJ2KxDWoDcY686w12qCPfYq5EXVKWKcI+9GhnuUkW4x16NDHepItxjr0aGu1QR7rFXIy+oShXhHns1MtylCrHpiupclpGkCjLcJamCDHdJqiDDXZIqqKVwj4jrImJPROyNiLumGffrEZERMeNDbSRJnTNjuEfEAHA/cD1wKXBrRFzaZNw5wH8AftTuIiVJs9PKmfvlwN7M3JeZbwIPAVuajPtD4D7g9TbWJ0mag1bCfQXwQsPnB2rHfiEiLgNWZea321ibJGmO5n1BNSIWAX8CfLaFsXdExGhEjB46dGi+by1JmkIr4T4GrGr4fGXtWN05wLuB70fEc8CVwI5mF1Uz84HMHMnMkWXLls29aknStFoJ90eBDRGxLiLOAG4BdtRfzMxXM3NpZq7NzLXALuDGzLSHniT1yIzPlsnMExFxJ7ATGAAezMwnI+IeYDQzd0z/FaT2spWcNLOWHhyWmY8Aj0w69vkpxn5o/mVJzdlKTmqNd6iqVGwlJ7XGcFep2EpOao3hrlKxlZzUGsNdpWIrufbbvnuMq+/9Luvu+jZX3/tdtu8em/l/pL5nJyaViq3k2ssL1NVluKt0bCXXPtNdoPZ7XG4uy0gLmBeoq8twlxYwL1BXl+EuLWBeoK4u19ylBcwL1NVluEsLnBeoq8llGUmqIMNdkirIcJekCjLcJamCDHdJqiDDXZIqyHCXpAoy3CWpggx3Saogw12SKshwl6QKMtwlqYIMd0mqIMNdkirIcJekCjLcJamCDHdJqiDDXZIqyHCXpApqKdwj4rqI2BMReyPiriav/35EPBURP46I70TEmvaXKklq1YzhHhEDwP3A9cClwK0RcemkYbuBkcz8l8DfAP+13YVKklrXypn75cDezNyXmW8CDwFbGgdk5vcy81jt013AyvaWKUmajVbCfQXwQsPnB2rHpnI78HfzKUqSND+L2/nFIuI2YAT44BSv3wHcAbB69ep2vrUkqUErZ+5jwKqGz1fWjk0QEdcAnwNuzMw3mn2hzHwgM0cyc2TZsmVzqVeS1IJWztwfBTZExDqKUL8F+GTjgIjYBPwZcF1mvtT2KiX1le27x9i2cw8Hj46zfGiQrZuHuWnTdKu16rYZwz0zT0TEncBOYAB4MDOfjIh7gNHM3AFsA94O/HVEAOzPzBs7WLekHtm+e4y7H36c8eMnARg7Os7dDz8OYMD3kZbW3DPzEeCRScc+3/DxNW2uS1Kf2rZzzy+CvW78+Em27dxjuPeRtl5QldSaMi9rHDw6Pqvj6g0fPyB1WX1ZY+zoOMmpZY3tu0/bp9CXlg8Nzuq4esNwl7psumWNMti6eZjBJQMTjg0uGWDr5uEeVaRmXJaRuqzsyxr15aOyListFIa71GXLhwYZaxLkZVrWuGnTCsO8z7ksI3WZyxrqBs/cpS5zWUPdYLhLPeCyhjrNZRlJqiDDXZIqyHCXpAoy3CWpggx3Saogw12SKshwl6QKMtwlqYIMd0mqIMNdkirIcJekCjLcJamCDHdJqiDDXZIqyHCXpAoy3CWpggx3SaogOzFJc7R995it8tS3DHdpDrbvHuPuhx9n/PhJAMaOjnP3w48DGPDqCy7LSHOwbeeeXwR73fjxk2zbuadHFUkTGe7SHBw8Oj6r41K3Ge7SHCwfGpzVcanbDHdpDrZuHmZwycCEY4NLBti6ebhHFUkTtXRBNSKuA74EDABfy8x7J71+JvBN4H3AK8AnMvO59pYq9Y/6RVN3y2gmvdpVNWO4R8QAcD9wLXAAeDQidmTmUw3DbgeOZObFEXELcB/wiU4ULPWLmzatMMw1rV7uqmplWeZyYG9m7svMN4GHgC2TxmwBvlH7+G+Aj0ZEtK9MSSqfXu6qaiXcVwAvNHx+oHas6ZjMPAG8Crxj8heKiDsiYjQiRg8dOjS3iiWpJHq5q6qrF1Qz84HMHMnMkWXLlnXzrSWp63q5q6qVcB8DVjV8vrJ2rOmYiFgMnEdxYVWSFqxe7qpqJdwfBTZExLqIOAO4BdgxacwO4N/UPv7XwHczM9tXpiSVz02bVvDFX3sPK4YGCWDF0CBf/LX39Mdumcw8ERF3AjsptkI+mJlPRsQ9wGhm7gD+B/DnEbEXOEzxfwCStOD1aldVS/vcM/MR4JFJxz7f8PHrwM3tLU2SNFfeoSpJFWS4S1IFGe6SVEGGuyRVkOEuSRUUvdqOHhGHgOfb8KWWAi+34euUhfOtroU0V3C+c7UmM2e8xb9n4d4uETGamSO9rqNbnG91LaS5gvPtNJdlJKmCDHdJqqAqhPsDvS6gy5xvdS2kuYLz7ajSr7lLkk5XhTN3SdIkpQn3iLguIvZExN6IuKvJ62dGxF/VXv9RRKztfpXt08J8fz8inoqIH0fEdyJiTS/qbIeZ5tow7tcjIiOi1DssWplvRPxG7ef7ZET8RbdrbKcWfpdXR8T3ImJ37ff5hl7U2Q4R8WBEvBQRT0zxekTEn9a+Fz+OiMs6Vkxm9v0fikcNPwusB84A/hG4dNKYfwd8pfbxLcBf9bruDs/3w8DZtY9/t6zzbWWutXHnAD8AdgEjva67wz/bDcBu4Jdqn1/Q67o7PN8HgN+tfXwp8Fyv657HfD8AXAY8McXrNwB/BwRwJfCjTtVSljP3hdake8b5Zub3MvNY7dNdFB2yyqiVny3AHwL3Aa93s7gOaGW+vw3cn5lHADLzpS7X2E6tzDeBc2sfnwcc7GJ9bZWZP6DoaTGVLcA3s7ALGIqICztRS1nCvW1Nukuilfk2up3ibKCMZpxr7T9dV2Xmt7tZWIe08rPdCGyMiB9GxK6IuK5r1bVfK/P9AnBbRByg6Bvxe90prSdm+297zlpq1qH+FRG3ASPAB3tdSydExCLgT4BP9biUblpMsTTzIYr/IvtBRLwnM4/2tKrOuRX4emb+cURcRdHV7d2Z+VavCyuzspy5L7Qm3a3Ml4i4BvgccGNmvtGl2tptprmeA7wb+H5EPEexTrmjxBdVW/nZHgB2ZObxzPwJ8DRF2JdRK/O9HfgWQGb+PXAWxXNYqqilf9vtUJZwX2hNumecb0RsAv6MItjLvCY77Vwz89XMXJqZazNzLcX1hRszc7Q35c5bK7/L2ynO2omIpRTLNPu6WWQbtTLf/cBHASLiEopwP9TVKrtnB/BbtV0zVwKvZuaLHXmnXl9dnsVV6BsozmCeBT5XO3YPxT90KH4h/hrYC/xfYH2va+7wfP838M/AP9T+7Oh1zZ2a66Sx36fEu2Va/NkGxVLUU8DjwC29rrnD870U+CHFTpp/AD7W65rnMde/BF4EjlP8F9jtwGeAzzT8bO+vfS8e7+TvsneoSlIFlWVZRpI0C4a7JFWQ4S5JFWS4S1IFGe6SVEGGuyRVkOEuSRVkuEtSBf1/H/TNgC+CQloAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "theta1, theta0 = np.random.random(2)\n",
+    "\n",
+    "line_xs = [X.min(), X.max()]\n",
+    "line_ys = [h(x, theta1, theta0) for x in line_xs]\n",
+    "plt.plot(line_xs, line_ys, color='r')\n",
+    "\n",
+    "plt.scatter(X, Y)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "error before:  0.06228371667961022\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"error before: \", error_function(X, Y, theta1, theta0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-1.0035757423970153 0.9393189294497459\n",
+      "error after:  0.010349594165039607\n"
+     ]
+    }
+   ],
+   "source": [
+    "alpha = 0.1\n",
+    "iterations = 20000\n",
+    "\n",
+    "theta1, theta0 = gradient_descent(X, Y, theta1, theta0, alpha, iterations)\n",
+    "\n",
+    "print(theta1, theta0)\n",
+    "print(\"error after: \", error_function(X, Y, theta1, theta0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl4VOX5xvHvQwCNayxEKwELWkjYVDBs4goCwQXQWhV3q+JS3MtPqDtqQalWLVTE2lo3FNEidYsLWCwCEowSkUSRKhKrUit2i4r6/v54JzViwkySM3PmnNyf6+JqZnKceY6Jdw/veeZ5zTmHiIjES6uwCxARkeAp3EVEYkjhLiISQwp3EZEYUriLiMSQwl1EJIYU7iIiMaRwFxGJIYW7iEgMtQ7rjdu3b+86d+4c1tuLiETSihUr/u6cy092XGjh3rlzZ8rKysJ6exGRSDKzd1M5TssyIiIxpHAXEYkhhbuISAwp3EVEYkjhLiISQwp3EZEYUriLiMRQ0nA3s9+Z2Udm9noD3zczu83M1pjZSjPrG3yZIiLSGKl8iOluYDpwTwPfHwl0TfwZANye+F9pgnnl1UwrreL9jTV0yMtlwohCxvQpCLssEYmYpFfuzrlFwD+2cMho4B7nLQXyzGzXoApsSeaVVzPp0QqqN9bggOqNNUx6tIJ55dVhlyYiERPEmnsB8F6dx+sTz0kjTSutombTV996rmbTV0wrrQqpIhGJqozeUDWzcWZWZmZlGzZsyORbR8L7G2sa9byISEOCCPdqoFOdxx0Tz32Hc26Wc67YOVecn590qFmL0yEvt1HPi4g0JIhwnw+cnOiaGQh86pz7WwCv2+JMGFFIbpucbz2X2yaHCSMKQ6pIRKIqabeMmc0GDgLam9l64CqgDYBzbibwJHAosAb4L3BauoqNu9quGHXLiEhzmXMulDcuLi52mucuItI4ZrbCOVec7Dh9QlVEJIYU7iIiMaRwFxGJIYW7iEgMhbZBdnNFaQZL0LVG6dxFJByRvHKvncGy22vLuOrZmfzzw79n7QyWoOfFaP6MiKQikuFeO4Nlzw/e5ORXnuD5O89m6MqFTHu6MuzSviPoeTGaPyMiqYhkuNfOWrljwNGMPvlmPti+HdPn38jUWRPgrbdCru7bgp4Xo/kzIpKKSIZ73VkrFbt2ZcxJN3HFsLPp87c3oXdvuOYa+OyzECv8RtDzYjR/RkRSEclw33wGy9etcpg7YDQvzl8ERx4JV18Ne+4Jzz0XXpEJQc+L0fwZEUlFJMN9TJ8CphzVm4K8XAwoyMtlylG9GTm8L8yeDc88A87BsGFw/PHwwQdZV2tTu1uCfj0Riaf4zpb57DOYOhWmTIHcXLj+ejj7bMjJSf7PiohkKc2W2XprvzxTUQH9+sH48TBwIKxYEXZlIiJpF99wr9Wtm1+mmT0b3nsP+veH88+HTz8NuzIRkbSJf7gDmMFxx0FlJZxzDkyfDt27w5w5fm1eRCRmWka418rL88G+bBnsuisceyyUlMCaNWFXJiISqJYV7rX69YOXX4bbboMlS6BXL5g8GT7/POzKREQC0TLDHXzXzHnn+aWaMWPgqqt8b/zzz4ddmYhIs7XccK/VoQM8+CCUlsJXX8Ehh8AJJ4TaGy8i0lwK91rDh/u2ySuvhLlzoagIbr/dB76ISMQo3OvKzfVzaSoqoLgYzj0XBg2CV14JuzIRkUZRuNenWzd49lm4/35Yt87fgL3gAvjnP0MpZ155NYOnLqDLxCcYPHWBZreLSFIK94aY+bk0lZV+bMGvf+2XajLcG6/NOUSkKRTuyeTlwYwZvjf++9/3vfEjR8Lbb2fk7bU5h4g0hcI9VbW98bfeCi+95Hvjr7su0N74+pZftDmHiDSFwr0xWrf2c2kqK2HUKLjiCthrL1iwoNkv3dDyS942beo9XptziMiWKNybokMHeOghePpp+PJLGDoUTjwRPvywyS/Z0PKLc2hzDhFpNIV7c4wY4dsmr7gCHn4YCgub3Bvf0DLLpzWbtDmHiDRaSuFuZiVmVmVma8xsYj3f383MFppZuZmtNLNDgy81S+Xm+rk0K1fCPvv43vh994Xy8ka9zJb2Rh3Tp4DFE4fw16mHsXjiEAW7iCSVNNzNLAeYAYwEegBjzazHZoddDsxxzvUBjgN+E3ShWa+w0O/Zet998M47/kNQF10E//pXSv+49kYVkSClcuXeH1jjnFvrnPsCeBAYvdkxDtgh8fWOwPvBlRghZn4uTWUlnHWW76wpKvLjDJL0xmtvVBEJUtI9VM3saKDEOXdG4vFJwADn3Pg6x+wKPAPsBGwLHOKc2+J+dmnfQzUbvPyy/wBUebmfGz99OuyxR9hViUiEZXoP1bHA3c65jsChwL1m9p3XNrNxZlZmZmUbNmwI6K2zWP/+PuBvuQUWL05Lb7yISH1SCfdqoFOdxx0Tz9V1OjAHwDm3BNgaaL/5CznnZjnnip1zxfn5+U2rOGpat/ZzaVavhiOO+KY3fuHCsCsTkRhLJdyXA13NrIuZtcXfMJ2/2THrgKEAZtYdH+4t4NK8EQoK/Fyap56CTZtgyBA46aRm9caLiDQkabg7574ExgOlwGp8V8wqM5tsZqMSh10CnGlmrwGzgVNdssX8lqqkBF5/HS6/3H8QqqgI7rgDvv467MpEJEaS3lBNlxZxQzWZykrfF79wIQwYADNnwt57h12ViGSxTN9QlaYoKvJ7tt53H/z1r/5DUI3ojRcRaYjCPWx1e+PHjfO98d27wyOPZHRuvIjEi8I9W+y0k59Ls2QJ5OfD0UfDYYfB2rVhVyYiEaRwzzYDBsDy5fCrX8GLL0LPnnD99eqNF5FGUbhno9at4cIL/VLN4Yf7zpq994YXXgi7MhGJCIV7Niso8KOEn3zSX7kffDCcfDJ89FHYlYlIllO4R8HIkb43/rLL4MEHfZfNrFmh98bXty2giGQHhXtUbLONn0vz2mt+fMFZZ8Hgwf5xCBraFlABL5IdFO5R072737P1nnvg7bd9b/zFF2e8N76hbQGnlVZltA4RqZ/CPYrM/Fyaqio44ww/dTLDvfENbQvY0PMiklkK9wCEtva8005+ZMFLL0H79r43/vDD/add01zXlrYFFJHwKdybKSvWngcOhLIyuPlmWLQIevZk1XmTuPLhV9JWl7YFFMluCvdmypq159at/Vya1avh0EPpOX0qj8z6KQPWVaSlLm0LKJLdWoddQNRl3dpzx44wdy6n/fhqrnl2Jg/NnsQjvYbwi4N+wsfb5gVa15g+BQpzkSylcG+mDnm5VNcTmOlYe55XXs200ire31hDh7xcJowobDBc39znAIbv1pvxS+YwbtmjDF3zMjcceCovHrD53ubBa0ydIpIeWpZppkytPTd2bX/CiEJsm2355QEnM/K0X1OZ35kppdN57KGJae2Nz4p7ECKicG+uTK09N3Ztv25da9t34pJzbmHF5Fto97d1vjf+Zz+Df/870BqbUqeIpIeWZQKQibXnpqztf7euofDTk2DSJLjpJr/N3223wZgxvnc+pDpFJHi6co+IwPrKv/c9v2frSy/5r486Co444n+98c2l/neR7KBwj4jA1/YHDYIVK/wV/Asv+LnxU6bAF19kV50i0iQK94hIy9p+69Z+Ls3q1X7y5M9/7ufGL1qUXXWKSKOZC2mfzuLiYldWVhbKe0sDnngCxo+Hd96BU0+FG2/0W/6JSNYwsxXOueJkx+nKPWaaNU/msMNg1Sp/w/X++6GwEH7729DnxotI4yncYySQHvNttoFf/AJefRV694Yzz4T99oOVK9NWt4gET+EeI4H2mPfo4W+03n03vPUW9O2btt54EQmewj1GAu8xN4NTTvEbdf/kJ76zpnt3mDcvY3PjRaRpFO4xkrYe83bt/J6tixf7GfJHHgmjRvkbryKSlRTuMZL2HvN99/W98b/8JSxc6Jdubrih2b3xIhK8lMLdzErMrMrM1pjZxAaOOcbM3jCzVWb2QLBlSioy0mPepg1cconvjS8pgYkToU+fZvXGi0jwkva5m1kO8CYwDFgPLAfGOufeqHNMV2AOMMQ594mZ7eyc+2hLr6s+95h4/HHfG//uu+qNF8mAIPvc+wNrnHNrnXNfAA8Cmw8FPxOY4Zz7BCBZsMuWZXJP1ma/1+GH+974iRPhvvugqAjuuku98SIhSyXcC4D36jxen3iurm5ANzNbbGZLzaykvhcys3FmVmZmZRs2bGhaxTGXyXnogb3Xttv6uTSvvupn1JxxBuy/P1RUJP9nRSQtgrqh2hroChwEjAXuNLO8zQ9yzs1yzhU754rz9Vf3emVyHnrg79WzJ/z5z/D738Obb/q1+AkT1BsvEoJUwr0a6FTnccfEc3WtB+Y75zY55/6KX6PvGkyJLUsm56Gn5b3M/Np7ZSWcdprvrOnRAx57rOmvKSKNlkq4Lwe6mlkXM2sLHAfM3+yYefirdsysPX6ZZm2AdbYYmZyHntb3atcO7rwT/vIXyMvzG4KMGuVvvIpI2iUNd+fcl8B4oBRYDcxxzq0ys8lmNipxWCnwsZm9ASwEJjjnPk5X0XGWyXnoGXmvwYN9b/y0afD88/4q/sYbYdOm4N5DRL5DI3+z0LzyaqaVVvH+xho65OUyYURh2uahZ/K9WLcOLrjAjy/o2RNuv93feBWRlKXaCqlwl8z705/gvPP8Es1pp/kr+fbtw65KJBI0z10aJZO99RxxhO+Nv/RSuPdePzdevfEigVK4S0Z76/9n221h6lTfG9+jh++NP+AAeP319L2nSAuicJeM9tZ/R21v/O9+59sn+/TxV/T/+U/631skxhTuktHe+nq1auXX3quq/Pz4G2/0V/PzN++4FZFUKdwlo731W9Sund+z9S9/gR12gNGj/R/1xos0msJdMtpbn5LBg+GVV/wV/HPPqTdepAkU7pKZOfCN1aaNn0vzxhswbJhfh+/b11/Vi0hS6nOXaJg/3/fGr1sHp5/ud4Bq1y7squqV0Q+GSYujPncJTEZ74BsyapS/iv+//4M//MH3xv/+91nXGx9KW6lIPRTuskVZFVbbbuuv2MvLoXt3+MlP4MADs6o3PtS2UpE6FO6yRVkZVr16+d74u+7yV/NZ1BsfelupSILCXbYoa8OqVSt/5V5VBSef/E1v/J/+FGpZWdNWKi2ewl22KOvDqn17fwX/4ouw/fZ+bf7II/2N1xBkXVuptFgKd9miyITVfvv5tfgbboBnnvFr8r/8ZcZ747OyrVRaJLVCSlKRa+179104/3zfPtmrF8yc6T8YJRIDmucu8thjvjf+vfeyvjc+KJH7P2JpNPW5i4we7btpJkyAu+/2vfF33w0hXdCkW1a1rUroFO4Sb9tt5ztpysuhqMhPnzzwQL9ZSMxkZduqhEbhLi1D796waJGfOrlqFey9N0yaBP/9b9iVBSZr21YlFAp3aTlatfJr71VVcNJJfieoHj3g8cfDriwQWd+2KhmlcJeWp317v/PTokV+pMERR8BRR/kbrxEWmbZVyQiFu7Rc++/v1+KnToWnn/a98TfdFNm58eqxl7rUCikC8M47vm3y8cf9+vzMmbDvvmFXJfIdaoUUaYzOnf2Hnv74R9i40X/o6cwz4eOPw65MpEkU7iK1zGDMGN8b/7Of+XnxRUV+fnxMe+MlvhTuIpvbbjuYNs3v49qtG5x6Khx0kA99kYhIKdzNrMTMqsxsjZlN3MJxPzIzZ2ZJ14NEst6ee/ppk3feCRUVsNde8POfx6o3XuIrabibWQ4wAxgJ9ADGmlmPeo7bHrgAWBZ0kSKhadUKzjjD98afeCJMmQI9e8ITT4RdmcgWpXLl3h9Y45xb65z7AngQGF3PcdcCNwCfBVifSHbIz/dr8H/+M2yzDRx+eCx64yW+Ugn3AqDub/D6xHP/Y2Z9gU7OOV3OSLwdcIDvjZ8yJRa98RJfzb6hamatgJuBS1I4dpyZlZlZ2YYNG5r71iLhaNsWJk70M2oOOsh31hQXw5IlYVcm8j+phHs10KnO446J52ptD/QCXjCzd4CBwPz6bqo652Y554qdc8X5+flNr1okG3Tp4vdsffRR+Mc//IeezjrLfy0SslTCfTnQ1cy6mFlb4Dhgfu03nXOfOufaO+c6O+c6A0uBUc45ffxU4s/M79m6ejVcconfz7WoCO65R73xEqqk4e6c+xIYD5QCq4E5zrlVZjbZzEalu0CRzc0rr2bw1AV0mfgEg6cuyI7NKLbbzu/Z+sor8MMfwimnwMEH+9AXCYFmy0ik1O42VHdTitw2Odk1IOvrr/0V/KWXwr//7dfkL7/cd9mINJNmy0gsRWK3oVat/Fyayko4/vhveuOffDLsyqQFUbhLpERqt6Gdd/Z7tr7wAuTmwmGHwdFHw/r1YVcmLYDCXSIlkrsNHXggvPoq/OIX/pOt3bvDr34FX34ZdmVAlt7DkGZTuEukRHa3obZt/Z6tb7zhPwh18cW+N37p0lDLqr2HUb2xBgdUb6xh0qMVCvgYULhLpER+t6EuXfyGII88An//e+i98ZG4hyFN0jrsAkQaa0yfguiEeX3M/FyaYcPg6qvh1lv9JiE33eSHk5llrJRI3cOQRtGVu0hYtt/eB/qKFbDHHnDyyTBkiO+yyZBI3sOQlCjcRcK2116weDHccQe89pqfI3/55VCT/qvnyN7DkKQU7iLZoFUrGDfOX7WPHQvXX5+R3vjI38OQBukTqiLZ6IUX4JxzfNgffTTccgsUKHBFn1AVibaDDvJLNNdf77triop8wGdJb7xkP4W7SLZq29bv2bpqFey/P1x0EfTrB8u0k6Ukp3AXyXa77+4/2Tp3LmzYAIMG+SWbTz4JuzLJYgp3kSgwgx/9yI8QvvBCuPNOv1Rz332aGy/1UriLRMn228PNN0NZmf+060knwdChGe2Nl2hQuItE0d57w0svwcyZfsPuPfeEK67ISG+8RIPCXSSqWrXyc2kqK+G44+C666BXL3j66bArkyygcBeJul128Xu2LlgAbdrAyJHw4x9DtSY7tmQKd5G4OPhg3xt/3XXf9Mbfeqt641sohbtInGy1FVx2me+N328/31nTrx+8/HLYlUmGKdxF4mj33f1cmocfho8+goED4dxzYePGsCuTDFG4i8SVmZ9Ls3o1XHCBnzpZWAj336/e+BZA4S4Sdzvs4PdsLSuDzp39hiCHHAJV2m0pzhTuIi1Fnz6+N/722/0GIeqNjzWFu0hLkpMDZ5/tr9qPOeab3vjS0rArk4Ap3EVaol12gXvvheefh9atoaQEjj0W3n8/7MokIAp3kZZsyBBYuRKuvRYee8z3xt92m3rjY0DhLtLSbbWV37N11SoYPNh31vTvr974iEsp3M2sxMyqzGyNmU2s5/sXm9kbZrbSzJ43sx8EX6qIpNUee/je+Dlz4IMP1BsfcUnD3cxygBnASKAHMNbMemx2WDlQ7JzbE5gL3Bh0oSKSAWZ+Lk1lJZx/vu+NLyqCBx5Qb3zEpHLl3h9Y45xb65z7AngQGF33AOfcQufcfxMPlwIdgy1TRDJqhx38nq3Ll8Nuu8EJJ8CwYfDmm2FXJilKJdwLgPfqPF6feK4hpwNPNacoEckSffvCkiXwm9/4D0H17g1XXQWffRZ2ZZJEoDdUzexEoBiY1sD3x5lZmZmVbdiwIci3FpF0ycnxe7ZWVvolm8mT1RsfAamEezXQqc7jjonnvsXMDgEuA0Y55z6v74Wcc7Occ8XOueL8/Pym1CsiYfn+9/2erc895wO/pMRvEqLe+KyUSrgvB7qaWRczawscB8yve4CZ9QHuwAf7R8GXKSJZY+hQ5t/zFHceciqfz32U/+zelZWXXgtffRV2ZVJH0nB3zn0JjAdKgdXAHOfcKjObbGajEodNA7YDHjazV81sfgMvJyIRN6+8mksff5Pr9zma4afPYMWuhex545V80ruvX5eXrGAupPam4uJiV6ZfBGmh5pVXM620ivc31tAhL5cJIwoZ02dLfQrZY/DUBVRvrDNszDkOq/wL1yz8Le3//Q/fG3/ddZCXF16RMWZmK5xzxcmO0ydURTJsXnk1kx6toHpjDQ6o3ljDpEcrmFcejT1P39+42RRJM57ovj8Hn347nHeenzpZVASzZ6s3PkQKd5EMm1ZaRc2mb69P12z6imml0Ziv3iEvt97nd9ilnd+zdfly6NQJjj8ehg+Ht97KcIUCCneRjPvOlW+S57PNhBGF5LbJ+dZzuW1ymDCi0D/o2xeWLoUZM/x8ml694Oqr1RufYQp3kQxr6Mq3oeezzZg+BUw5qjcFebkYUJCXy5Sjen/7nkFOjl97r6ryW/1dc43/ANQzz4RWd0ujG6oiGVa75l53aSa3Tc53AzJOnnvOh/1bb/ne+Jtvhl13DbuqSNINVZEsldKVb9wccoifG3/NNfDHP/obrtOnqzc+jXTlLiKZtWaNv4p/9lnYZx+YOROKk16ISoKu3EUkO/3wh34uzYMPQnW13xjkvPPg00/DrixWFO4iknlmfs/WykoYP95PnSwq8oGv3vhAKNxFJDw77uj3bH35ZejYEcaOVW98QBTuIhK+ffbxvfHTp/ug793b33xVb3yTKdxFJDvk5MBPf+qXao480n/wqXdvf+NVGk3hLiLZZddd/Vya2g88DR/uRxl88EG4dUWMwl1EstOwYVBR4a/gH3kECgv9SAP1xqdE4S4i2Wvrrf2era+/DgMG+M6agQNhxYqwK8t6CncRyX5du/re+NmzYf169canQOEuItFg5ufSVFb6T7jOmOF74x96SL3x9VC4i0i07Lgj/PrXvmWyoMAHfkmJH2sg/6NwF5FoKi6GZct80C9d6ufGT54Mn38edmVZQeEuItGVk+Nvstb2xl91le+Nf+65sCsLncJdRKKvtje+tBS+/tq3Ubbw3niFu4jEx/Dhvm3yqqt8b3xRkR9K1gJ74xXuIk00r7yawVMX0GXiEwyeuoB55dVhlyTge+Ovvtp/AKpfPz/SYNAgeOWVsCvLKIW7SBPUbpVXvbEGB1RvrGHSoxUK+GzSrZsfYfDAA7BunQ/6Cy6Af/4z7MoyQuEu0gTTSqu+tQcqQM2mr5hWWhVSRVIvMz9GuLISzjnHd9YUFcGcObHvjVe4izTB+xtrGvW8hCwvz48TXrbM33w99lgYORLefjvsytJG4S7SBB3ychv1vGSJfv38h59uuw1eegl69oRrr41lb3xK4W5mJWZWZWZrzGxiPd/fysweSnx/mZl1DrpQkWwyYUQhuW1yvvVcbpscJowoDKkiSVlOjp9LU1kJY8bAlVfCnnvCggVhVxaopOFuZjnADGAk0AMYa2Y9NjvsdOAT59wPgV8BNwRdqEg2GdOngClH9aYgLxcDCvJymXJUb8b0KQi7NElVhw5+z9bSUt8qOXQonHgifPhhoG8TVleVuSQ3FcxsEHC1c25E4vEkAOfclDrHlCaOWWJmrYEPgHy3hRcvLi52ZWVlAZyCiEgz1dTA1Kn+T24uTJkC48b5q/xmqO2qqnvzPbdNTrMuBMxshXOuONlxqSzLFADv1Xm8PvFcvcc4574EPgXapVaqiEjIcnP9nq0VFX5mzbnnwr77Qnl5s142zK6qjN5QNbNxZlZmZmUbNmzI5FuLiCTXrZvfs/X+++Gdd3zQX3hhk3vjw+yqSiXcq4FOdR53TDxX7zGJZZkdgY83fyHn3CznXLFzrjg/P79pFYuIpJOZn0tTVQVnn+07a7p3h4cfbnRvfJhdVamE+3Kgq5l1MbO2wHHA/M2OmQ+ckvj6aGDBltbbRUSyXl6e3xBk6VLYZRc45hg49NBG9caH2VWVNNwTa+jjgVJgNTDHObfKzCab2ajEYXcB7cxsDXAx8J12SRGRSOrf3/fG33orLF7s58Zfd11KvfFhdlUl7ZZJF3XLiEjkVFfDRRf5JZrCQj9xcsiQjJYQZLeMiIiA39Zvzhx46inYtMn3xp90UuC98UFQuIuINFZJiZ8bf8UVfoPuoiKYOdNvFJIlFO4iIk2Rm+v3bK2ogL59/dTJQYOa3RsfFIW7iEhzFBb6PVvvu++b3viLLoJ//SvUshTuIiLNZQYnnOCHkY0b5ztriopg7tzQ5sYr3EVEgrLTTnD77bBkCey8M/z4x3DYYbB2bcZLUbiLiARtwABYvhxuuQVefNHPjb/rroyWoHAXEUmH1q39nq2VlXDEEdC1a2bfPqPvJiLS0tT2xmeYrtxFRGJI4S4iEkMKdxGRGFK4i4jEkMJdRCSGFO4iIjGkcBcRiSGFu4hIDIW2E5OZbQDeDeCl2gN/D+B1okLnG18t6VxB59tUP3DO5Sc7KLRwD4qZlaWy5VRc6HzjqyWdK+h8003LMiIiMaRwFxGJoTiE+6ywC8gwnW98taRzBZ1vWkV+zV1ERL4rDlfuIiKymciEu5mVmFmVma0xs4n1fH8rM3so8f1lZtY581UGJ4XzvdjM3jCzlWb2vJn9IIw6g5DsXOsc9yMzc2YW6Q6LVM7XzI5J/HxXmdkDma4xSCn8Lu9mZgvNrDzx+3xoGHUGwcx+Z2YfmdnrDXzfzOy2xL+LlWbWN23FOOey/g+QA7wN7A60BV4Demx2zLnAzMTXxwEPhV13ms/3YGCbxNfnRPV8UznXxHHbA4uApUBx2HWn+WfbFSgHdko83jnsutN8vrOAcxJf9wDeCbvuZpzvAUBf4PUGvn8o8BRgwEBgWbpqicqVe39gjXNurXPuC+BBYPRmx4wG/pD4ei4w1MwsgzUGKen5OucWOuf+m3i4FOiY4RqDksrPFuBa4Abgs0wWlwapnO+ZwAzn3CcAzrmPMlxjkFI5XwfskPh6R+D9DNYXKOfcIuAfWzhkNHCP85YCeWa2azpqiUq4FwDv1Xm8PvFcvcc4574EPgXaZaS64KVyvnWdjr8aiKKk55r4q2sn59wTmSwsTVL52XYDupnZYjNbamYlGasueKmc79XAiWa2HngSOC8zpYWisf9tN5n2UI04MzsRKAYODLuWdDCzVsDNwKkhl5JJrfFLMwfh/0a2yMx6O+c2hlpV+owF7nbO3WRmg4B7zayXc+7rsAuLsqhcuVcDneo87ph4rt6t6WdAAAABeklEQVRjzKw1/q93H2ekuuClcr6Y2SHAZcAo59znGaotaMnOdXugF/CCmb2DX6ecH+Gbqqn8bNcD851zm5xzfwXexId9FKVyvqcDcwCcc0uArfFzWOIopf+2gxCVcF8OdDWzLmbWFn/DdP5mx8wHTkl8fTSwwCXuYERQ0vM1sz7AHfhgj/Ka7BbP1Tn3qXOuvXOus3OuM/7+wijnXFk45TZbKr/L8/BX7ZhZe/wyzdpMFhmgVM53HTAUwMy648N9Q0arzJz5wMmJrpmBwKfOub+l5Z3CvrvciLvQh+KvYN4GLks8Nxn/Hzr4X4iHgTXAy8DuYdec5vN9DvgQeDXxZ37YNafrXDc79gUi3C2T4s/W8EtRbwAVwHFh15zm8+0BLMZ30rwKDA+75mac62zgb8Am/N/ATgfOBs6u87Odkfh3UZHO32V9QlVEJIaisiwjIiKNoHAXEYkhhbuISAwp3EVEYkjhLiISQwp3EZEYUriLiMSQwl1EJIb+H9xt0QCKJAmEAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "line_xs = [X.min(), X.max()]\n",
+    "line_ys = [h(x, theta1, theta0) for x in line_xs]\n",
+    "plt.plot(line_xs, line_ys, color='r')\n",
+    "\n",
+    "plt.scatter(X, Y)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-1.0035757423970153 0.9393189294497459\n",
+      "-50177.847800921314\n"
+     ]
+    }
+   ],
+   "source": [
+    "#t1 = theta1 * (xs.max() - xs.min()) + xs.min()\n",
+    "#t0 = theta0 * (xs.max() - xs.min()) + xs.min()\n",
+    "\n",
+    "#print(t1, t0)\n",
+    "\n",
+    "t1 = denormalize(theta1, )\n",
+    "print(h(50_000, theta1, theta0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebook/ft_linear_regression_notebook.ipynb b/notebook/ft_linear_regression_notebook.ipynb
deleted file mode 100644
index 8515c65..0000000
--- a/notebook/ft_linear_regression_notebook.ipynb
+++ /dev/null
@@ -1,434 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# ft_linear_regression\n",
-    "\n",
-    "Project in which I need to build a linear regression model for a simple dataset."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "%matplotlib inline\n",
-    "\n",
-    "data = np.genfromtxt('../data.csv', delimiter=',')[1:]\n",
-    "km = data[:, 0]\n",
-    "price = data[:, 1]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "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": [
-    "def plot_data():\n",
-    "    plt.scatter(km, price)\n",
-    "    plt.xlabel(\"km\")\n",
-    "    plt.ylabel(\"price\")\n",
-    "plot_data()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This dataset contains information about cars, their cost and the the number of kilometers they've made.\n",
-    "\n",
-    "We can see just by looking at the data that their is a **linear relationship**, when the distance made diminish, the price rize.\n",
-    "\n",
-    "We can try to trace an approximate line which goes *through* the data."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "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": [
-    "plot_data()\n",
-    "plt.plot([200_000, 20_000], [3_500, 8_500], color='r')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can use this hypothetical line to predict new data, for example predict the price of a car knowing only it's distance traveled.\n",
-    "\n",
-    "The equation of a line is in the form:\n",
-    "\n",
-    "$$\n",
-    "\\boxed {\n",
-    "    y = \\theta_1 x + \\theta_0\n",
-    "}\n",
-    "$$\n",
-    "\n",
-    "Where $\\theta_1$ is the slope of the line and $\\theta_0$ the y-intercept. If we managed to tweak those values correctly we can find the best fitting line for our data (or at least very close to it).\n",
-    "\n",
-    "If we switch to a function, we get $h(x) = \\theta_1 x + \\theta_0$, $h$ is our **hypothesis function**."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "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": [
-    "def h(x, theta1, theta0):\n",
-    "    return x * theta1 + theta0\n",
-    "\n",
-    "theta1 = -0.03\n",
-    "theta0 = 9000\n",
-    "\n",
-    "line_xs = [km.min(), km.max()]\n",
-    "line_ys = [h(x, theta1, theta0) for x in line_xs]\n",
-    "plt.plot(line_xs, line_ys, color='r')\n",
-    "\n",
-    "plot_data()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can adjust our prediction by changing $\\theta_1$ and $\\theta_0$.\n",
-    "\n",
-    "Now, we need a way to know if our line correctly predicts the data or not, so that if not, we can slightly change it to better fit the data.\n",
-    "\n",
-    "Introducing the **error function** $J$ (also called cost function):\n",
-    "\n",
-    "$$\n",
-    "\\begin{align}\n",
-    "J(\\theta_1, \\theta_0) &= \\frac{1}{2n} \\sum_{i=1}^{n}(h(x_i) - y_i)^2 \\\\\n",
-    "                      &= \\frac{1}{2n} \\sum_{i=1}^{n}((\\theta_1 x_i + \\theta_0) - y_i)^2\n",
-    "\\end{align}\n",
-    "$$\n",
-    "\n",
-    "It's the sum of the square of the distance between what we predicted and the actual data.\n",
-    "$n$ is the number of entry we got, we divide by it to normalize the result."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def error_function(xs, ys, theta1, theta0):\n",
-    "    return (1 / (2 * len(xs))) * sum(\n",
-    "        [(h(x, theta1, theta0) - y) ** 2\n",
-    "         for x, y in zip(xs, ys)])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "386217.6189791666\n"
-     ]
-    }
-   ],
-   "source": [
-    "xs = km\n",
-    "ys = price\n",
-    "\n",
-    "print(error_function(xs, ys, theta1, theta0))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The error value is pretty high, this means that the approximated line is garbage.\n",
-    "\n",
-    "The process of learning will be done by reducing this error function. To make that happen, we need to know *how* we are going to change $\\theta_1$ and $\\theta_0$.\n",
-    "\n",
-    "Here comes partial derivatives:\n",
-    "\n",
-    "$$\n",
-    "\\begin{align}\n",
-    "    \\theta_1 &:= \\theta_1 - \\alpha \\frac{\\partial}{\\partial \\theta_1} J(\\theta_1, \\theta_0) \\\\\n",
-    "    \\theta_0 &:= \\theta_0 - \\alpha \\frac{\\partial}{\\partial \\theta_0} J(\\theta_1, \\theta_0)\n",
-    "\\end{align}\n",
-    "$$\n",
-    "\n",
-    "First of all $\\alpha$ is the **learning rate** we multiply the change we want to make by it, it describes how *fast* we are changing the hypothesis component.\n",
-    "\n",
-    "The partial derivative of $J$ by regard to $\\theta_1$ for example is how the error function changes if we consider $\\theta_0$ has a constant.\n",
-    "\n",
-    "We compute the *next* $\\theta_0$ by subtracting learning rate * partial derivative from it.\n",
-    "\n",
-    "Lets expand theses partial derivatives:\n",
-    "\n",
-    "$$\n",
-    "\\newcommand{\\partialthetazero}{\\frac{\\partial}{\\partial \\theta_0}}\n",
-    "\\begin{align}\n",
-    "    &  \\partialthetazero \\left[ J(\\theta_1, \\theta_0) \\right] \\\\\n",
-    "    =& \\partialthetazero \\left[ \\frac{1}{2n} \\sum_{i=1}^{n}((\\theta_1 x_i + \\theta_0) - y_i)^2 \\right] \\\\\n",
-    "    =& \\frac{1}{2n} \\sum_{i=1}^{n} \\partialthetazero \\left[ ((\\theta_1 x_i + \\theta_0) - y_i)^2 \\right] \\\\\n",
-    "    =& \\frac{1}{2n} \\sum_{i=1}^{n} 2((\\theta_1 x_i + \\theta_0) - y_i) \\partialthetazero \\left[ ((\\theta_1 x_i + \\theta_0) - y_i) \\right] \\\\\n",
-    "    =& \\boxed{ \\frac{1}{n} \\sum_{i=1}^{n} ((\\theta_1 x_i + \\theta_0) - y_i) }\n",
-    "\\end{align}\n",
-    "$$\n",
-    "\n",
-    "And for $\\theta_1$:\n",
-    "\n",
-    "$$\n",
-    "\\newcommand{\\partialthetaone}{\\frac{\\partial}{\\partial \\theta_1}}\n",
-    "\\begin{align}\n",
-    "    &  \\partialthetaone \\left[ J(\\theta_1, \\theta_0) \\right] \\\\\n",
-    "    =& \\partialthetaone \\left[ \\frac{1}{2n} \\sum_{i=1}^{n}((\\theta_1 x_i + \\theta_0) - y_i)^2 \\right] \\\\\n",
-    "    =& \\frac{1}{2n} \\sum_{i=1}^{n} \\partialthetaone \\left[ ((\\theta_1 x_i + \\theta_0) - y_i)^2 \\right] \\\\\n",
-    "    =& \\frac{1}{2n} \\sum_{i=1}^{n} 2((\\theta_1 x_i + \\theta_0) - y_i) \\partialthetaone \\left[ ((\\theta_1 x_i + \\theta_0) - y_i) \\right] \\\\\n",
-    "    =& \\boxed { \\frac{1}{n} \\sum_{i=1}^{n} ((\\theta_1 x_i + \\theta_0) - y_i) x_i }\n",
-    "\\end{align}\n",
-    "$$"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def theta0_partial(xs, ys, theta1, theta0):\n",
-    "    return sum([h(x, theta1, theta0) - y\n",
-    "                for x, y in zip(xs, ys)]) / len(xs)\n",
-    "\n",
-    "def theta1_partial(xs, ys, theta1, theta0):\n",
-    "    return sum([(h(x, theta1, theta0) - y) * x\n",
-    "                for x, y in zip(xs, ys)]) / len(xs)\n",
-    "\n",
-    "\n",
-    "def gradient_descent(xs, ys, theta1, theta0, alpha, iterations):\n",
-    "    for _ in range(iterations):\n",
-    "        next_theta1 = theta1 - alpha * theta1_partial(xs, ys, theta1, theta0)\n",
-    "        next_theta0 = theta0 - alpha * theta0_partial(xs, ys, theta1, theta0)\n",
-    "        theta1 = next_theta1\n",
-    "        theta0 = next_theta0\n",
-    "    return theta1, theta0\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The gradient descent work by repeating the formula above a certain amount of times.\n",
-    "\n",
-    "But before actually running the algorithm, the data need to be normalized. This means that they will be in a range like 0 < x < 1 but they will keep their relative distance to each other.\n",
-    "\n",
-    "If we don't do this, our values will go to infinity or some do some sneaky floating point arithmetic stuff."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from sklearn.preprocessing import normalize\n",
-    "\n",
-    "X, Y = normalize([xs, ys])\n",
-    "#Y = normalize([ys])[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAD4CAYAAAAO9oqkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAY8ElEQVR4nO3dfbBc9X3f8fdXz0+AHtEV4kEQY4ywHave0CSuwyQWA/aMEX6s43oqN/bQ1va0aRrP4NJJXeePKGaS1k2ZSVTsqZzJDCTYBWWAKkKAgxuDubLEg8CKBLGxhBAXbBEE4kHw7R/nXGt17+7evXfP3t179X7N7Nyzu7+zv+890t3Pnt/vnLORmUiSTm0zel2AJKn3DANJkmEgSTIMJEkYBpIkYFavC2hl+fLluWbNml6XIUlTxs6dO5/LzBXjXa+vw2DNmjUMDg72ugxJmjIi4scTWc9hIkmSYSBJMgwkSRgGkiQMA0kShoEkiT4/tFSj3brrINdv28vTR45x1uL5fPGKi7h63epelyVpipvWYTBV3jjbrfPWXQf50rcf4djrbwBw8MgxvvTtRwBOaj9Vfm9J/WPaDhMNv3EePHKM5MQb5627Dva6tJOMp87rt+39eRAMO/b6G1y/be+EXk+Shk3bMGjnjbMfjKfOg0eONXyNp48c49ZdB3nPprv57Zt3T4nfW1J/mbbDRE+3eOPsJ+3WeeuugwTQ6HvpFi+YfdLw0Xj6kSSYxmFw1uL5DT9Jn7V4fg+qaa7dOq/ftrdhEASQScsgaPR6k8G5C2nqmLZh8MUrLhr1aXn+7Jl88YqLelJPszfGduts9sk+gReOvd6y71a/d7fesFtNdgOGhNRnpm0YDL+59MObTjtHAY1VZ7M9iNXlJ/5m8wlLFszmv3zwkoZHGx08cuykoadmRydNRLO5kP/613t45fU3xzwiStLkisxGgw/jfJGIK4GvATOBGzNz04jnfwf4LHAcGAJ+KzPHvMxqrVbL6XAJ6/dsurvpG/n/u/Y32nqNkYEC/PyNfPH82Rxpsncwso9Gr9NqnYnuOZx/7e0Nh7Xa6VPSxEXEzsysjXe9jo8mioiZwA3A+4G1wG9GxNoRzXYBtcx8J3AL8NVO+51KqpjMvnrdav7gw+/4+Z5A/Sf6ZkHQqI9Gn9ibrdPoMNX/cPNu1lx7O+/ZdHfLw1XHO0fhBLfUW1UME10K7M/MJwEi4iZgA/DYcIPMvKeu/f3Apyrod8qoajL76nWruXrd6qZ7Gs36rtfOm+7wOo2Co9mQ0sg9iF9/2wq+tfPgqLmQubNmNAyvfpvY7zYn19VvqjjPYDXwk7r7B8rHmvkMcGezJyPimogYjIjBoaGhCsrrvS9ecRHzZ8886bFOJrPb/RTdqI+x3nTr1xmrn+HzFxrtQXxr50E+8u7VrF48n6AYBvqDD7+DL191SaXbYirq9YmBw+eknN/GHp5OHZM6gRwRnwJqwGXN2mTmZmAzFHMGk1RaV1U9md1sT2Px/NksnDurZR+Njl4aHnJaPWKdZv3Ue/rIsaaTxff8cKjpPMCp/Km41YmG3d4O7V7SRKeeKsLgIHBO3f2zy8dOEhHrgeuAyzLz1Qr6nVKGh3iq0Oxw1C9fdcmYfYwnmBr1M9JZi+ePe06kym3RSL8PwfTyhMiJBFG/b09Vo4oweBC4MCLOpwiBTwCfrG8QEeuAPwOuzMxnK+jzlNbpnka7b8b1/Yw8DBVODO8MPz9Sr0506/dPvr08IXK8QTQVtqeq0XEYZObxiPgCsI3i0NJvZOaeiPgKMJiZW4HrgUXAX0UEwFOZeVWnfZ/Kuv3pulE/rT4h9ssJfr0cgmlXL0+IHG8QTYXtqWpUMmeQmXcAd4x47PfqltdX0Y96q1kA9dMJflPhmlS93F7jDaKpsD1VjWl7BrIm12TtqYxlqlyTaqzt1a1x+vEG0US3p/MMU49hoGml365JNRHdHqcfT3BPZHs6zzA1TdvvM9Cpqf5M7frzG3p1TaqJHM/fT9/FMZHt2U/1q33uGWja6Ychq04+HffbOP14t2e/1d/v+mVIzT0DqQs6+XTcbDy+3+Y9mpnq9U+mXp+NXs8wkLqgk0/HVV++ZLJN9fonUz8NqTlMJHVBJ0c19dOhuhMx1eufTP00pGYYSF3Q6VFN/TDv0YmpXv9k6adDoR0mkrqgn45qUv/qpyE19wykLvHTscbST0NqhoEk9VC/fGhwmEiSZBhIkgwDSRKGgSQJw0CShGEgScIwkCRhGEiSqCgMIuLKiNgbEfsj4toGz8+NiJvL5x+IiDVV9CtJqkbHYRARM4EbgPcDa4HfjIi1I5p9BvhZZr4F+G/AH3barySpOlXsGVwK7M/MJzPzNeAmYMOINhuALeXyLcD7IiIq6FuSVIEqwmA18JO6+wfKxxq2yczjwAvAskYvFhHXRMRgRAwODQ1VUJ4kaSx9N4GcmZszs5aZtRUrVvS6HEk6JVQRBgeBc+run10+1rBNRMwCzgCer6BvSVIFqgiDB4ELI+L8iJgDfALYOqLNVmBjufxR4O7MzAr6liRVoOPvM8jM4xHxBWAbMBP4RmbuiYivAIOZuRX4OvDnEbEf+ClFYEiS+kQlX26TmXcAd4x47Pfqll8BPlZFX5Kk6vXdBLIkafIZBpIkw0CSZBhIkjAMJEkYBpIkDANJEoaBJAnDQJKEYSBJwjCQJGEYSJIwDCRJGAaSJAwDSRKGgSQJw0CShGEgScIwkCTRYRhExNKI2B4R+8qfSxq0eVdEfC8i9kTEwxHxzzvpU5JUvU73DK4FdmTmhcCO8v5ILwP/MjMvAa4E/ntELO6wX0lShToNgw3AlnJ5C3D1yAaZ+feZua9cfhp4FljRYb+SpAp1GgYrM/NQufwMsLJV44i4FJgDPNGizTURMRgRg0NDQx2WJ0lqx6yxGkTEXcBAg6euq7+TmRkR2eJ1VgF/DmzMzDebtcvMzcBmgFqt1vT1JEnVGTMMMnN9s+ci4nBErMrMQ+Wb/bNN2p0O3A5cl5n3T7haSVJXdDpMtBXYWC5vBG4b2SAi5gD/B/hmZt7SYX+SpC7oNAw2AZdHxD5gfXmfiKhFxI1lm48DvwZ8OiJ2l7d3ddivJKlCkdm/w/K1Wi0HBwd7XYYkTRkRsTMza+NdzzOQJUmGgSTJMJAkYRhIkjAMJEkYBpIkDANJEoaBJAnDQJKEYSBJwjCQJGEYSJIwDCRJGAaSJAwDSRKGgSQJw0CShGEgScIwkCRRQRhExNKI2B4R+8qfS1q0PT0iDkTE/+y0X0lSdarYM7gW2JGZFwI7yvvN/D7wtxX0KUmqUBVhsAHYUi5vAa5u1Cgi3g2sBP6mgj4lSRWqIgxWZuahcvkZijf8k0TEDOCPgN8d68Ui4pqIGIyIwaGhoQrKkySNZVY7jSLiLmCgwVPX1d/JzIyIbNDuc8AdmXkgIlr2lZmbgc0AtVqt0WtJkirWVhhk5vpmz0XE4YhYlZmHImIV8GyDZr8CvDciPgcsAuZExNHMbDW/IEmaJG2FwRi2AhuBTeXP20Y2yMx/MbwcEZ8GagaBJPWPKuYMNgGXR8Q+YH15n4ioRcSNFby+JKnLIrN/h+VrtVoODg72ugxJmjIiYmdm1sa7nmcgS5IMA0mSYSBJwjCQJGEYSJIwDCRJGAaSJAwDSRKGgSQJw0CShGEgScIwkCRhGEiSMAwkSRgGkiQMA0kShoEkCcNAkkSHYRARSyNie0TsK38uadLu3Ij4m4h4PCIei4g1nfQrSapWp3sG1wI7MvNCYEd5v5FvAtdn5sXApcCzHfYrSapQp2GwAdhSLm8Brh7ZICLWArMycztAZh7NzJc77FeSVKFOw2BlZh4ql58BVjZo81bgSER8OyJ2RcT1ETGzw34lSRWaNVaDiLgLGGjw1HX1dzIzIyKb9PFeYB3wFHAz8Gng6036uwa4BuDcc88dqzxJUgXGDIPMXN/suYg4HBGrMvNQRKyi8VzAAWB3Zj5ZrnMr8Ms0CYPM3AxsBqjVao3CRZJUsU6HibYCG8vljcBtDdo8CCyOiBXl/d8AHuuwX0lShToNg03A5RGxD1hf3iciahFxI0BmvgH8LrAjIh4BAvhfHfYrSarQmMNErWTm88D7Gjw+CHy27v524J2d9CVJ6h7PQJYkGQaSJMNAkoRhIEnCMJAkYRhIkjAMJEkYBpIkDANJEoaBJAnDQJKEYSBJwjCQJGEYSJIwDCRJGAaSJAwDSRKGgSQJw0CSRAVhEBFLI2J7ROwrfy5p0u6rEbEnIh6PiP8REdFp35KkalSxZ3AtsCMzLwR2lPdPEhG/CrwHeCfwduCXgMsq6FuSVIEqwmADsKVc3gJc3aBNAvOAOcBcYDZwuIK+JUkVqCIMVmbmoXL5GWDlyAaZ+T3gHuBQeduWmY83erGIuCYiBiNicGhoqILyJEljmdVOo4i4Cxho8NR19XcyMyMiG6z/FuBi4Ozyoe0R8d7MvG9k28zcDGwGqNVqo15LklS9tsIgM9c3ey4iDkfEqsw8FBGrgGcbNPsQcH9mHi3XuRP4FWBUGEiSJl8Vw0RbgY3l8kbgtgZtngIui4hZETGbYvK44TCRJGnyVREGm4DLI2IfsL68T0TUIuLGss0twBPAI8BDwEOZ+dcV9C1JqkBbw0StZObzwPsaPD4IfLZcfgP41532JUnqDs9AliQZBpIkw0CShGEgScIwkCRhGEiSMAwkSRgGkiQMA0kShoEkCcNAkoRhIEnCMJAkYRhIkqjgEtZ9LRM+/nFYvhwGBmDVqhO3gQFYuRJmz+51lZLUc9M7DI4dg7174d574bnnRj8f0TwoRt5ftGjSy5ekyTK9w2DBAnj44WL5tdfg2Wfh0KETt2eeOXn58ceLn6+/Pvq1Fi1qHhT195cuhRmOvkmaWqZ3GNSbMwfOPru4tfLmm/DTn54cFCODY/duuPNOePHF0evPnl0MP40VHCtXFjVJUh84dcKgXTNmFENHy5fD29/euu1LL40Oivr7P/4xPPAADA0V8xcjLVvWemhqeHnRomJIS5K6pKMwiIiPAV8GLgYuLb/3uFG7K4GvATOBGzNzUyf99o2FC+Etbylurbz++okhqmbBsXdvsfzaa6PXX7CgeVDULy9f7hCVpAnpdM/gUeDDwJ81axARM4EbgMuBA8CDEbE1Mx/rsO+pY/ZsWL26uLWSCT/7WfM5jUOHijmQbdvgH/9x9PozZ54YomoVHAMDMHdud35XSVNSR2GQmY8DROshjEuB/Zn5ZNn2JmADcOqEQbsiignopUvhkktat3355RMB0Whv48ABePDBYo+k0RDV0qXN9zDq759+ukNU0ilgMuYMVgM/qbt/APinzRpHxDXANQDnnntudyubyhYsgAsuKG6tHD9ezFk02tsYvv/d7xbLr746ev3589s79HbFimLPRNKUNGYYRMRdwECDp67LzNuqLigzNwObAWq1WoOPtBqXWbNOvGm3kgkvvND8CKpDh+Cxx2DHDjhyZPT6M2fCmWe2Do7h5XnzuvO7SpqwMcMgM9d32MdB4Jy6+2eXj6mfRMDixcXt4otbtz12DA4fbn3Oxq5dRZs33xy9/uLFYx9BNTBQtHOISpoUkzFM9CBwYUScTxECnwA+OQn9qlvmz4c1a4pbK2+8UQxRtTpn4/77i5/Hjo1ef968kye9mwXHihXFHpCkCev00NIPAX8CrABuj4jdmXlFRJxFcQjpBzLzeER8AdhGcWjpNzJzT8eVq//NnFm8aQ8MwLve1bxdZnF0VLMjqIYPvf3Od4oTAkeaMaMIhLEOvV21qggySaNENjrSpE/UarUcHGx46oJOVa++2vgoqpF7H4cPF3smI51+envnbCxZ4hCVpqSI2JmZtfGu5761ppa5c+G884pbK2++WVycsNU5G9//fvHz5ZdHrz9nTnuH3q5c6RCVpgX/F2t6mjGjOLrpzDPhF3+xebtMOHq09aG3+/fDfffB88+PXj+iGKJqJzgWLuze7yt1yDDQqS0CTjutuL31ra3bvvbayUdRNQqOPXuKn8ePj17/tNPaO/R22TKHqDTpDAOpXXPmwDnnFLdWhq982+rQ2x/8oFg+enT0+rNnn5h4bxUcAwN+OZMqYxhIVau/8u073tG67dGjrQ+9/dGP4HvfKw7RbWT58rGPoBoYKPZKpBYMA6mXFi1q/8q3hw+3PoJq797iZ6MvZ1q4sL1Db5ct88q3pyjDQJoKZs9u78uZMk8MUTULjocean7l21mzTr7ybbPgGBjwy5mmGcNAmk4iik/3y5a19+VMzzzTfJjqqaeKw29bXfm2nS9nOu00J8SnAMNAOlUtXAi/8AvFrZXjx8f+cqb77iuWG135dsGC9g69XbHCIaoeMgwktTZrFpx1VnFrJbO4om2rQ28ffRS2by+ukDvS8JVvx7pc+sCAV77tAsNAUjUiist4LFkCa9e2bnvsWOvJ8Kefhp07iz2SRle+XbKkvXM2zjjDIao2GQaSJt/8+XD++cWtleEr37Y6Z+Pv/q5YfuWV0evPm9feobdnnnnKfzmTYSCpf9Vf+Xbduubthr+cqdXexg9/CPfcU3zP+EjDly9pJzim6ZVvDQNJU1/9lzO97W2t277yyuijqEYGx0MPNb/y7RlnjH0E1apVU+7LmQwDSaeWefPa/3Km555rfYb4Aw80/3KmuXPb+3KmM8/siyvf9r4CSepHM2cWJ+CtXDn2lW9ffLH1obf79o195dvVq2FwsGeH1xoGktSJiOJLk04/HS66qHXbV189ceXbkcNUL73U0/MsDANJmixz58K55xa3PuPpfpKkzsIgIj4WEXsi4s2IaPidmxFxTkTcExGPlW3/fSd9SpKq1+mewaPAh4G/bdHmOPAfM3Mt8MvA5yNijNMTJUmTqaM5g8x8HCBaHEubmYeAQ+XyixHxOLAaeKyTviVJ1ZnUOYOIWAOsAx5o0eaaiBiMiMGhZt/uJEmq1Jh7BhFxFzDQ4KnrMvO2djuKiEXAt4DfzswG36pRyMzNwGaAWq3W4CLqkqSqjRkGmbm+004iYjZFEPxFZn6709eTJFWr68NEUUwofB14PDP/uNv9SZLGL7LR19m1u3LEh4A/AVYAR4DdmXlFRJwF3JiZH4iIfwbcBzwCDF+Y/D9l5h1tvP4Q8OMJFzi25cBzXXz9TvRrbdY1Pv1aF/RvbdY1PiPrOi8zV4z3RToKg6kuIgYzs+H5Eb3Wr7VZ1/j0a13Qv7VZ1/hUVZdnIEuSDANJkmGwudcFtNCvtVnX+PRrXdC/tVnX+FRS1yk9ZyBJKpzqewaSJAwDSRLTOAwi4sqI2BsR+yPi2gbPz42Im8vnHyivm0RErImIYxGxu7z96STX9WsR8YOIOB4RHx3x3MaI2FfeNvZRXW/Uba+tVdbVZm2/U14i/eGI2BER59U918tt1qqurm2zNur6NxHxSNn3d+uvIhwRXyrX2xsRV/RDXd3+m2yntrp2H4mIrL9kfy+3WbO6JrTNMnPa3YCZwBPABcAc4CFg7Yg2nwP+tFz+BHBzubwGeLSHda0B3gl8E/ho3eNLgSfLn0vK5SW9rqt87miP/y1/HVhQLv/bun/LXm+zhnV1c5u1WdfpdctXAf+3XF5btp8LnF++zsw+qKtrf5Pt1la2O43icv33A7V+2GYt6hr3NpuuewaXAvsz88nMfA24Cdgwos0GYEu5fAvwvogW1+KepLoy80eZ+TAnztYedgWwPTN/mpk/A7YDV/ZBXd3WTm33ZObL5d37gbPL5V5vs2Z1dVM7ddVfKHIhMHwUyQbgpsx8NTP/Adhfvl6v6+q2dt4vAH4f+EPglbrHerrNWtQ1btM1DFYDP6m7f6B8rGGbzDwOvAAsK587PyJ2RcR3IuK9k1xXN9bt9mvPi+Ky4/dHxNUV1TRsvLV9BrhzgutOVl3QvW3WVl0R8fmIeAL4KvDvxrNuD+qC7v1NtlVbRPwT4JzMvH286/aoLhjnNuvoy22mqUPAuZn5fES8G7g1Ii7JFpfdFudl5sGIuAC4OyIeycwnJruIiPgUUAMum+y+W2lSV0+3WWbeANwQEZ8E/jNQ6XzKRDWpq6d/kxExA/hj4NOT0V+7xqhr3Ntsuu4ZHATOqbt/dvlYwzYRMQs4A3i+3N17HiAzd1KM2b11Euvqxrpdfe3MPFj+fBK4l+ILjKrSVm0RsR64DrgqM18dz7o9qKub22y8v/NNwPCeSc+3V6O6uvw32U5tpwFvB+6NiB9RfH3v1nKytpfbrGldE9pmVU/G9MONYo/nSYoJneGJl0tGtPk8J08g/2W5vIJyAohi4uYgsHSy6qpr+78ZPYH8DxQToUvK5X6oawkwt1xeDuyjwSRXl/8t15X/2S8c8XhPt1mLurq2zdqs68K65Q8Cg+XyJZw8Gfok1U2GdlJX1/4mx/v/v2x/Lycmanu6zVrUNe5tVsnG7Mcb8AHg78s/xuvKx75C8QkNYB7wVxQTPt8HLigf/wiwB9gN/AD44CTX9UsUY4MvAc8De+rW/a2y3v3Av+qHuoBfpbg8+UPlz8/04N/yLuBw+W+2G9jaJ9usYV3d3mZt1PW1uv/j99S/wVDsxTwB7AXe3w91dftvsp3aRrS9l/JNt9fbrFldE9lmXo5CkjRt5wwkSeNgGEiSDANJkmEgScIwkCRhGEiSMAwkScD/Bz1bhg0bbgKTAAAAAElFTkSuQmCC\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "theta1, theta0 = np.random.randn(2)\n",
-    "\n",
-    "line_xs = [X.min(), X.max()]\n",
-    "line_ys = [h(x, theta1, theta0) for x in line_xs]\n",
-    "plt.plot(line_xs, line_ys, color='r')\n",
-    "\n",
-    "plt.scatter(X, Y)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "error before:  0.7480087502767399\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"error before: \", error_function(X, Y, theta1, theta0))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "-0.3765733088322758 0.26847436709506317\n",
-      "error after:  0.00022231908719401474\n"
-     ]
-    }
-   ],
-   "source": [
-    "alpha = 1\n",
-    "iterations = 1000\n",
-    "\n",
-    "theta1, theta0 = gradient_descent(X, Y, theta1, theta0, alpha, iterations)\n",
-    "\n",
-    "print(theta1, theta0)\n",
-    "print(\"error after: \", error_function(X, Y, theta1, theta0))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAD4CAYAAAAKA1qZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3de3hU1dXH8e8ygMaqDdbUShDBFoGgaDSggvcbYBWQegGvWJWqtdqqVJR6w1pQvCsFqdWWWkWkiihaVMDaKiiBIIgkCohKrEJrqfUVRXS9f+yJDiGQmWRmzkzm93keHmfOnHNmZZBZOWfvtZe5OyIikp+2ijoAERGJjpKAiEgeUxIQEcljSgIiInlMSUBEJI+1iDqAunbaaSdv37591GGIiOSU+fPn/8vdi5M9LuuSQPv27amoqIg6DBGRnGJm7zTmON0OEhHJY0oCIiJ5TElARCSPKQmIiOQxJQERkTymJCAikseUBERE8piSgIhIHsu6YjGp39TKGsbMqOb9tetoU1TIsN6dGFBWEnVYIpLjlARywNTKGq58bDHrvvgSgJq167jyscUASgQi0iQJ3Q4ysz5mVm1my8xseD2vX2pmb5jZIjObaWa7xb3WzsyeNbOlsX3apy78/DBmRvXXCaDWui++ZMyM6ogiEpHmosEkYGYFwFigL1AKDDaz0jq7VQLl7t4NmALcHPfaRGCMu3cBegCrUxF4Pnl/7bqktouIJCqRK4EewDJ3X+Hu64FJQP/4Hdx9trt/Gns6F2gLEEsWLdz9udh+n8TtJwlqU1SY1HYRkUQlkgRKgPfinq+Kbducc4BnYo/3ANaa2WNmVmlmY2JXFhsxs6FmVmFmFWvWrEk09rwxrHcnCltu/LEVtixgWO9OEUUkIs1FSqeImtnpQDkwJrapBXAwcDnQHdgdGFL3OHef4O7l7l5eXJz0ctjN3oCyEkYN3IuSokIMKCkqZNTAvTQoLCJNlsjsoBpg17jnbWPbNmJmRwEjgEPd/fPY5lXAQndfEdtnKnAA8PumBJ2PBpSV6EtfRFIukSuBeUBHM+tgZq2AQcC0+B3MrAy4F+jn7qvrHFtkZrW/3h8BvNH0sEVEJBUaTALuvgG4CJgBLAUmu/sSMxtpZv1iu40BtgMeNbOFZjYtduyXhFtBM81sMWDA79Lwc4iISCOYu0cdw0bKy8td7SVFRJJjZvPdvTzZ47R2kIhIHmuWy0bkyjo7qY4zV35uEckeze5KYGplDddMns8VE6+n6wfLvl5nZ2rlJhOaIlW7HlDN2nU4NDnOVJ9PRPJDs0sCY2ZUs8vq9zjw3UU8MfFSrn3+Xlp88nHWrbOT6vWAtL6QiDRGs0sC769dR3Vxe448dzwPlvXlrPlP8fx9F1A251nIokHwVK8HpPWFRKQxml0SqF1P5+NttuPaoy9gwJm3svpbrbln2k3Qpw8sWxZxhEGq1wPS+kIi0hjNLgnUXWdn0S57MOicO1n0y5EwZw7suSeMHAmff76Fs6RfqtcD0vpCItIYzS4J1LfOzo0n7kO3m66GqioYMACuvRa6dYOZM7MqzqasB6T1hUSkMfKzWOzZZ+HCC2H5cjj1VLj1Vvje99L7niIiaaRisWQccwwsXgzXXANTpkDnzjBuHHz5ZcPHiog0I/mZBAAKC+H660MyKC8PVwYHHggLFkQdmYhIxuRvEqi1xx7w3HPw5z/Du+9C9+5wySXw8cdRRyYiknZKAgBmYWygqgrOPx/uvjvcIpo8OatqC0REUk1JIF5REYwdC3PnhoHiU06Bvn3DALKISDOkJFCfHj3g1Vfhzjvh5ZdDbcGvfx15bYGISKopCWxOixZw8cXhFlG/fnD11bD33jBrVtSRiYikTEJJwMz6mFm1mS0zs+H1vH6pmb1hZovMbKaZ7Vbn9R3MbJWZ3ZOqwDOmTRt45BH4619hwwY48kg4/XT48MOoIxMRabIGk4CZFQBjgb5AKTDYzErr7FYJlLt7N2AKcHOd128AXmx6uBHq3TtMJ7366jBg3KmTagtEJOclciXQA1jm7ivcfT0wCegfv4O7z3b3T2NP5wJta18zs/2AnYFnUxNyhAoLw7pDixfDfvuF2oKePaGyMpJwplbW0Gv0LDoMn06v0bPUO0BEkpZIEigB3ot7viq2bXPOAZ4BMLOtgFsJzeY3y8yGmlmFmVWsWbMmgZAi1qkTPP88PPggrFwZis1+8Qv43/8yFoKayIhIKqR0YNjMTgfKgTGxTRcCT7v7qi0d5+4T3L3c3cuLi4tTGVL6mMFpp4WB45/8JMwk6tw5LEORgdoCNZERkVRIpMdwDbBr3PO2sW0bMbOjgBHAoe5eO5fyQOBgM7sQ2A5oZWafuPsmg8s5q3Vr+O1vYciQUGh20kmhb8E998D3v5+St6ivd7CayIhIKiRyJTAP6GhmHcysFTAImBa/g5mVAfcC/dx9de12dz/N3du5e3vCLaGJzSoBxKutLbjjDnjppZTVFmzutk/Rti3r3V9NZEQkGQ0mAXffAFwEzACWApPdfYmZjTSzfrHdxhB+03/UzBaa2bTNnK55a9EirDu0dCkcf/w3tQWzZzf6lJu77eOOmsiISJPlZz+BTPnrX+GnP4UVK0JtwS23wM47J3WKDsOnU9/fkAG3n7LPJreJ1ERGJD81tp9AImMC0lh9+sDrr8NvfgM33QRPPQWjR8N558FWiY3JtykqpKae+/xtigoZUFaiL30RaRItG5FuhYVwww2waBGUlYXB4549YeHChA5X72ARSSclgUzp3Dn0NH7wQXj77VBslkBtgXoHi0g6aUwgCv/5D1x1Fdx7b1ib6M47YeDAUHsgItII6jGcS1q3DusOzZkDxcVw4onwwx+GAWQRkQxSEojS/vvDvHlw++3w979D165w443qWyAiGaMkELUWLeDnPw/LTxx3HPzqV7DPPvDCC1FHJiJ5QEkgW5SUwKOPwtNPhyuBww+HM8+E1asbPlZEpJGUBLJN376htmDECJg0KaxYOmECfPVV1JGJSDOkJJCNtt02rDv02mvh1tBPfgK9eoXnIiIppCSQzbp0CT2NJ06E5ctDbcGll2a0b4GING9KAtnODM44A6qr4dxzwyqlXbrAX/6Skb4FItK8KQnkitatYfx4ePll2GmnUFtw3HGh+lhEpJGUBHLNAQdARQXcdhu8+CKUlsKoUbB+fdSRiUgOUhLIRS1ahHWHli4NlcZXXRUGkP/2t6gjE5EcoySQy9q2DT2Np0+Hzz6Dww6Ds86KvLZgamUNvUbPosPw6fQaPYuplZt0IxWRLJFQEjCzPmZWbWbLzGyT9pBmdqmZvWFmi8xsppntFtu+j5nNMbMlsddOSfUPIMCxx4bagquugocfDiuWRlRbsLl2mEoEItmpwSRgZgXAWKAvUAoMNrPSOrtVAuXu3g2YAtwc2/4pcKa7dwX6AHeYWVGqgpc4224b1h167TXo1i3UFhx0UMZrCzbXDnPMjOqMxiEiiUnkSqAHsMzdV7j7emAS0D9+B3ef7e6fxp7OBdrGtr/p7m/FHr8PrAaKUxW81KNLl9DT+I9/hGXLQm3BZZfBJ59k5O3fr6cL2pa2i0i0EkkCJcB7cc9XxbZtzjnAM3U3mlkPoBWwvJ7XhppZhZlVrFmzJoGQckNk98bNwrpDVVVwzjlhJlGXLvD441/XFqQrtjZFhUltF5FopXRg2MxOB8qBMXW27wL8CTjb3Te5Ue3uE9y93N3Li4ubx4VCVtwb33HH0Ljm5ZfD44ED4fjjefapOWmLTe0wRXJLIkmgBtg17nnb2LaNmNlRwAign7t/Hrd9B2A6MMLd5zYt3NyRVffGDzwQ5s+HW2+FF17gkIGHc/aLD9Pyyy9SHpvaYYrklhYJ7DMP6GhmHQhf/oOAU+N3MLMy4F6gj7uvjtveCngcmOjuU1IWdQ7IunvjLVqEdYdOOonZRw3ily9O5IQls/nVMRfySru9UhrbgLISfemL5IgGrwTcfQNwETADWApMdvclZjbSzPrFdhsDbAc8amYLzWxabPvJwCHAkNj2hWa2T+p/jOyTyXvjSd3f33VXfn32DZx94rVss2E9jzx8JbdMv50dP/1v2u/bq35AJPuo0Xya1I4JxN8SKmxZkPJbI415n9pj/NP/42cvP8J5rz7Op6224e1h11B23WWwVeprCDP1eYjkKzWazzKZujfemLGH2ti+U9yaWw49i7MvvpcNpV0pu+GXobZg0aKUxtjYOEUk/RIZE5BGysS98caOPWwSm58d+hZcfjnsu2/oe3zddbDddpHGKSLppSuBHJeysQezsO5QdTX8+MdhJlGd2oKsiFNEUkpJIMelfF7+jjuGdYdeein0MBg4EPr1g5UrsytOEUkJJYEcl7axh549Q23BLbeEZShKS+Gmmxrdt0D1AyLZSbODpGHvvQeXXBJuDZWWwrhxcMghUUclInE0O0ga1Oh5+rvuCo89Bk8+Cf/3f3DooXD22dCM1nkSyVdKAnkiJWsZHXccvPEGDB8ODz4Y+hbcd18kfQtEJDWUBPJEyubpb7tt6Gm8cCF07QrnnQcHHwyLF6cwWhHJFCWBPJHyefpdu4aexg88AG++CWVlMGxYxvoWiEhqKAnkibTM0zeDIUNC34Kzzw4ziUpL4YknGn9OEckoJYE8kdZ5+t/5Dvzud/CPf0BREQwYEGoL3nmn6ecWkbRSEsgTGZmn36vXN7UFs2Z9U1vwxRcNHysikVCdgKTHu++G2oKpU8P4wbhxYQBZRNJCdQJ5IlNr8jf5fdq1C8Vl06aFweJDDglrEv3rX2mJV0QaR0kgh2Sqb3FK3+f442HJErjiCvjTn6BTJ/j971VbIJIlEkoCZtbHzKrNbJmZDa/n9UvN7A0zW2RmM81st7jXzjKzt2J/zkpl8PkmU2vyp/x9vvUtGD36m9qCc88NVwaqLRCJXINJwMwKgLFAX6AUGGxmpXV2qwTK3b0bMAW4OXbsjsC1wP5AD+BaM2uduvDzS6bW5E/b+8TXFlRVhb4Fv/xlWIpCRCKRyJVAD2CZu69w9/XAJKB//A7uPtvdP409nQu0jT3uDTzn7h+5+3+A54A+qQk9/2RqTf60vk9tbUF1dehfMGZMmEU0bVqDh4pI6iWSBEqA9+Ker4pt25xzgGeSOdbMhppZhZlVrNGiZJuVqTX5M/I+3/lOWHfoH/+AHXaA/v3DH9UWiGRUSgeGzex0oBwYk8xx7j7B3cvdvby4uDiVITUrmVqTP6Nr//fqBQsWwM03w/PPh6uCm29WbYFIhiTSY7gG2DXuedvYto2Y2VHACOBQd/887tjD6hz7QmMClSATfYsz+T4AtGwZ1h065RS4+OJvZhKNGxca34tI2iRyJTAP6GhmHcysFTAI2OgGrpmVAfcC/dx9ddxLM4BjzKx1bED4mNg2ySGZqk2gXbtQXPbEE/Dxx6G47JxzVFsgkkYNJgF33wBcRPjyXgpMdvclZjbSzPrFdhsDbAc8amYLzWxa7NiPgBsIiWQeMDK2TXJEpmoTNtKvX+hbcMUVMHFi6FvwwAOqLRBJAy0bIVvUa/QsauqZGlpSVMhLw49IfwCvvw4XXBAGkA86KNwi2nPP9L+vSI7RshGSFpmqTdisPfcMtQW//z0sXRr6FlxxhWoLRFJESUC2KFO1CVu01VZh3aGqKjjzzDB7SLUFIimhJCBblKnahITstFO4Ivj732H77UNdwYABYcVSEWkUJQHZoozWDCTqoIOgsjJcETz3HHTpEiqPVVsgkjQNDEtue+edUFswbVoYPxg/PhSgZamplTWMmVHN+2vX0aaokGG9O0WbUKXZ0MCwZFzG6ge2ZLfdQl3B1Knw3/+Gq4Rzz4V//zvzsTQgkum2Ig1QEpBGybovtP79Q23BsGHwxz+GvgUPPABZdKWbqaXARZKhJCCNkpVfaNttF8YJFiwIBWY//jEcemhoapMFIp9uK1IPJQFplKz+QttrL3jxxTCTaMkS2GcfGD488tqCrJhuK1KHkoA0StZ/odXWFlRXwxlnwE03haY2Tz0VWUhZNd1WJEZJQBolZ77QdtoJ7r8/XBlst13oeXzCCZHUFmTldFvJe5oiKo2Wc9Md16+H22+H668PVwrXXQeXXBKWshbJcY2dIqokIPln5cpQW/Dkk2H8YPx46Nkz6qjSKucStiRNdQIiiWrfPhSXTZ0Ka9eG4rLzzsvK2oJUyLrpvJJVlAQkf9XWFlx+eagp6Nw51Bhk2dVxU2XldF7JGkoCkt+22y6sO7RgAeyxBwwZAocdFpJDM5HV03klcgklATPrY2bVZrbMzIbX8/ohZrbAzDaY2Yl1XrvZzJaY2VIzu8vMLFXBi6RMt25hddL77guNbPbeG668Ej79NOrImizrp/NKpBpMAmZWAIwF+gKlwGAzK62z27vAEOChOsf2BHoB3YA9ge7AoU2OWiQdttoq9DSuqoLTT4fRoyOvLUiFnJnOK5FI5EqgB7DM3Ve4+3pgEtA/fgd3X+nui4C6TWAd2AZoBWwNtAQ+bHLUIulUXBzGCP72N9h221BbMHAgvPde1JE1iuoTZEtaJLBPCRD/f/8qYP9ETu7uc8xsNvBPwIB73H1p3f3MbCgwFKBdu3aJnFok/Q45JPQtuO02GDky9C24/vowvTTHagsGlJXoS1/qldaBYTP7AdAFaEtIJkeY2cF193P3Ce5e7u7lxcXF6QxJJDmtWoV1h954Aw4/PMwkKi+HOXOijkwkJRJJAjXArnHP28a2JeIEYK67f+LunwDPAAcmF6JIFqitLXj8cfjoo1BcNnRoeCySwxJJAvOAjmbWwcxaAYOARDt8vwscamYtzKwlYVB4k9tBIjnBLPQ0Xro0XBHcf3/oW9AMawskfzSYBNx9A3ARMIPwBT7Z3ZeY2Ugz6wdgZt3NbBVwEnCvmdUu4D4FWA4sBl4DXnP3J9Pwc4hkTnxtQceOobbg8MNDchDJMVo7SKQpvvoq9C244gr45JNwhfCrX4VZRSIZpLWDRKKw1VZh3aHqajj1VBg1KtQWTJ8edWQiCVESEEmF4mL4wx/ghRegsBCOOw5+9CNYtSrqyES2SElAJJUOPRQWLgxXBM88E2oLbrsNNmyIOjKReikJiKRabW3BkiWh4Oyyy0Jtwdy5UUcmsgklAZF06dAhrDv0l7+EXgU9e8JPfqLaAskqSgLSbEytrKHX6Fl0GD6dXqNnZUfTFLOw7tAbb8AvfhFmEnXuDBMnqrZAsoKSgDQLWd89a/vt4dZbYf58+P734ayz4IgjVFsgkVMSkGYhZ7pn7b03vPQSTJgAr70Wno8Y0Sz6FkhuUhKQZiGnumfV1hZUVcHgwfCb38Cee8LTT0cdmeQhJQFpFnKye9Z3vxvWHZo9G7beGn74QzjxxKypLcjKMRZJOSUBaRZyunvWYYeFW0M33hgqjbt0gdtvj7S2IOvHWCRllASkWcj57lmtWsFVV31TW3DppZHWFuTMGIs0WSKdxURyQrPonrX77qG24PHHQwez2r4Fo0ZB69YZCyOnxlikSXQlIJJtamsLli4NtQX33Rf6Fjz4YMZqC3JyjEUaRUlAJFvV1hZUVIQrhDPOgCOPDLOK0iynx1gkKUoCItlun33g5Zdh/PjQ+L5bt9CzYF36bs3k/BiLJCyhpjJm1ge4EygA7nP30XVePwS4A+gGDHL3KXGvtQPuI/QpduBYd1+5ufdSUxmRLVi9OjSu+dOfwtXBPfdA375RRyVZIG1NZcysABgL9AVKgcFmVlpnt3eBIcBD9ZxiIjDG3bsAPYDVyQYpIjHf/W5Yd2jWrDCj6Nhj4aSToEZTN6VxErkd1ANY5u4r3H09MAnoH7+Du69090XAV/HbY8mihbs/F9vvE3dXfbxIUx1++De1BU89FRalu+MO9S2QpCWSBEqA9+Ker4ptS8QewFoze8zMKs1sTOzKYiNmNtTMKsysYs2aNQmeWiTPxdcWHHxwmEnUvTu88krUkUkOSffAcAvgYOByoDuwO+G20UbcfYK7l7t7eXFxcZpDEmlmdt89VBpPmRLGDA48EC64AP7zn6gjkxyQSBKoIQzq1mob25aIVcDC2K2kDcBUYN/kQhSRBpmFnsZVVXDJJWGV0s6dM1pbILkpkSQwD+hoZh3MrBUwCJiW4PnnAUVmVvvr/RHAG8mHKSIJ2X77sO5QRUXobJbB2gLJTQ0mgdhv8BcBM4ClwGR3X2JmI82sH4CZdTezVcBJwL1mtiR27JeEW0EzzWwxYMDv0vOjiMjXyso2rS24+uq01hZIbkqoTiCTVCcgkmIffhhqCx58MIwfjB0LffpEHZWkWNrqBEQkx+28cygumzkTWrYMxWUnn6zaAgGUBETyxxFHhNqCX/8annwy9C24807VFuQ5JQGRfLL11qGn8euvQ69e8POfQ48e8OqrUUcmEVESEMlH3/9+6Gn86KNhzOCAA+DCC2Ht2qgjkwxTEhDJV2ahp/HSpaGBzb33htqCP/9ZtQV5RElAJN/tsENYd6iiAnbbDU4/HY46CqrVSjIfKAmISFBbWzBuHMyfH2oLrrlGtQXNnJKAiHyjoADOPz9cBZx8MtxwA+y1F8yYEXVkkiZKAiKyqfjagoKCUFx2yinw/vtRRyYppiQgIpt3xBGwaBGMHAlPPBEGju+6C778MurIJEWUBERky7beOqw79Prr0LNnWKW0Rw+YNy/qyCQFlAREJDE/+AE88wxMngz//Cfsvz/89KeqLchxSgIikjiz0NO4qirUFowfH24RPfSQagtylJKAiCSvtrZg3jxo1w5OOw2OPhrefDPqyCRJSgIi0nj77gtz5oTlqSsqwnTSa6+Fzz6LOjJJkJKAiDRNQUFYd6iqKixDMXJkSAbPPht1ZJKAhJKAmfUxs2ozW2Zmw+t5/RAzW2BmG8zsxHpe38HMVpnZPakIWkSy0Pe+x9TLb+bic8aw4qN10Ls3q3r3V21BlmswCZhZATAW6AuUAoPNrLTObu8CQ4CHNnOaG4AXGx+miGS7qZU1XPnYYqbt1IU+Z9/DrQedRvHMZ/hij05w992qLchSiVwJ9ACWufsKd18PTAL6x+/g7ivdfRHwVd2DzWw/YGdA14YiDZhaWUOv0bPoMHw6vUbPYmpl7nT/GjOjmnVfhC/69S1acnevwRxzzlgWtOkcZhLtv38YN5CskkgSKAHei3u+KratQWa2FXArodn8lvYbamYVZlaxZs2aRE4t0uzU/iZds3YdDtSsXceVjy3OmUTw/tpNF5p7p3UbBp1wLUyaFG4L9egBF10E//1vBBFKfdI9MHwh8LS7r9rSTu4+wd3L3b28uLg4zSGJZKf436RrrfviS8bMyI0lndsUFda/vfW2Yd2hpUtDAhg3LtQWPPywaguyQCJJoAbYNe5529i2RBwIXGRmK4FbgDPNbHRSEYrkifp+k97S9mwzrHcnClsWbLStsGUBw3p3Ck++/e2w7tCrr0LbtnDqqXDMMfDWWxFEK7USSQLzgI5m1sHMWgGDgGmJnNzdT3P3du7ennBLaKK7bzK7SES28Jv0ZrZnmwFlJYwauBclRYUYUFJUyKiBezGgrM7d4/32g7lzQ23Bq6/CnnvCddeptiAi5glcjpnZscAdQAFwv7vfaGYjgQp3n2Zm3YHHgdbAZ8AH7t61zjmGAOXuftGW3qu8vNwrNHgkeah2TCD+llBhy4L6v0ibiw8+gMsuC8tO/OAHITEcc0zUUeUkM5vv7uVJH5dIEsgkJQHJZ1Mraxgzo5r3166jTVEhw3p3ar4JIN7zz4eCs7fegkGD4LbbYJddoo4qpygJiEhu++wzuOkmGDUqLF99441wwQWhIlka1NgkoGUjRCQ7bLNNWHdo8eJQU/Czn6m2IAOUBEQku3TsGHoaT5oENTWhtuBnP1NtQZooCYhI9jELtQVVVaG2YOzYUFswaZJqC1JMSUBEsld8bUFJCQweDL17q7YghZQERCT7lZfDK6/APfeE/+61F1x/vWoLUkBJQERyQ0FB6GlcVQUnnBAKzLp1C9NLpdGUBEQkt+yyS1h36Nlnw/jA0UeHJSg++CDqyHKSkoCI5Kajjw7TSa+7Dv7yF+jUKQwgq29BUpQERCR3xdcW1C5TfcABMH9+1JHlDCUBEcl9e+wRbg89/DCsWhUSwsUXq7YgAUoCItI8mIV1h6qqwjpE99wDXbrAI4+otmALlAREpHn59rdDT+NXX4U2bUJi6NMHli2LOrKspCQgIs1TbW3B3XfDnDmhb8HIkfD551FHllWUBESk+SooCIPFVVUwYEAYRO7WDWbOjDqyrKEkICLNX5s2Yd2hGTPCFNKjjoLTTlNtAQkmATPrY2bVZrbMzDZpD2lmh5jZAjPbYGYnxm3fx8zmmNkSM1tkZqekMniRbDS1soZeo2fRYfh0eo2exdTKRFtyS9odcwy8/nq4IpgyJSxK99vf5nVtQYNJwMwKgLFAX6AUGGxmpXV2excYAjxUZ/unwJmxVpN9gDvMrKipQYtkq9oWkTVr1+FAzdp1XPnYYiWCbLLNNqHAbPFi6N49LEVx4IGwYEHUkUUikSuBHsAyd1/h7uuBSUD/+B3cfaW7LwK+qrP9TXd/K/b4fWA1UJySyEWy0JgZ1Rv1CAZY98WXjJlRHVFEslm1tQUPPQTvvhsSwiWXwMcfRx1ZRiWSBEqA9+Ker4ptS4qZ9QBaAcvreW2omVWYWcWaNWuSPbVI1nh/7bqktkvEzMLy1FVVcP75YSZR584weXLe1BZkZGDYzHYB/gSc7e5f1X3d3Se4e7m7lxcX60JBclebosKktkuWKCoK6w698kpYoO6UU6BvX1i+ye+szU4iSaAG2DXuedvYtoSY2Q7AdGCEu89NLjyR3DKsdycKW27cGL2wZQHDeneKKCJJSvfuocjsrrvg5Zeha1e44YZmXVuQSBKYB3Q0sw5m1goYBExL5OSx/R8HJrr7lMaHKZIbBpSVMGrgXpQUFWJASVEhowbuxYCypO+gSlQKCkJP49ragmuuCbUFs2al9G2yZRaZeQL3vczsWOAOoAC4391vNLORQIW7TzOz7oQv+9bAZ8AH7t7VzE4HHgCWxJ1uiLsv3ODh6mIAAAdCSURBVNx7lZeXe0VFReN/IhGRVJoxI8wgWr481BbceivsvHOTTlk7iyx+EkFhy4Im/cJgZvPdvTzp4xJJApmkJCAiWWfdOhg1Cm66CQoLw+OhQ8NVQyP0Gj2LmnomC5QUFfLS8CMadc7GJgFVDIuINKSwMKw7tGgR7LdfWKW0Z0+orGzU6bJpFpmSgIhIojp1Cj2N//xnWLkyLFL3858nXVuQTbPIlARERJJhFnoaV1eH2oK77gp9Cx59NOHagmyaRaYkICLSGLW1BXPnhoHik0+GY49NqLYgm2aRaWBYRKSpNmwICeHqq+GLL2DECBg2DLbeOmMhaGBYRCQqLVqEdYeWLoXjjw/JYO+9YfbsqCNrkJKAiEiqlJSEdYeeeSZcERxxBJxxBnz4YdSRbZaSgIhIqvXpE/oWXH11aHTfuTOMHw9fbbJ0WuSUBERE0iG+tqCsDC64IPQtaGRtQbooCYiIpFPnzqGn8YMPflNb8ItfwP/+F3VkgJKAiEj6mYV1h6qqwnITd94ZagumTIm8b4GSgIhIprRuDePGwZw5UFwMJ50Exx0XBpEj0iKydxYRyVf77w/z5oXagrffhpYtIwtFSUBEJAq1tQUR0+0gEZE8piQgIpLHEkoCZtbHzKrNbJmZDa/n9UPMbIGZbTCzE+u8dpaZvRX7c1aqAhcRkaZrMAmYWQEwFugLlAKDzay0zm7vAkOAh+ocuyNwLbA/0AO41sxaNz1sERFJhUSuBHoAy9x9hbuvByYB/eN3cPeV7r4IqFsT3Rt4zt0/cvf/AM8BfVIQt4iIpEAiSaAEeC/u+arYtkQkdKyZDTWzCjOrWLNmTYKnFhGRpsqKgWF3n+Du5e5eXlxcHHU4IiJ5I5EkUAPsGve8bWxbIppyrIiIpFmDncXMrAXwJnAk4Qt8HnCquy+pZ98/AE+5+5TY8x2B+cC+sV0WAPu5+0dbeL81wDtJ/yTJ2Qn4V5rfo7GyNTbFlRzFlbxsjS1X4trN3ZO+lZJQe0kzOxa4AygA7nf3G81sJFDh7tPMrDvwONAa+Az4wN27xo79MXBV7FQ3uvsDyQaZamZW0Zg2bJmQrbEpruQoruRla2zNPa6Elo1w96eBp+tsuybu8TzCrZ76jr0fuL8JMYqISJpkxcCwiIhEI1+TwISoA9iCbI1NcSVHcSUvW2Nr1nElNCYgIiLNU75eCYiICEoCIiJ5rdklgQRWPN3azB6Jvf6KmbWPbW9vZuvMbGHsz/gMxxXJSqxNjOvLuM9rWirjSjC2S83sDTNbZGYzzWy3uNei/My2FFfaPrME4jrfzBbH3vsf8QtBmtmVseOqzax3NsQV9b/JuP1+ZGZuZuVx29L2eTUltkZ9Zu7ebP4Q6hiWA7sDrYDXgNI6+1wIjI89HgQ8EnvcHng9wrjaA92AicCJcdt3BFbE/ts69rh11HHFXvsk4r/Lw4FtY48viPu7jPozqzeudH5mCca1Q9zjfsBfY49LY/tvDXSInacgC+KK9N9kbL/tgReBuUB5uj+vFMSW9GfW3K4EGlzxNPb8j7HHU4AjzcyijsujWYm1KXGlWyKxzXb3T2NP5/JNrUrUn9nm4kqnROL6OO7pt4DaWSH9gUnu/rm7vw0si50v6rjSKZHvCoAbgJsIRbC10vl5NTW2pDW3JJDIqqVf7+PuG4D/At+JvdbBzCrN7G9mdnCG40rHsek+9zYWVn+da2YDUhRTrWRjOwd4ppHHZiouSN9nluiKvT81s+XAzcDFyRwbQVwQ4b9JM9sX2NXdpyd7bISxQZKfmRrNf+OfQDt3/7eZ7QdMNbOudX5LkY3t5u41ZrY7MMvMFrv78kwHYWanA+XAoZl+7y3ZTFyRfmbuPhYYa2anAr8CsqLb32biiuzfpJltBdxGaJaVVRqILenPrLldCSSyaunX+1hYHO/bwL9jl3b/BnD3+YR7cntkMK50HJvWc7t7Tey/K4AXgLIUxZVwbGZ2FDAC6OfunydzbARxpfMzS/ZnngTUXolE/nnVF1fE/ya3B/YEXjCzlcABwLTYAGy6V0dudGyN+sxSOdgS9R/Clc0KwmBN7YBK1zr7/JSNB4Ynxx4XExvcIQzI1AA7ZiquuH3/wKYDw28TBjhbxx5nQ1ytga1jj3cC3qKewas0/12Wxf4n71hne6Sf2RbiSttnlmBcHeMeH09YABKgKxsPdK4gdQPDTYkrK/5NxvZ/gW8GX9P2eaUgtqQ/s5QEnU1/gGMJS18vB0bEto0k/EYGsA3wKGEw51Vg99j2HwFLgIWEJa+Pz3Bc3Qn3/v4P+DewJO7YH8fiXQacnQ1xAT2BxbH/QRcD50Twd/k88GHs72whMC1LPrN640r3Z5ZAXHfG/T8+O/6LhXDVshyoBvpmQ1xR/5uss+8LxL5o0/15NSW2xnxmWjZCRCSPNbcxARERSYKSgIhIHlMSEBHJY0oCIiJ5TElARCSPKQmIiOQxJQERkTz2/8KM433kz7GtAAAAAElFTkSuQmCC\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "line_xs = [X.min(), X.max()]\n",
-    "line_ys = [h(x, theta1, theta0) for x in line_xs]\n",
-    "plt.plot(line_xs, line_ys, color='r')\n",
-    "\n",
-    "plt.scatter(X, Y)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "-18828.396967246696\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(h(50_000, theta1, theta0))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/notebook/ft_linear_regression_notebook.md b/notebook/ft_linear_regression_notebook.md
deleted file mode 100644
index 1754f62..0000000
--- a/notebook/ft_linear_regression_notebook.md
+++ /dev/null
@@ -1,248 +0,0 @@
-
-# ft_linear_regression
-
-Project in which I need to build a linear regression model for a simple dataset.
-
-
-```python
-import numpy as np
-import matplotlib.pyplot as plt
-%matplotlib inline
-
-data = np.genfromtxt('../data.csv', delimiter=',')[1:]
-km = data[:, 0]
-price = data[:, 1]
-```
-
-
-```python
-def plot_data():
-    plt.scatter(km, price)
-    plt.xlabel("km")
-    plt.ylabel("price")
-plot_data()
-plt.show()
-```
-
-
-![png](ft_linear_regression_notebook_files/ft_linear_regression_notebook_2_0.png)
-
-
-This dataset contains information about cars, their cost and the the number of kilometers they've made.
-
-We can see just by looking at the data that their is a **linear relationship**, when the distance made diminish, the price rize.
-
-We can try to trace an approximate line which goes *through* the data.
-
-
-```python
-plot_data()
-plt.plot([200_000, 20_000], [3_500, 8_500], color='r')
-plt.show()
-```
-
-
-![png](ft_linear_regression_notebook_files/ft_linear_regression_notebook_4_0.png)
-
-
-We can use this hypothetical line to predict new data, for example predict the price of a car knowing only it's distance traveled.
-
-The equation of a line is in the form:
-
-$$
-\boxed {
-    y = \theta_1 x + \theta_0
-}
-$$
-
-Where $\theta_1$ is the slope of the line and $\theta_0$ the y-intercept. If we managed to tweak those values correctly we can find the best fitting line for our data (or at least very close to it).
-
-If we switch to a function, we get $h(x) = \theta_1 x + \theta_0$, $h$ is our **hypothesis function**.
-
-
-```python
-def h(x, theta1, theta0):
-    return x * theta1 + theta0
-
-theta1 = -0.03
-theta0 = 9000
-
-line_xs = [km.min(), km.max()]
-line_ys = [h(x, theta1, theta0) for x in line_xs]
-plt.plot(line_xs, line_ys, color='r')
-
-plot_data()
-plt.show()
-```
-
-
-![png](ft_linear_regression_notebook_files/ft_linear_regression_notebook_6_0.png)
-
-
-We can adjust our prediction by changing $\theta_1$ and $\theta_0$.
-
-Now, we need a way to know if our line correctly predicts the data or not, so that if not, we can slightly change it to better fit the data.
-
-Introducing the **error function** $J$ (also called cost function):
-
-$$
-\begin{align}
-J(\theta_1, \theta_0) &= \frac{1}{2n} \sum_{i=1}^{n}(h(x_i) - y_i)^2 \\
-                      &= \frac{1}{2n} \sum_{i=1}^{n}((\theta_1 x_i + \theta_0) - y_i)^2
-\end{align}
-$$
-
-It's the sum of the square of the distance between what we predicted and the actual data.
-$n$ is the number of entry we got, we divide by it to normalize the result.
-
-
-```python
-def error_function(xs, ys, theta1, theta0):
-    return (1 / (2 * len(xs))) * sum(
-        [(h(x, theta1, theta0) - y) ** 2
-         for x, y in zip(xs, ys)])
-```
-
-
-```python
-xs = km
-ys = price
-
-print(error_function(xs, ys, theta1, theta0))
-```
-
-    386217.6189791666
-
-
-The error value is pretty high, this means that the approximated line is garbage.
-
-The process of learning will be done by reducing this error function. To make that happen, we need to know *how* we are going to change $\theta_1$ and $\theta_0$.
-
-Here comes partial derivatives:
-
-$$
-\begin{align}
-    \theta_1 &:= \theta_1 - \alpha \frac{\partial}{\partial \theta_1} J(\theta_1, \theta_0) \\
-    \theta_0 &:= \theta_0 - \alpha \frac{\partial}{\partial \theta_0} J(\theta_1, \theta_0)
-\end{align}
-$$
-
-First of all $\alpha$ is the **learning rate** we multiply the change we want to make by it, it describes how *fast* we are changing the hypothesis component.
-
-The partial derivative of $J$ by regard to $\theta_1$ for example is how the error function changes if we consider $\theta_0$ has a constant.
-
-We compute the *next* $\theta_0$ by subtracting learning rate * partial derivative from it.
-
-Lets expand theses partial derivatives:
-
-$$
-\newcommand{\partialthetazero}{\frac{\partial}{\partial \theta_0}}
-\begin{align}
-    &  \partialthetazero \left[ J(\theta_1, \theta_0) \right] \\
-    =& \partialthetazero \left[ \frac{1}{2n} \sum_{i=1}^{n}((\theta_1 x_i + \theta_0) - y_i)^2 \right] \\
-    =& \frac{1}{2n} \sum_{i=1}^{n} \partialthetazero \left[ ((\theta_1 x_i + \theta_0) - y_i)^2 \right] \\
-    =& \frac{1}{2n} \sum_{i=1}^{n} 2((\theta_1 x_i + \theta_0) - y_i) \partialthetazero \left[ ((\theta_1 x_i + \theta_0) - y_i) \right] \\
-    =& \boxed{ \frac{1}{n} \sum_{i=1}^{n} ((\theta_1 x_i + \theta_0) - y_i) }
-\end{align}
-$$
-
-And for $\theta_1$:
-
-$$
-\newcommand{\partialthetaone}{\frac{\partial}{\partial \theta_1}}
-\begin{align}
-    &  \partialthetaone \left[ J(\theta_1, \theta_0) \right] \\
-    =& \partialthetaone \left[ \frac{1}{2n} \sum_{i=1}^{n}((\theta_1 x_i + \theta_0) - y_i)^2 \right] \\
-    =& \frac{1}{2n} \sum_{i=1}^{n} \partialthetaone \left[ ((\theta_1 x_i + \theta_0) - y_i)^2 \right] \\
-    =& \frac{1}{2n} \sum_{i=1}^{n} 2((\theta_1 x_i + \theta_0) - y_i) \partialthetaone \left[ ((\theta_1 x_i + \theta_0) - y_i) \right] \\
-    =& \boxed { \frac{1}{n} \sum_{i=1}^{n} ((\theta_1 x_i + \theta_0) - y_i) x_i }
-\end{align}
-$$
-
-
-```python
-def theta0_partial(xs, ys, theta1, theta0):
-    return sum([h(x, theta1, theta0) - y
-                for x, y in zip(xs, ys)]) / len(xs)
-
-def theta1_partial(xs, ys, theta1, theta0):
-    return sum([(h(x, theta1, theta0) - y) * x
-                for x, y in zip(xs, ys)]) / len(xs)
-
-
-def gradient_descent(xs, ys, theta1, theta0, alpha, iterations):
-    for _ in range(iterations):
-        next_theta1 = theta1 - alpha * theta1_partial(xs, ys, theta1, theta0)
-        next_theta0 = theta0 - alpha * theta0_partial(xs, ys, theta1, theta0)
-        theta1 = next_theta1
-        theta0 = next_theta0
-    return theta1, theta0
-
-```
-
-The gradient descent work by repeating the formula above a certain amount of times.
-
-But before actually running the algorithm, the data need to be normalized. This means that they will be in a range like 0 < x < 1 but they will keep their relative distance to each other.
-
-If we don't do this, our values will go to infinity or some do some sneaky floating point arithmetic stuff.
-
-
-```python
-from sklearn.preprocessing import normalize
-
-X = normalize([xs])[0]
-Y = normalize([ys])[0]
-```
-
-
-```python
-theta1, theta0 = np.random.randn(2)
-
-line_xs = [X.min(), X.max()]
-line_ys = [h(x, theta1, theta0) for x in line_xs]
-plt.plot(line_xs, line_ys, color='r')
-
-plt.scatter(X, Y)
-plt.show()
-```
-
-
-![png](ft_linear_regression_notebook_files/ft_linear_regression_notebook_14_0.png)
-
-
-
-```python
-print("error before: ", error_function(X, Y, theta1, theta0))
-```
-
-    error before:  0.20767778959463673
-
-
-
-```python
-alpha = 1
-iterations = 1000
-
-theta1, theta0 = gradient_descent(X, Y, theta1, theta0, alpha, iterations)
-
-print(theta1, theta0)
-print("error after: ", error_function(X, Y, theta1, theta0))
-```
-
-    -0.3766258389374899 0.2684839986208806
-    error after:  0.00022231909239872055
-
-
-
-```python
-line_xs = [X.min(), X.max()]
-line_ys = [h(x, theta1, theta0) for x in line_xs]
-plt.plot(line_xs, line_ys, color='r')
-
-plt.scatter(X, Y)
-plt.show()
-```
-
-
-![png](ft_linear_regression_notebook_files/ft_linear_regression_notebook_17_0.png)
-
diff --git a/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_14_0.png b/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_14_0.png
deleted file mode 100644
index 66ea667..0000000
--- a/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_14_0.png
+++ /dev/null
diff --git a/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_17_0.png b/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_17_0.png
deleted file mode 100644
index 1394372..0000000
--- a/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_17_0.png
+++ /dev/null
diff --git a/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_2_0.png b/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_2_0.png
deleted file mode 100644
index 0da582d..0000000
--- a/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_2_0.png
+++ /dev/null
diff --git a/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_4_0.png b/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_4_0.png
deleted file mode 100644
index efdd169..0000000
--- a/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_4_0.png
+++ /dev/null
diff --git a/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_6_0.png b/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_6_0.png
deleted file mode 100644
index 4ed9c99..0000000
--- a/notebook/ft_linear_regression_notebook_files/ft_linear_regression_notebook_6_0.png
+++ /dev/null
diff --git a/src/model.py b/src/model.py
index 8fb34a9..ee43050 100644
--- a/src/model.py
+++ b/src/model.py
@@ -1,6 +1,6 @@
 import numpy as np
 import matplotlib.pyplot as plt
-from sklearn.preprocessing import normalize as sklearn_normalize
+import sklearn.preprocessing
 
 
 class Model:
@@ -11,7 +11,7 @@ class Model:
         self.xs, self.ys = self._read_data()
 
     def train(self, alpha=1, epoch=100):
-        self.xs, self.ys = self._normalize_data()
+        self._normalize_data()
         for _ in range(epoch):
             next_theta0 = self.theta0 - alpha * self._partial_theta0()
             next_theta1 = self.theta1 - alpha * self._partial_theta1()
@@ -19,8 +19,8 @@ class Model:
             self.theta1 = next_theta1
 
     def write_theta(self):
-        with open(self.datafilename, "w") as file:
-            file.write("{},{}".format(str(theta1), str(theta0)))
+        with open(self.thetafilename, "w") as file:
+            file.write("{},{}".format(str(self.theta1), str(self.theta0)))
 
     def hypothesis(self, x):
         return x * self.theta1 + self.theta0
@@ -54,7 +54,7 @@ class Model:
                     for x, y in zip(self.xs, self.ys)]) / len(self.xs)
 
     def _normalize_data(self):
-        self.xs, self.ys = sklearn_normalize([self.xs, self.ys])
+        self.xs, self.ys = sklearn.preprocessing.normalize([self.xs, self.ys])
 
     def _read_theta(self):
         try:
@@ -62,13 +62,13 @@ class Model:
                 strs = file.read().strip().split(",")
                 if len(strs) != 2:
                     raise "wrong theta file format"
-                return int(strs[0]), int(strs[1])
+                return float(strs[0]), float(strs[1])
         except IOError:
             print(self.thetafilename, "do not exist")
 
     def _read_data(self):
         try:
-            data = np.genfromtxt(self.datafilename, delimiter=",")
+            data = np.genfromtxt(self.datafilename, delimiter=",")[1:]
             return data[:, 0], data[:, 1]
         except IOError:
             print(self.datafilename, "do not exist")
diff --git a/src/theta b/src/theta
index 15794e0..768218a 100644
--- a/src/theta
+++ b/src/theta
@@ -1 +1 @@
-0,0
+-0.19808642684030997,0.23574835208002437
\ No newline at end of file