Regression Linear From scratch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Contexts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    L'idee de ce projet est d'aide les gens qui veulent en savoir plus sur les maths (et les algorithms) qui sont caches derriere outils de machine learning.\n",
    "    Permettre de comprendre un peu plus en profondeur la therorie derriere le machie learning.\n",
    "    Dans ce jupyter nous allons commencer avec la Regression Linear, un algorithme beaucoup plus simple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Explications"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    La regression linear est etablie par une equation : \n",
    "$$ y = a*X + b $$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    L'objectif du model sera de trouver les bons parameters pour : \n",
    "$$a , b$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "    \n",
    "    On a donc besoin d'une fonction de cout (ou fonction erreur) Pour nous permettre d'evaluer le model et par la suite apprendre sur les parameters. Cette fonction est definie par : \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](quicklatex.com-dc79559d002feb0b9693f668a3a4a537_l3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    Explication : supposons que notre model predit une valeur de y=600 alors qu'il devrait predire 550 ?\n",
    "    On dit alors que notre model a fait une erreur de -50 (550-600) on peut donc parfois obtenir des erreurs negatives, pour palier a ce probleme... on a deux solutions :\n",
    "        Soit on prens la valeurs absolue de l'erreur : |550-600|=50 (Celui est la procedure avec mean absolute error)\n",
    "        Soit on prends la racine carree du resultat soit (-50)**2 = 2500 (on a donc une erreur trop grand il faut donc le penaliser) mais avant on applique cela a tous notre dataset ainsi on la somme precedente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    la representation de cette fonction est convexe (une fonction qui a un seul minima possible)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](5141ef4a2c46eeb5f611f3454eda810c.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    Cette fonction est donc un algorithm iterative, il faut applique des derives partielles et avance celle une certain valeur (c'est ce qu'on appelle taux d'apprentissage ou encore learning rate). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![SegmentLocal](gradient-descent.gif \"segment\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    Il faut donc trouver les gradients pour chaque parameters : a,b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](grd-desc-1-768x460.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    A savoir : Tout ce qu'on fait en realite, c'est de derive la fonction et calculer le nouveau parameters en retranchant a chaque fois l'encienne valeur et comme la decente de gratient a un seul mina possible (une fonction convexe)... apres plus repetition on va donc tomber sur le minima.\n",
    "    Mais attention, vous remarquez qu'on multiplie par le learning reate apres avoir calucle la somme des erreurs, cette valeur est important... il faut savoir le choisir, en generale cette valeur est tres faible et varie entre 0.001 a 0.1.\n",
    "    Si cette valeur est trop grand on risque de ne pas tomber sur le minima... on ferra des sauts sans jamais tomber decus, par contre si cette valeur est tres petite on risque de mettre bcp de temps avant d'y arriver on aura donc besoin de beaucoup d'iteration.\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    Si vous avez encore des doutes ou que vous n'avez pas tout compris : Je vous recomande de suivre cette \n",
    "    video youtube qui l'explique bien avant de continuer sur le code : \n",
    "   [Gradient decente Thibault Neveu](https://www.youtube.com/watch?v=JGgT7L7wKQM)\n",
    "   ou encore sur wiki [https://fr.wikipedia.org/wiki/Algorithme_du_gradient](https://fr.wikipedia.org/wiki/Algorithme_du_gradient)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import tools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.datasets import make_regression\n",
    "import pandas as pd\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0)\n",
    "x, y = make_regression(n_samples=180, n_features=1, noise=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(144, 1)"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(36, 1)"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(144,) (36,)\n"
     ]
    }
   ],
   "source": [
    "print(y_train.shape, y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f212439ab70>"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RegressionLinearCustom():\n",
    "    \"\"\"\n",
    "        Implementation Linear Regression Model with gradient decente solution.\n",
    "        The gradient decente use partial derivate.\n",
    "        This model have two essentiel parameters :\n",
    "            - Learning rate : learning_rate (0.01 default)\n",
    "            - max interation : max_iter (1000 default)\n",
    "        The other parameters:\n",
    "            - coefs_ this is coeffients of parameters data\n",
    "            - intercept_ this is intercept of function, can edit it True or False\n",
    "            - error_gradient this is gradient parameters learning.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, learning_rate=0.01, max_iter=1000):\n",
    "        \"\"\"\n",
    "            Initializer parameters model\n",
    "        \"\"\"\n",
    "        self.lrate=learning_rate\n",
    "        self.max_iter=max_iter\n",
    "        self.coefs_=None\n",
    "        self.intercept_= 0\n",
    "        self.error_gradient = None\n",
    "        self.is_fited = False\n",
    "        \n",
    "    def error_coefs(self, coefs,intercept_, xi, yi, m, lr):\n",
    "        \"\"\"\n",
    "            Calcul coefs gradient:\n",
    "            -- Parameters :\n",
    "                - xi : value for one sample in data\n",
    "                - yi : real value prediction for this precedent sample\n",
    "                - m : dataset size\n",
    "                - lr : learning rate\n",
    "        \"\"\"\n",
    "        return lr/m * (xi*(coefs*xi+intercept_-yi))\n",
    "    \n",
    "    def error_intercept(self,coefs, intercept_, xi, yi, m, lr):\n",
    "        \"\"\"\n",
    "            Calcul intercept gradient\n",
    "            -- Parameters:\n",
    "                - xi : value for one sample in data\n",
    "                - yi : real value prediction for this precedent sample\n",
    "                - m : dataset size\n",
    "                - lr : learning rate\n",
    "        \"\"\"\n",
    "        return lr/m * sum(coefs*xi+intercept_-yi)\n",
    "    \n",
    "    def cout_function(self, m, coefs, intercept_, xi, yi):\n",
    "        \"\"\"\n",
    "            Gradient function\n",
    "            -- Parameters:\n",
    "                - xi : value for one sample in data\n",
    "                - yi : real value prediction for this precedent sample\n",
    "                - m : dataset size\n",
    "        \"\"\"\n",
    "        return sum((yi - coefs*xi+intercept_)**2)/2*m\n",
    "    \n",
    "    def score(self, x, y):\n",
    "        \"\"\"\n",
    "            Score function\n",
    "        \"\"\"\n",
    "        return 1 - sum((y-self.predict(x))**2)/sum((y-y.mean())**2)\n",
    "        \n",
    "    \n",
    "    def fit(self,x, y):\n",
    "        \"\"\"\n",
    "            Fit fuction, learning parameters\n",
    "            -- Parameters:\n",
    "                - x, sample data\n",
    "                - y, predict data\n",
    "        \"\"\"\n",
    "        \n",
    "        if x.shape[0] != y.shape[0]:\n",
    "            return ValueError(\"x and y must have same sample\")\n",
    "        \n",
    "        m = x.shape[0] # size du dataset\n",
    "        self.coefs_ = np.zeros(x.shape[1]) # nuers of features\n",
    "        error_intermed = None\n",
    "        for _ in range(self.max_iter):\n",
    "            for xi,yi in zip(x,y):\n",
    "                self.coefs_ -= self.error_coefs(self.coefs_,self.intercept_, xi, yi, m, self.lrate) \n",
    "                self.intercept_ -= self.error_intercept(self.coefs_, self.intercept_, xi, yi,m, self.lrate) \n",
    "                self.error_gradient = self.cout_function(m, self.coefs_, self.intercept_, xi, yi)\n",
    "         \n",
    "        self.is_fited = True\n",
    "        print('RegressionLinear(learning_rate={}, max_iter={})'.format(self.lrate, self.max_iter))\n",
    "    \n",
    "    def predict(self, x):\n",
    "        \"\"\"\n",
    "            Predict function : \n",
    "            -- Parameters:\n",
    "                - x, sample data what to predict\n",
    "        \"\"\"\n",
    "        if not self.is_fited:\n",
    "            return ValueError(\"model must fited after predict\")\n",
    "        if x.shape[1] != self.coefs_.shape[0]:\n",
    "            return ValueError(\"the features of x do not have the same size as those to train\")\n",
    "        return (x*self.coefs_).sum(axis=1)+self.intercept_ # equation -- coefs*X + intercept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = RegressionLinearCustom()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RegressionLinear(learning_rate=0.01, max_iter=1000)\n"
     ]
    }
   ],
   "source": [
    "lr.fit(x_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([21.1303301])"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr.coefs_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.8352580818314677"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr.intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f212433dc50>]"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x_train, y_train)\n",
    "plt.plot(x_train, lr.predict(x_train), c='red', lw=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "     Evalute custum model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE :  7.877842240242018\n",
      "RMSE :  10.042785587416502\n",
      "Median absolute error :  6.54594841083626\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import mean_squared_error, mean_absolute_error, median_absolute_error\n",
    "print('MAE : ', mean_absolute_error(y_test, lr.predict(x_test)))\n",
    "print('RMSE : ', np.sqrt(mean_squared_error(y_test, lr.predict(x_test))))\n",
    "print('Median absolute error : ', median_absolute_error(y_test, lr.predict(x_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score Custum model :  0.7612679859914026\n"
     ]
    }
   ],
   "source": [
    "print('Score Custum model : ', lr.score(x_test, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparaison avec Sklearn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr2 = LinearRegression()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr2.fit(x_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([21.12867091])"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr2.coef_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.8328942101095778"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr2.intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'LinearRegression model')"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEICAYAAABcVE8dAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJztnXeYVcX5xz8vywqLKIsRC4sIKootESVGf9hLsIGIvXdiD2gQDEZNbChGYmKJWBJbFA0EFYxERSxYIgsYK0pEyoIRFSyAssD8/jj3LnfvnnPruf37eZ59du+ZOTPvvRe+M+edd94x5xxCCCHKn1aFNkAIIUR+kOALIUSFIMEXQogKQYIvhBAVggRfCCEqBAm+EEJUCBJ8kRQz29vMZhfajlLFzL4zs60KbUc6mNlfzey6FOt+amYH5domkT0SfNFE0H9c59wrzrntCmTTGWa2JiKa35jZ22Z2RCFsyRTnXHvn3CeFtkMICb4oWsysdeTP151z7YFa4E7gMTOrzWF/QpQlEnyRFDPbz8wWxrz+1Mx+ZWb/MbOvzWysmbWNKT/CzGaZ2TIze83MfhxTNtzM/mtm35rZ+2Z2VEzZGWY2zcxGm9lXwDWxdjjn1gIPAesDPWLu2yPSz7LIE8B+MWXdzezlSH/Pm9kdZvZwpKybmTkzO9vM5gNTUmjvDDP7JNLeXDM7OXJ9GzN7KfJ5fGFmY2PucWa2TeTvDmb2oJktMbN5ZnalmbWKaftVM7vFzJZG2j80wffyqZkNjXwPy83sPjPb1Mz+GfN+O8bU729m70Xe11Qz2z6mrJeZzYjcNxZoG9dX4HcqSgjnnH70g3MO4FPgIJ/r+wEL4+r9G+gMbAR8AJwXKdsV+Bz4GVAFnB6p3yZSfmzkvlbA8cByYPNI2RnAauBioDVQE7n2aqS8CrgQWAVsErlWB3wJHBZp8+DI606R8teBW4D1gL2Ab4CHI2XdAAc8iDeI1CRqL1LnG2C7yP2bAztG/n4UGBG5py2wV8zn5YBtIn8/CDwJbBDp/yPg7Jj33wicG3mv5wOLAEvwfb0BbBqx+3NgBtALaIM3gF0dqbtt5LM+GKgGLgfmRD6X9YB5wJBI2TERO65L8Tv9FJ9/N/opvp+CG6Cf4vkJ+o+Lv+CfEvP6ZuDPkb/vAq6Nu382sG9An7OAIyN/nwHMjys/A28QWBYRoZXAcTHlw4CH4u6ZHBGlrpF728WUPUxLwd8qxfbWj9hxNFATV+dBYAzQxec9OmCbiFj+AOwQU/YLYGrMe50TU9Yucu9mCb6vk2NejwPuinl9MTAh8vdvgMdjyloBDZHvdh/iBhbgtRjBT/idSvBL50cuHZEpn8X8vQJoH/l7S+CyyKP/MjNbBmyBN6vHzE6LcQ0sA3YCNo5pa4FPX28452qBjsBTwN4xZVsCx8b1txfe7Lsz8JVzbkWS9mOvBbbnnFuO91RyHrDYzCaZWc/IfZcDBvw74jY5y6efjVk3m44yD292HqXpc42xuz3B/C/m75U+r6P3do7t13nusQWRvjsDDS6i3jF2RUn4nYrSQYtUImwWANc7566PLzCzLYF7gAPxFmLXmNksPKGMEpi+1Tn3nZldAPzXzO53zs2M9PeQc+7cgP42MrN2MeK5hV/Tcfb7thexYTIw2cxqgOsi72dv59xneK4YzGwv4Hkze9k5Nyfm9i/wnlK2BN6PXOuKN9PONYuAnaMvzMzwPosGvPdfZ2YWI/pdgf9G/g78TkVpoRm+iKfazNrG/KQ7KbgHOM/MfmYe65vZ4Wa2AZ5LxAFLAMzsTLwZfso4574E7gWuilx6GOhnZn3NrCpi835m1sU5Nw+YDlxjZuuZ2Z5AvyRdBLYXWRDtb2br47lmvgPWRN7LsWbWJdLG0sj7XBNn+xrgceB6M9sgMiBdGukz1zwOHG5mB5pZNXBZ5D28hrfOsRq4xMxam9lAYPeYexN9p6KEkOCLeJ7BcwVEf65J52bn3HS8me7teMI3B883jXPufeD3eALzP7wZ57QMbPwDcJiZ/dg5twA4Evg13kCyABjKun/bJwN74i28XgeMxRO6IPsTtdcKTygXAV8B+wIXRG79KfCmmX2H53b6pXNurk8XF+Mtnn4CvAr8Dbg/7U8gTZxzs4FTgD/hPWn0A/o551Y551YBA/G+p6V4bqvxMfcGfqeitLDmbjshyptIyOGHzrmrC22LEPlGM3xR1pjZT81sazNrZWaH4M3eJxTaLiEKgRZtRbmzGZ574kfAQuD8yGKvEBWHXDpCCFEhyKUjhBAVQlG5dDbeeGPXrVu3QpshhBAlRX19/RfOuU7J6oUi+OZlLrwXL6baAWfhbb0ei7d9/VO87fBLE7XTrVs3pk+fHoZJQghRMZjZvOS1wnPp3AY865zrCfwEL5nWcOAF51wP4IXIayGEEAUia8E3sw3xki/dBxDZyLEML/ztgUi1B4AB2fYlhBAic8KY4W+FtyPxL2Y208zujWw939Q5txgg8nsTv5vNbJCZTTez6UuWLAnBHCGEEH6EIfit8fJl3+Wc64W3bTxl941zboxzrrdzrnenTknXHIQQQmRIGIK/EC9X+puR13/HGwD+Z2abA0R+fx5CX0IIITIk6ygd59xnZrbAzLaLJGg6EC/16/t4h0aMjPx+Mtu+hBAiUybMbGDU5NksWraSzrU1DO27HQN61SW/sYwIKw7/YuARM1sPLwvgmXhPD4+b2dnAfLyj7YQQIu9MmNnAFePfYWWjl7G6YdlKrhj/DkBFiX4ogu+cmwX09ik6MIz2hRAiG0ZNnt0k9lFWNq5h1OTZFSX4Sq0ghCh7Fi1bmdb1cqWoUisIIUQu6FxbQ4OPuHeoqabPyCkV49fXDF8IUfYM7bsdNdVVza5VtzKWr1pNw7KVONb59SfMzMcRwx4TZjbQZ+QUug+fRJ+RU3LetwRfCFH2DOhVx40Dd6autgYD6mpraN+2NY1rmqeHj/r180F0ITmfA45cOkKIimBAr7pm7pruwyf51suXX78QC8ma4QshKpLOtTVpXQ+bQiwkS/CFEBWJn1+/prqKoX23y0v/hRhwJPhCiIrEz69/48Cd8xalU4gBRz58IYQoANGBJZ/pHiT4QoiKpBjSLcQvJOcauXSEEBVJoiiZckUzfCFE2eOXKTMfUTIpZeh0Dr79FjbcMLR+g9AMXwhR1gRtcOpQU+1bP6womaQbq774Ajp0gFatvN833BBKv4mQ4Ashypog140ZOY2SCer3tonvwO67Q6dO8M036wpHjAil30RI8IUQZU2Qi2bZisachmXG92tuLaOfvoUXrzoU3nqr5Q0zZoTSbyLkwxdClDVBmTI719bkNEomtt9Lpj3Kpa8+4l9x113h1VehJvc7fDXDF0KUNYXaUTu073Yc++FLfHrTEf5i3749fP451NfnRexBM3whRBmRKComr+fZvvQSA/bbjwFB5bNnw7bb5q7/ACT4QoiyINlGqqjARweFIWNnhS/+H34I228fXP7yy7D33uH0lQFy6QghyoJUNlLlLAf95597bpkgsX/kES/evoBiDxJ8IUSZkMpGqtB3165cCbvsAptuCt9/37L82ms9oT/ppMzaDxkJvhCiLEgl3XBou2vXroXjjoN27eDtt1sUz+93LH1ueJ7u3/XKy9GFqSLBF0KUJPHnwe7fs1PSaJxQctBfeSVUVcETT7Qs22MPnnp9Dn1/chYNX39fsLNyg5DgCyFKDj9f/Lj6Bo7erc53I1V0cGhYthKLayvlEM2//AXM4PrrW5Z17OilSnj9dW6aOq9ok7IpSkcIUXIE+eJf/HAJ04Yf0Oz6lRPe4ZE35hM9rtwBFvldl0qUzgsvwEEHBZd//DFss03Ty0IcXZgqEnwhRMmRqqhOmNnQTOyjRMU+fnBoxnvvwU47BZe/9hrsuWeLy4l29hYauXSEECVHqr74UZNntxD7KIEz7sWLPR99kNg//rgXeeMj9lD4s3ITIcEXQpQcqYpqIjdKi0Fj+XIvjr5zZy8KJ56bbvKE/thjE9pW6LNyExGaS8fMqoDpQINz7ggz6w48BmwEzABOdc6tCqs/IUTlkmq6hCD3isG6wWHNGjj6aHjySf/OzjkHxozxFmzTsK8YBD6eMH34vwQ+AKLHttwEjHbOPWZmfwbOBu4KsT8hRAWTiqgO7btds3QL4In9yXt09e69/HIYNcr/5n32geeeg/XWC9HqwhKKS8fMugCHA/dGXhtwAPD3SJUHIDiPkBBC5AI/98ro43fhuiVveDN2P7HfdFP46it46aWyEnsIb4b/B+ByYIPI6x8By5xzqyOvFwK+Q7GZDQIGAXTt2jUkc4QQwqPZk8Czz8KuXYIrz50L3brlxa5CkPUM38yOAD53ztXHXvap6rtY7pwb45zr7Zzr3alTp2zNEUKIlrz9tjejP/RQ//I33/QWZMtY7CGcGX4foL+ZHQa0xfPh/wGoNbPWkVl+F2BRCH0JIcqARHnrQ6WhAbokmNGPHw9HHRV+v0VK1jN859wVzrkuzrluwAnAFOfcycCLwDGRaqcDAUvgQohKImcpimP59ltv92uQ2I8e7c3oK0jsIbdx+MOAS81sDp5P/74c9iWEKBFCT1Ecy+rVnttmww3hv/9tWX7hhV6M/eDB2fdVgoSaWsE5NxWYGvn7E2D3MNsXQpQ+Ock14xwMGQK33eZfftBB8MwzUF2deR9lgHLpCCHySui5Zm6/HS6+2L9siy3gnXegQ4fM2i4zJPhCiLwStBlq/55pRulNnAj9+gWXz5sHCUK987ZwXEQol44QIq8M6FXH0bvVNYvddsC4+obUFm5nzPBCLIPEvr7ec/EkEfucLxwXIZrhCyGaSDTrDXNG/OKHS1pszIku3Aa2OX8+bLllcKNPPw1HHJFS/4kWjst5li/BF0IA62a9USGMznqjBJVlIpBpLdx+/bWXqnjhQv/Gbr/di77JVf9lhFw6Qggg8aw37FDKlPLZNzZ60TW1tf5iP3iwF2KZptin3H8ZIsEXQgDBs9uGZSt9o2oS3ZOMhPnsnYMLLvASl73wQsubDzvMGwxGj04rZXHK/ZcxcukIIYDEueODTo3KZEYcXQtY2biGKjPWOLfubNmXnoBdh/jfuPXWMHMmbLCBf3kapJpPv9yQ4AshgOBwySCxz2RGHL9OsMY5aqqruHW9ufxs1wODb1y4EOrCFeNiPaQkl0jwhRCA/6w3yJUDZHRsX/xawE8WzebJhy4LvmHWLPjJT9LqQwQjwRdCNBE/6+0zcoqv6NfV1mQVndNl2We8evc5wRWffRb69k27fZEYCb4QZUy2sfN+bp5sFje3a7Oah245g04rlvlXuPtuGDQoo7ZFciT4QpQpieLqUxX90BY3V62Cgw7i2Vde8S3+6PTz2favd6bXpkgbCb4QZUpYu0mzWtx0Ds49F+7zz47+8g7/x1cPPMqA3jreNB9I8IUoUwq+m/Tmm2HYMP+y7beHt95in/XXz48tApDgC1G2hJ6GOFWeeAKOO86/rKrKC7HcbLPc2iB80U5bIcqUvO8mfe01b+drkNi/+653IlURiP2EmQ30GTmF7sMn0WfklLLPkhlFM3whypS87SadMwd69Aguf+45LydOkRDGYnapIsEXogyJD8ccffwuaYtZ0pDOL7/0Dgpf5h9iOePq37PrNZdm8zZyQqWmRgYJvhAFIZenLYUxg03Yxg4bw777wptv+t77xz2P59Z9TqWubQ3Tsn0zOaDgi9kFRIIvRJ7JtUshjBmsXxvfr2qkzdlnwsznfO+Z2HNvLu4/FGfe0mCxCmjBFrOLAC3aCpFnws4tH08YM9j4uhe99hhzb+7PoT5i//HmW9Pz0r9z0ZHDmsQeildAKzU1MmiGL0TeybVLIYwZbLSN/u9P5Y9P3+JfqaYGPv2U9xoasfHvQEjpF3JNpaZGBgm+EHkn1y6FTPPfxK4rHPD5h0z7y6+CK3/wAfTsCcCATbxLpSSglZgaGST4IkRyuRBZToSdkCyeTGaw0XWFzT+bx9x7zwtufOpUb8HWp09918WPBF+EQiXHNqdLLl0KmYZj3jPuTepvPol2jT/4V3joITjllKztE4XFnAs6zyb/9O7d202fPr3QZogMSJQ3fdrwAwpgUeURP+iC9+SQ8KCSlSuhTx/v6EAfbt3rZC595eGm9vUEV5yYWb1zrneyeprhi1Co5NjmYiGtcMy1a+Gkk2DsWN+2xu+4P5cdPoQO7dowLjKYxx53qCe40kRhmSIUghYcizU0rxwJGlwblq1snivm6qu9JGY+Yj9r823Z7rLxXHrEZbSuqmL5qtVNT27xvoAwQ0lFfsha8M1sCzN70cw+MLP3zOyXkesbmdlzZvZx5HfH7M0VxUolxzYXC4kG1yvGv0P97/7gJTf73e9aVujQgWde+A8XXnIXq1qvR11tDe3btqZxTWKXr57gSoswXDqrgcucczPMbAOg3syeA84AXnDOjTSz4cBwICA5tih1Kjm2OZ8k8qP7Rf8A7DnvbR59bERwox99BD16cBhwWMxyS/fhk5Laoye40iJrwXfOLQYWR/7+1sw+AOqAI4H9ItUeAKYiwS9rFJqXW5JFQkU/+8FjZwGwzRfzef6+C4IbfPVVb8E2gKD9AlH0BFd6hOrDN7NuQC/gTWDTyGAQHRQ2CbhnkJlNN7PpS5YsCdMcIcqKVFIyDOhVx05VK/lo1IBgsX/sMe/owQRiD/5uOov8rqutSRz9I4qS0KJ0zKw9MA4Y7Jz7xsyS3QKAc24MMAa8sMyw7BGi3EgaCbV8Oey+OxPff9+33k37ns5f9z6BG7fdmQEp9FdKbjqFjKZGKIJvZtV4Yv+Ic2585PL/zGxz59xiM9sc+DyMvoSoVIJcLF02XA8GDoR//MP3vrE7H8ywQy/xFmxjnghSEchScNNp01/qhBGlY8B9wAfOuVtjip4CTo/8fTrwZLZ9CVHJ+LlYfv3Kg7wy4ue+Yv9W3Q5se9k/GHbYLz2xjxAVxIZlK3Exr0v1mL9cZx8tJ8KY4fcBTgXeMbNZkWu/BkYCj5vZ2cB84NgQ+hKiYol1sez90gRGPvsn33o/dPwR+5x1F/9r3c63vMqsrE580qa/1AkjSudV1q3lxHNgtu0LERbl4OcdsOQ9BlzRN7jCJ59wwNi5/C9A7Gqqq1qIfZRSFchKPtAkXbTTVlQEUT9vrBtjyNhZXDnhnUKblhrvvOO5ZfoGiP3rr3uRN927JxTuGwfuTF2Z7YrWpr/UUS4dURH4+Xkd8Mgb8+m95UYFneknfPJYtAjqEtg2bpy3YBtD0Iy3rramqd1cpmfON6UUTVRoJPiiIgia9TooqO86KMKkasVy+p15BHz8sf+Nt9wCl13Woq1Rk2e3SHQGzQW9HAWyFKKJigEJvqgIEu0aLaTvOv7Jo2rtGm5/9LcceN1b/jecdx7ceWezqBtoOXA4aBL9Oh9Bl0BWJhJ8UfSEsdi6f89OPPzGfN+yQvqumwYb57hyyr2cMz0genn//WHyZKiu9i0OclnpPAIRiwRfFDVhbKqZMLOBcfX+MeaF9l13rq1h/xfHcd2/7vSvUFfHxL89x42vLWbRb/4VOOApNFGkggRfFDVpHeqRRhvgxaOnmw8m1NDOZ55h2hWHBxYPvPxvnHbCPikNeApNFKmgsExR1IQxcw2qu9a5tMU+lB2qM2d6PvjD/cW+32mj6TZsIjNtw5R3kSo0UaSCZviiqEl35uo3Aw9r9pv108aCBdC1a2DxOQN/w/M9ftbMvlQHvHKMvBHhI8EXRY3foR5BM9cgf//Ru9Uxrr4h67jzjJ82vvkGdt4Z5vsvGv/n8t9xdNVuNK5dF0hZ3coY2ne7pjDLePwGq1KIvCmH3c6ljFw6oqgZ0KuuaXeokTgPe9AM/MUPl6TcRiKCngg61FTTZ+QUug+fRJ+RU9a5eBob4ec/hw4d/MX+kktg7Vo+OeGslslJIq+TuWomzGzw77sICc0lJjLGnCueFPS9e/d206dPL7QZokTpPnxSi4O2wdPOuSODF0dTJf4JAryZOEazs19rWrdi0pzH2WrsX/0b6tsXJk6E1t4Ddp+RUwJ3xk4bfkDgrNjPnprqKm4cuDNQfO6dZO9TZI6Z1TvneierJ5eOKBtyHani5ydfsWo1S1c0NtU5Y/pTXPPCGP8GuneHWbNgww2bXU7mKgpy1QQ90Vzz1Hv8sHpt0eWHV+ho4ZHgi7IhHX9/psSLb/Sg74M/foN7xl8XfOOCBdCli29RpgNVkFAuW9nY4loxpD9W6GjhkeCLsiGVSJV0Fg396sa3/39LP+GRMZcEGzVzJuyyS0K7Mx2oOtRU+4p7EIWeSedjQBaJkeCLsiJRpEo6u3b96g79+9vgoHGto8vX/+PVm84OtOO1Pz3I/110aso2Q/o+98Y1a32vtzJY67OYUeiZtEJHC48EX1QM6cTR+9VtXOPY8PvvePW+C9j0u6/8+xgwmB5X/SptEUs3pHLCzAaWr/I/yGSta3nQSbHMpEshdLSckeCLiiGdRcP4a9VrGnlo7G/YY8G7vm3cvftAHhxwAdOuaH7IW67izhOd1xrNjqmZtIhHgi+Khlxvykln0bCprnPcMPkOTnr7Wd82n9tmd35x1AjWtqqCr79nwsyGJpvDSPwWRCJ/fPRzk8CLeBSHL/JO0GJoUEx5WMKVKG7dz4f/0dCrufyF+3zb+u9GXeh3+mhWrNd8sIjNQR8fshklUdx5qoNeUEx7dP+WZvWVRapx+BJ8kReSncbUpnUr34iTsDflpCSo48bBMccEtrH7BQ/w+QY/ytiGoI1g6Q5I8XX9+jl5j65cN2DnjG0VpYEEvwIp1jwlqYhTEJnsks34c3jjDdhzz8DivmfdzuxO3QDo2K7ad/aeKn6nUKW7EzX2fbYyY43P/2UDRh+/S1H8OxC5QzttK4xc+ouzJSgffSqkG0qYyucQPyBcvWNbft6/T2Cbpxx3La9279Xs2rIVjdQlODYxGX52pbsTNdZPH90AFk+hz+wVxYWSp5UJqeZNzxWJknilsuGnY7vqUPK5J/scYhN4bbjyW57+3VHBYn/vvfS58YUWYg/rfOTxNsdTW1NNXcCgFf/9BA1uqQx6ieoUesOVKB4k+GVCIfOUJMuCmEywaqqruLrfjqFktEz2OYyaPJs1K79n3EO/4u0/nshGK79pWfmKK8A5OPvshNkqYzN5QsuElzXVVVzTf0emDT+gRZmfvYn6SpYVc2jf7QL7KPSGK1E8yKVTJhQyT0myDU1+W+pjo1lifdl+Ap+OTz7h5+AcQx65gWPefcH/jRx9NIwdC1XrRDfR7tBYu+pqa9i/Zyde/HCJr52pfD9BfQFJ3VQDetUxfd5XPPLG/BYL4sWw4UoUB1q0LRPSifAIm1TSEme6kJrK+4ptu7ZdNd99v7rZYSI11VWMWzqVHe64ybePDzp148KL7mDKVYel/J6vnPCOr7gGfd7ZfD/pLOYW68K9yC1atK0w8pWnJNMjBDPdCJTs6SFeSJeuaKS6yqitqebrlY2cOu91fvfY9b5t/1BVTZ/z72d57cbc2C/10MUJMxtaiH28XfFk8/2k467ThiuRiJwLvpkdAtwGVAH3OudG5rrPSiXX/9lzfYSg32CSik/eL+fNnos/4K67Bwf2ddKQ+3l9vU3oXFvDlQHCGzRbHjV5tu8TTaxdfmT6/SitsAiLnAq+mVUBdwAHAwuBt8zsKefc+7nsV+SGZEcIZvN0ETSY1AbEu0fFLl5gu33VwNR7fhHYz8Xn3MKBF5zA35LYFu+yifWbJxL1XIiw0gqLsMj1DH93YI5z7hMAM3sMOBKQ4JcgiWbb2T5dBA0mbVq3Spj5MTr77bjia165+xzar/K38dLDhzB+Jy+x2fNJ9ickc9kEzbgNciLCSisswiLXgl8HLIh5vRD4WWwFMxsEDALo2rVrjs0R2ZBL10LQYPL1ykZGH79LoNgN229Lthp4KDst/tj3/vsOPI1rex/X7Fqy05+SuWxGH7+Lb9TRyXt0zZkIyzcvwiDXgu8XGtzs/5JzbgwwBrwonRzbI7IgXddCqhEjE2Y2BKYG6Fxb4y92a9fCKafQ/9FH/Y098UR4+GGu+/U/fYsTuWWSuWw04xalSq4FfyGwRczrLsCiHPcpckQ6QpdqqodoPT+xDxxMfvtbuOYafyN32w1eeQVqvKeOTJ5KUnHZaMYtSpFcC/5bQA8z6w40ACcAJ+W4T5EimcRspyp0qZ4uFZRnp8qsZYz6Qw/Baaf5d9i+PXzyCXTq1OxyJgueQRvFcumyESIf5FTwnXOrzewiYDJeWOb9zrn3ctmnSI1cJ1tLNXY8qN4a5xgydhajJs/mph99yV6DjvOtB8Ds2bDttr5Fmbhf5LIR5UrO4/Cdc88Az+S6H5Ee6ZzvmgmpulKC6gFs9cUCXrjp/OBOXn4Z9t47qS2ZuF+S3aMdraIUUfK0CiXXydYSJQJLVu9Hy5cx+5ajeOG+ALH/29+85GYpiH0uSJYsTohiRYJfoWSTijcVYjNJJsp+GVuvpvF7/nn/RdTffgpt1vgcLnL99Z7Qn3hiKDZmSqFTUQuRKcqlU+Jk6lrYv2enFpuLLHI9LFJ1pQz48WYMuP6X3tGCPjyx00H84aThTLviwNBsy4ZCpqIWIhsk+CVMpguvE2Y2MK6+ocXmIgeMq2+g95Yb5c8fPWIE3HCDb1F9556ceOKNVNW05cZDeqbUXD5868ptI0oVuXRKmExdC4mOHMyba+L++8HMV+yXtt2AfYc9wTGn3kKnjTdMOcVzvnzrqa5PCFFsaIZfwmTqWsi2PCuefx4OPjiweJ9B9zC/4+bU1dYw1+fg7kRkEnmU6V6EaH+K0hGlhAS/hAlyLdS2q6bPyCmBYpQoFDJaHjrvvgs7B+ecH3jKKGbUbd/0OpNBJ90BMJu9CNppK0oRuXRKGD/XQnWV8d33qxO6NRIdvp0sN06ic1V9WbzYc90EiP2Ik66i27CJzcQeMht00o08UrSNqDQk+CWMX+jj+uu1bna8H7QUsQG96jh6t7oWme0MOHo3/5lr2v7x5cuhZ0/o3Nm//OabwTl++qtBofnD0/WtK9pGVBrjPeflAAAP6klEQVRy6ZQ48a6F7sMn+daLF7EXP1ziG6Xz4odLfO9P2T++Zg0cdRQ8/bS/weeeC3ff7c36Cdcfnm5birYRlYYEv8xIVcTSnd0GXW9YttJbL1i6gutff4iTXnnc37B994V//QvWW69FUZj+8HTa0klSotKQS6fMSNWtka6/O+i6AftOHc/cm/v5i/3mm8PSpTB1qq/YF5JUdwMLUS5ohl9mpOrWSHd261d/30/qeeCJq4ONmTsXunXL/M3kAUXbiEpCgl+GpCJi6fq7Y+t3+Og9nvnLJYFtH3narTz5wJAMrRdC5AoJfgWT7uy27eeLE+azGXTUCP617Z7UadFTiKJEgi+S8+23LN9+Jw5pmO9b/NsDz+UvvY8ECrvoqRz1QiRGgp8nCilGGfe9ejUccQRMnsz6PsUP7Ho4o/tdzPptq7ECi2yuT/BK1rcGGlEKSPDzQKHFKO2+nYPBg+GPf/QtfrlbL8465mpWV7XGvl/NrGv65sT2dMj1CV5BFPK7FSJdFJaZBwq5hT/tvm+/HVq18hX7hRt2YqfBj3Pa8deyusqbK6SySSmjlAxpUqhds0rPIEqJsp/hF8PjdiG38Kfc99NPQ//+ge1MfubfDH7ty7Q3KeVrBlyoXbNKzyBKibKe4RfL2aO5Pk4wq77r6700B0FiX18PztH30J9mtEkpXzPgQuWoL+R3K0S6lLXgF8vjdiEPzAjq+6oft/eEvndv/xsnTvR8+bvu2nRpQK86pg0/gLkjD2fa8ANSmqHncwbctnrdP+famuq87JrVYSiilChrl06xPG4X8sCM+L57tF3Dk3edQ811n/nfcMcdcMEFofWfD1dLvNsI4IfVa0NrPxE6DEWUEmUt+MWUDbGQW/gH9KpjwE6bQN++8OKL/pWGDIHf/74pi2VY5CNBWaEidKIoPYMoFcrapaPHbTy3zPnne4nL/MT+sMOgsRFuvTUtsU818iYfCcqK5UlOiGKnrGf4+X7cjo0Iqm1XjXPw9crGrPrNKsro/PPhz3/2L+vRA2bMgPbt0+4n3cibXM+Ai+lJTohipqwFH/L3uB0vgktXNDaVZRqKmKqwxov1PQv/xQ533BTccENDs5Oo0hXwQrtQ4lFeeyFSo+wFP1/4iWAsmQhiKsIaK9Z9Z7/G3RNuCG7w7bfhxz9uui86SLQyY43zPxbRz95ic6Fo4VSI1JDgh0QqYpeuIKYirKMmz2arBbOZ9MDg4IYmTIAjj1z3Mm5GHy/2yfovRheKFk6FSE5Wi7ZmNsrMPjSz/5jZP8ysNqbsCjObY2azzazwyVZyTCpil64g1rarTtzOYi9dcaDYn3eet2gbI/aQ/Gkkmb1+i+EAK1atzvumNiFE6mQbpfMcsJNz7sfAR8AVAGa2A3ACsCNwCHCnmbVUiDIiSASjWKROqkyY2cB3369ucb26yhi2b1cvoibGDx/Lfzbbhj43vgB33eVbnsqTRiIfeDTypram+YC0dEVjQXYyCyFSIyvBd879yzkXVaU3gC6Rv48EHnPO/eCcmwvMAXbPpq9iJyqCHX1m5QacvEfXtP33jWvjXC3O8e/RJ9L//3oE3rf10Cc5/pw/JRxckj1pGHD0boldJAN61bF+m5YeQSUOE6J4CdOHfxYwNvJ3Hd4AEGVh5FoLzGwQMAiga9euIZqTf6J+5DAStsXPwu8Z9zsOnvPvwPq7DB7LsjbrU5dCf35RLbE44MUPl6RtY7LrQojCklTwzex5YDOfohHOuScjdUYAq4FHorf51PddGXTOjQHGAPTu3dt/9bDECGMBMbowOuSVR/jla48G1tt30BjmdfRcO1E3TDrn2fotvkJqol2Mi7dCiGCSCr5z7qBE5WZ2OnAEcKBzTeEeC4EtYqp1ARZlamS54/dE8Adm89ObgnPaXHTu75m4UXO3TTqhn9FBqc/IKRmLdqL492JISy2EaE5WLh0zOwQYBuzrnFsRU/QU8DczuxXoDPQAgv0RFUx8iOTG789iQIKDwrn3Xjj7bCYNn+Rb7DcznzCzgd8+/V7TZrDammqu6b8jA3rVZbVpKSj+HdApUEIUIdn68G8H2gDPmZeH5Q3n3HnOuffM7HHgfTxXz4XOueRxgBVINERy82+W8PpdZwZXHDwYRo9uepmqO2XCzAaG/v1tGtes85YtW9nI0CfeBrLftOTnvuozckpR7cQVQnhkJfjOuW0SlF0PXJ9N+5XA0s+X8unoY4Ir7LUXvPJKi8upzsxHTZ7dTOyjNK51TQIc9qYlLeYKUZxop60PefE/r10LG27I+8uX+xavblVF61U/QJV/bH+qM/NEIpsrAdZirhDFSVmnR86EvByLePDBnpAHiP1uQ8cxcfq8QLGP2pnKoJRIZHMlwEpLLURxIsGPI1fHIk6Y2cBD+53o7ZB9/nnfOnuddx9bD5/El63aMGry7MBBxm9QGjJ2Ft18ctMP7bsd1VUto2SrW1nOBDgfOfCFEOljLiBxViHo3bu3mz59etr3hemC6T58ku+GAQPmjjw8ozbrr72N3a4KTm523i9u49narTGab1aoqa7yFcqgUMpYWx00bcICAqN0hBClj5nVO+cCDqheR8n78NPN5Z6MUP3P06bBXnuxW0DxiKOGMn7HA5psjx9ogiJbkvneo+1EP4sbB+7MzKt+nr79QoiyouRdOmG7YELxP3/6qee62Wsv3+I79ziGbsMm8si2+ybNWukn7ukMPsptI4SIUvIz/LBCAOOPJ2zTulX6xxN+8w106BBY/HK3Xpx2/LVp2eUn7sly4cSjcEghBJSB4IfhgvE7nrCmuorRx++SmtCvWQPV1V7ueR8a263PT4Y8zorV68prqqtoW92q2VGI8QQ9WcTnwon3/cejcEghBJSBSycMF0xWbqG994bWrQPFnu++o3r5d9xw9E9aRK1c3W/HFrZH42mSRbYM6FXHtOEH8OnIwxl9/C7URUQ9Ph5H4ZBCiCglP8MP4zzTjNxCgwfDbbcFl8+fD1usyx+XaDdrurb7RSVNG35AYFkmi9dKfiZE+VEWYZnZEhTmWFdb0ySkTdx7L5x7bnBj//43/PSnIVu4jnj3EwSHbyZqI5GYh9GHECJ/pBqWWfIunTBIyS00daoXeRMk9o895rl1cij2kH1UUio7iXO1+UwIUVgk+CTZGTpnjif0++/ve+/9B5zKhBkL4fjj82JrtlFJqYi5kp8JUZ6UvA8/LFr42Jct84Q+gOe22Z1zj74KgJo85nrPNiopFTFX8jMhyhPN8ONZvdoT+o4dfYu/al9Lt8ufbhJ7yK+7I9uopCDRjr2u5GdClCcVO8P3Xbg890iorw++acUKdvvtFN+ibNwd6UTEZBuVlEoe/TAin4QQxUdFCn58FMr5Y29hwBX/DL5h0SLYfHMgXHfHhJkNXPPUeyxbuW7zVSq5gLI5sCRVMQ/7UBQhROGpSMGPLlyeMmMS1z13V3DF+nrYdddml7I5AzYWv9DHKLk+DlBiLkRlUpGCv9XM15j2+G+CK4wfD0cd5VsUlrvDL1omFkXECCHCprIEf/Zs6NmThwKK/9z3bM579t6kzYQxQ04m6PmIiNFuWiEqi8oQ/C+/hI03DiyeuN1eDD12BDcO3DlvJgWtBUC4ETFBoh72OQJCiOKnvAV/1Spo0yaw+LPaTdhz0H107tiOG/M8uw1KcdyxXTVX9wvnNKpEop5oA5YEX4jypDwF3znYcUf44IPAKk+9Pof+e2zN3DyaFUs+Qh8Tibp20wpReZSf4J95Jvz1r4HFu130MF+uX0vd1Hn032PrrLrK1gee62iZRKKu3bRCVB7ls9P2zju9HbIBYt/3rNvpNmwiX65fC2Q/k00lCVmhSbSrVrtphag8ykPwJ0+GCy/0LRp62nV0GzaR2Z26Nbue7Uy2FDJKJhL1hAnjhBBlSXm4dJ58suW1W26Byy6jz8wGJoawUSqeUvCBJ1sn0AYsISqL8hD8W26BuyI7Zk87DR54oKkoV4ujpeIDl6gLIaKEIvhm9itgFNDJOfeFmRlwG3AYsAI4wzk3I4y+fGnXLvhMWYJFL5tF17BSLAghRL7IWvDNbAvgYGB+zOVDgR6Rn58Bd0V+Fw3ZbjxSRkkhRKkRxgx/NHA5EOtIPxJ40HkH5r5hZrVmtrlzbnEI/YVCGBuP5C4RQpQSWUXpmFl/oME593ZcUR2wIOb1wsg1vzYGmdl0M5u+ZMmSbMxJi1JYdBVCiDBJOsM3s+eBzXyKRgC/Bn7ud5vPNV8nu3NuDDAGoHfv3sGO+JAp1KKrEpYJIQpFUsF3zh3kd93Mdga6A297a7R0AWaY2e54M/otYqp3ARZlbW2IFGLRVQnLhBCFJGOXjnPuHefcJs65bs65bngiv6tz7jPgKeA089gD+LqY/PdAQTYelcJmLSFE+ZKrOPxn8EIy5+CFZZ6Zo36yIt+Lrlo3EEIUktAEPzLLj/7tAP9cBxVMqWzWEkKUJ+WRS6dEUMIyIUQhKY/UCiWCNmsJIQqJBD/PaLOWEKJQyKUjhBAVggRfCCEqBAm+EEJUCBJ8IYSoECT4QghRIZRVlI4SkwkhRDBlI/hKTCaEEIkpG5eOEpMJIURiykbwlZhMCCESUzaCH5SATInJhBDCo2wEX4nJhBAiMWWzaKvEZEIIkZiyEXxQYjIhhEhE2bh0hBBCJEaCL4QQFYIEXwghKgQJvhBCVAgSfCGEqBDMOVdoG5owsyXAvELbUYRsDHxRaCOKHH1GqaHPKTVK7XPa0jnXKVmlohJ84Y+ZTXfO9S60HcWMPqPU0OeUGuX6OcmlI4QQFYIEXwghKgQJfmkwptAGlAD6jFJDn1NqlOXnJB++EEJUCJrhCyFEhSDBF0KICkGCXwKY2bFm9p6ZrTWzsgsVyxYzO8TMZpvZHDMbXmh7ihEzu9/MPjezdwttS7FiZluY2Ytm9kHk/9svC21T2EjwS4N3gYHAy4U2pNgwsyrgDuBQYAfgRDPbobBWFSV/BQ4ptBFFzmrgMufc9sAewIXl9m9Jgl8COOc+cM7pNHZ/dgfmOOc+cc6tAh4DjiywTUWHc+5l4KtC21HMOOcWO+dmRP7+FvgAKKsDNiT4otSpAxbEvF5Imf0nFfnHzLoBvYA3C2tJuJTViVeljJk9D2zmUzTCOfdkvu0pIcznmmKNRcaYWXtgHDDYOfdNoe0JEwl+keCcO6jQNpQoC4EtYl53ARYVyBZR4phZNZ7YP+KcG19oe8JGLh1R6rwF9DCz7ma2HnAC8FSBbRIliJkZcB/wgXPu1kLbkwsk+CWAmR1lZguBPYFJZja50DYVC8651cBFwGS8RbbHnXPvFdaq4sPMHgVeB7Yzs4VmdnahbSpC+gCnAgeY2azIz2GFNipMlFpBCCEqBM3whRCiQpDgCyFEhSDBF0KICkGCL4QQFYIEXwghKgQJvhBCVAgSfCGEqBD+HxvRyBjmSMG5AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x_train,y_train)\n",
    "plt.plot(x_train, lr2.predict(x_train), c='red', lw=3)\n",
    "plt.title('LinearRegression model')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    Evaluate Linear regression sklearn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE :  7.878092566619603\n",
      "RMSE :  10.043458219943728\n",
      "Median absolute error :  6.544939758863786\n"
     ]
    }
   ],
   "source": [
    "print('MAE : ', mean_absolute_error(y_test, lr2.predict(x_test)))\n",
    "print('RMSE : ', np.sqrt(mean_squared_error(y_test, lr2.predict(x_test))))\n",
    "print('Median absolute error : ', median_absolute_error(y_test, lr2.predict(x_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score sklearn model :  0.7612360059607552\n"
     ]
    }
   ],
   "source": [
    "print('Score sklearn model : ', lr2.score(x_test, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple Linear regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0)\n",
    "x1, y1 = make_regression(n_samples=1280, n_features=3, noise=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1_train, x1_test, y1_train, y1_test = train_test_split(x1, y1, test_size=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1024, 3)"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1024,)"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y1_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr3 = RegressionLinearCustom(learning_rate=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RegressionLinear(learning_rate=0.01, max_iter=1000)\n"
     ]
    }
   ],
   "source": [
    "lr3.fit(x1_train, y1_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([64.59675767, 62.55187783, 60.5581771 ])"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr3.coefs_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.8782243776243024"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr3.intercept_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    - Evaluate LinearRegressionCustum for multiple Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE :  9.187022392401918\n",
      "RMSE :  11.324822688558232\n",
      "Median absolute error :  7.700921217861264\n"
     ]
    }
   ],
   "source": [
    "print('MAE : ', mean_absolute_error(y1_test, lr3.predict(x1_test)))\n",
    "print('RMSE : ', np.sqrt(mean_squared_error(y1_test, lr3.predict(x1_test))))\n",
    "print('Median absolute error : ', median_absolute_error(y1_test, lr3.predict(x1_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score Custum model multiple regression :  0.9901428799842829\n"
     ]
    }
   ],
   "source": [
    "print('Score Custum model multiple regression : ', lr3.score(x1_test, y1_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sklearn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import SGDRegressor\n",
    "sg = SGDRegressor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [],
   "source": [
    "lrr3 = LinearRegression()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lrr3.fit(x1_train, y1_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SGDRegressor(alpha=0.0001, average=False, early_stopping=False, epsilon=0.1,\n",
       "             eta0=0.01, fit_intercept=True, l1_ratio=0.15,\n",
       "             learning_rate='invscaling', loss='squared_loss', max_iter=1000,\n",
       "             n_iter_no_change=5, penalty='l2', power_t=0.25, random_state=None,\n",
       "             shuffle=True, tol=0.001, validation_fraction=0.1, verbose=0,\n",
       "             warm_start=False)"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sg.fit(x1_train, y1_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([66.6285208 , 64.15098078, 63.81493204])"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lrr3.coef_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([66.60881996, 64.15799953, 63.74762287])"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sg.coef_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4128450631445766"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lrr3.intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.44550697])"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sg.intercept_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    - Evaluate LinearRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE :  7.9704692752093855\n",
      "RMSE :  9.851604662213807\n",
      "Median absolute error :  6.889328330159444\n"
     ]
    }
   ],
   "source": [
    "print('MAE : ', mean_absolute_error(y1_test, lrr3.predict(x1_test)))\n",
    "print('RMSE : ', np.sqrt(mean_squared_error(y1_test, lrr3.predict(x1_test))))\n",
    "print('Median absolute error : ', median_absolute_error(y1_test, lrr3.predict(x1_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score sklearn model LinearRegression :  0.9925406467656483\n"
     ]
    }
   ],
   "source": [
    "print('Score sklearn model LinearRegression : ', lrr3.score(x1_test, y1_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    - Evaluate SGDRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE :  7.972534909526331\n",
      "RMSE :  9.855358962547134\n",
      "Median absolute error :  6.859896458867109\n"
     ]
    }
   ],
   "source": [
    "print('MAE : ', mean_absolute_error(y1_test, sg.predict(x1_test)))\n",
    "print('RMSE : ', np.sqrt(mean_squared_error(y1_test, sg.predict(x1_test))))\n",
    "print('Median absolute error : ', median_absolute_error(y1_test, sg.predict(x1_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score sklearn SGDRegressor :  0.992534960384724\n"
     ]
    }
   ],
   "source": [
    "print('Score sklearn SGDRegressor : ', sg.score(x1_test, y1_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Piste d'amelioration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    - Ameliorer ce model pour prendre en compte la regression non-linear (avec l'algorithme de regression stockat).\n",
    "    - Jouer sur le learning rate ou le max_inter lorsque le model under-fit.\n",
    "    - Ajouter un peu plus de performance sur modele, notament permettre de normalizer les donnes avant de faire le fit.\n"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}