PS - Talus Insper - 2020.2 - Desafio.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PROCESSO SELETIVO TALUS INSPER 2020.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Olá! Esse é o Jupyter com o desafio do processo seletivo para a Talus!\n",
    "\n",
    "É aqui que deve ser posta a resolução do desafio que iremos propor e nenhum outro material entregue junto com este será considerado. Antes de continuarmos para o desafio, precisamos que você se identifique (usuários não identificados podem até passar, mas não receberão notificação &#128521;\n",
    "\n",
    "Edite essa célula e\n",
    "\n",
    "<font color='red'>COLOQUE SEU NOME AQUI</font>\n",
    "\n",
    "<font color='red'>COLOQUE SEU EMAIL INSPER AQUI</font>\n",
    "\n",
    "Se você tiver um usuário do Discord\n",
    "\n",
    "<font color='red'>COLOQUE SEU USUÁRIO AQUI</font>\n",
    "\n",
    "Lembre que não é obrigatório Discord nessa etapa, mas ambas Segunda e Terceira Fase serão realizadas por lá. Nós estamos num servidor do Discord especial feito pra vocês, você pode passar lá e tirar dúvidas com nossos membros a qualquer momento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regras do desafio\n",
    "\n",
    "O desafio que propomos aqui é construir um modelo de regressão linear simples para apenas uma variável.\n",
    "\n",
    "Existem diversas maneiras de fazer isso, a maneira que iremos explicar aqui, e que você deverá reproduzir, é o método de Gradient Descent. Qualquer outro método que não este __NÃO__ será considerado.\n",
    "\n",
    "Uma análise exploratória dos dados não é obrigatória e nem mesmo necessária!\n",
    "\n",
    "Por último, vale frisar: a utilização de pacotes com funções que cortem passos ou que façam o trabalho por você resultará na nulidade de sua solução e __NÃO__ será considerado também.\n",
    "\n",
    "No entanto, você pode usar os pacotes que foram ensinados no arquivo de tutorial para esse desafio.\n",
    "\n",
    "Você irá achar algumas células com código, elas servem para guiar você, mas não são obrigatórias! E você não precisa usar a estrutura que propomos, mas deve seguir o roteiro que se encontra no fim do desafio!\n",
    "\n",
    "Boa sorte, nós estamos esperando por você na Talus!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Proposta de desafio\n",
    "\n",
    "Como dito, o seu desafio será transformar em código a teoria sobre modelos de regressão linear que será ensinada aqui.\n",
    "\n",
    "Você usará o código que criou para prever o comportamento de uma variável em função de outra, estas podem ser achadas no dataset 'desafio.csv' na pasta data. As variáveis foram geradas manualmente por nós e portanto asseguramos que existe uma relação linear entre elas.\n",
    "\n",
    "No nosso dataset, a variável que será prevista é a variável y. Não existe um valor a ser batido, mas existem com certeza valores visivelmente incorretos. Seu código não será avaliado apenas pelo valor dos coeficientes, mas também (e principalmente) pela qualidade do código."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Explicação do modelo\n",
    "\n",
    "Sem entrarmos nos detalhes matemáticos (você irá aprender isso conosco depois), uma regressão linear é um modelo capaz de computar o valor de uma variável através de uma soma com pesos de outras variáveis mais a adição de uma constante (também chamada de viés ou intercepto). De maneira geral, uma relação linear entre variáveis pode ser expressa por:\n",
    "\n",
    "$$y = \\theta_0 + \\theta_1x_1 + \\theta_2x_2 + ... \\theta_nx_n$$\n",
    "\n",
    "Aqui trataremos apenas do caso $n = 1$, sendo $n$ o número de features ou inputs do nosso modelo.\n",
    "\n",
    "Nessa equação, $\\theta_i$ é o parâmetro da feature $i$ sendo $\\theta_0$ o viés."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tamanho do datashet:  (100, 2)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>X</th>\n",
       "      <th>y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.941499</td>\n",
       "      <td>-2.867797</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3.033204</td>\n",
       "      <td>-0.793799</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3.541302</td>\n",
       "      <td>0.679486</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2.486183</td>\n",
       "      <td>-3.625006</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3.739032</td>\n",
       "      <td>-0.607250</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          X         y\n",
       "0  1.941499 -2.867797\n",
       "1  3.033204 -0.793799\n",
       "2  3.541302  0.679486\n",
       "3  2.486183 -3.625006\n",
       "4  3.739032 -0.607250"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# leia nessa célula o dataset \"desafio.csv\" e obtenha os arrays de X e y\n",
    "\n",
    "# lendo dataset e dropando index\n",
    "dataset = pd.read_csv('./data/desafio.csv').drop(['Unnamed: 0'], axis=1)\n",
    "\n",
    "print('Tamanho do datashet: ', dataset.shape)\n",
    "\n",
    "X = dataset['X']\n",
    "y = dataset['y']\n",
    "\n",
    "dataset.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os algoritmos de regressão linear servem para acharmos, de maneira mais eficiente, os parâmetros $\\theta$ de nosso modelo, definida uma métrica.\n",
    "\n",
    "Portanto, antes de falarmos como construirmos e treinarmos um modelo desses, é preciso definir nossa métrica.\n",
    "\n",
    "Existem diversas métricas de avaliação quando falamos de modelos lineares, a mais popular e que usaremos aqui é o __Erro Quadrático Médio__ ou (EQM) que é dado por:\n",
    "\n",
    "$$EQM(ŷ) = \\frac{1}{m}\\sum^m_{i=1}(ŷ_i - y_i)²$$\n",
    "\n",
    "Onde:\n",
    "\n",
    "$m$ é o número de amostras usada no modelo;\n",
    "\n",
    "$ŷ$ é o valor previsto por nosso modelo;\n",
    "\n",
    "$y$ é o valor real da variável prevista.\n",
    "\n",
    "Substituindo a equação linear na fórmula do EQM ficamos com:\n",
    "\n",
    "$$EQM(ŷ) = \\frac{1}{m}\\sum^m_{i=1}(\\theta_1{x_1}_i + \\theta_0 - y_i)²$$\n",
    "\n",
    "E, portanto, vemos que $EQM$ depende do termo quadrático de $\\theta_1$ e $\\theta_0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# crie aqui uma função que calcule EQM\n",
    "# antes, lembre de inicializar o parâmetro m do seu modelo\n",
    "\n",
    "m = X.shape[0]\n",
    "\n",
    "# os parâmetros recebidos pela função ficam a seu critério\n",
    "\n",
    "def calcula_eqm(theta_0, theta_1, X, y, m):\n",
    "    \n",
    "    # com o numpy você pode realizar as operações normalmente\n",
    "    # depois elas seram aplicadas a cada elemento do array\n",
    "    diff = (theta_1*X + theta_0 - y)**2\n",
    "    eqm = diff.sum()/m\n",
    "    \n",
    "    return eqm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como dito, existem várias maneiras de encontrar os parâmetros do nosso modelo, inclusive, um método bem mais simples do que o que vamos ensinar (mas que é BEM mais lento para uma quantidade grande de dados).\n",
    "\n",
    "O método que usaremos se chama *Gradient Descent*, ele é um algoritmo, ou melhor, uma família de algoritmos, bem simples e genérico capaz de encontrar os parâmetros de nossa regressão de uma maneira mais rápida, objetivando minimizar o valor do nosso erro, o $EQM$.\n",
    "\n",
    "Esse método consiste de inicializar, aleatoriamente, o valor dos parâmetros e, iterativamente, modificar esse valor em função do erro obtido.\n",
    "\n",
    "Para explicar bem o procedimento, vamos supor $\\theta_0$ (ou $\\theta_1$) constante. Nesse caso, teríamos que $EQM$ é uma função quadrática de $\\theta_1$, ou seja, uma parábola.\n",
    "\n",
    "Nesse caso, o gráfico de $EQM$ x $\\theta_1$ seria semelhante a:\n",
    "\n",
    "<img src=\"https://cdn-images-1.medium.com/max/600/1*iNPHcCxIvcm7RwkRaMTx1g.jpeg\" height=\"400\" width=\"600\">\n",
    "\n",
    "Onde cost é a função de custo, que no caso é $EQM$.\n",
    "\n",
    "O que queremos é dar, pequenos \"passos\", modificando $\\theta_1$ até alcançarmos aquele que minimiza nosso erro.\n",
    "\n",
    "Caso você não tenha entedido ainda, façamos um exercício de imaginação: imagine que você esteja preso no topo de uma montanha durante uma névoa muito densa, deixando de lado suas habilidades de alpinismo, uma maneira de achar a base da montanha seria deslizar seu pé no chão até achar a direção de descida e então dar pequenos passos nessa direção, é exatamente isso que vamos fazer aqui.\n",
    "\n",
    "O learning step no nosso gráfico seria o tamanho do passo que você daria na montanha e a direção que seu pé indicaria seria o quê? Vamos ver isso agora.\n",
    "\n",
    "Ah, e claro você esteja se coçando que não resolvemos o caso real, com $n$ features, calma, não é o foco desse desafio e não é muito diferente da ideia que mostramos aqui, você só teria que ter uma abstração maior para desenhar o gráfico.\n",
    "\n",
    "<img src=\"https://miro.medium.com/max/1098/1*yasmQ5kvlmbYMe8eDkyl6w.png\" height=\"400\" width=\"600\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tá certo, mas antes de falar sobre a direção do passo, é importante falarmos algo sobre o learning step, ou learning rate como iremos chamar agora.\n",
    "\n",
    "Você se perguntou qual o valor que o learning rate deveria ter? Bom, nós não vamos te dar uma resposta sobre isso, mas vamos te mostrar o que o valor que você escolheu poderia resultar.\n",
    "\n",
    "Se você escolher um learning rate muito pequeno, o seu modelo precisaria de muito mais iterações e execuções para achar o valor de mínimo. É o equivalente a você dar passos que mal separam suas pernas tentando descer a montanha.\n",
    "\n",
    "Já um learning rate muito grande corre o risco de passar do local de mínimo.\n",
    "\n",
    "Veja essas imagens que exemplificam bem isso, mostrando um caso com learning rate pequeno e outro com learning rate muito grande, respectivamente:\n",
    "\n",
    "<div style=\"display: block\">\n",
    "<img src=\"./img/small_lr.png\" height=\"400\" width=\"600\">\n",
    "\n",
    "<img src=\"./img/large_lr.png\" height=\"400\" width=\"600\">\n",
    "</div>\n",
    "\n",
    "O learning rate também é importante para se esquivar de mínimos locais, mas você não precisa se preocupar com isso aqui."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, -3)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# inicialize aqui os parâmetros learning rate e o theta_0 e theta_1 inicial\n",
    "\n",
    "from random import randint\n",
    "\n",
    "# pode escolher qualquer método que gere números randômicos\n",
    "theta_0_ini = randint(-10,10)\n",
    "theta_1_ini = randint(-10,10)\n",
    "\n",
    "learning_rate = 0.1\n",
    "\n",
    "theta_0_ini, theta_1_ini"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, agora vamos pro último fundamento (e o mais importante) pra que você possa concluir o desafio.\n",
    "\n",
    "A análogo matemático da direção do seu passo tentando descer da montanha é o que dá nome a esse algoritmo, o *Gradiente*.\n",
    "\n",
    "Imaginamos que você esteja familiarizado com o conceito de derivada. Imagine no primeiro gráfico que lhe apresentamos que você tivesse que apontar a direção para onde o valor de $\\theta$ precisa andar, talvez você tenha feito com o dedo uma linha tangente apontando para o próximo ponto do gráfico.\n",
    "\n",
    "Devemos achar a tangente, ou mais especificamente, o coeficiente angular desta, para encontrarmos a direção que devemos seguir a fim de minimizar nossa função.\n",
    "\n",
    "E, uma luz pode ter acendido em você, indicando o que será necessário para tal feito: as derivadas.\n",
    "\n",
    "Se calcularmos a derivada para $\\theta_0$ e $\\theta_1$ teríamos:\n",
    "\n",
    "$$\\frac{\\partial}{\\partial\\theta_0}EQM = \\frac{2}{m}\\sum^m_{i=1}(\\theta_1{x_1}_i + \\theta_0 - y_i)$$\n",
    "\n",
    "$$\\frac{\\partial}{\\partial\\theta_1}EQM = \\frac{2}{m}\\sum^m_{i=1}(\\theta_1{x_1}_i + \\theta_0 - y_i){x_1}_i$$\n",
    "\n",
    "O símbolo pode parecer diferente, mas a ideia é a mesma, é que nesse caso estamos falando de derivada parcial.\n",
    "\n",
    "Ah, e o motivo do nome gradiente, vem porque um gradiente basicamente é um vetor formado pela derivada parcial das variáveis de que depende uma função e indico sentido e a direção cujo deslocamento maximiza ou minimiza um valor especificado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# crie aqui as funções que calculam as derivadas parciais de theta_0 e theta_1\n",
    "# não esqueça os parâmetros\n",
    "\n",
    "def dif_theta_0(theta_0, theta_1, X, y, m):\n",
    "    diff = (theta_1*X + theta_0 - y)\n",
    "    return 2*diff.sum()/m\n",
    "    \n",
    "def dif_theta_1(theta_0, theta_1, X, y, m):\n",
    "    diff = (theta_1*X + theta_0 - y)*X\n",
    "    return 2*diff.sum()/m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, agora você tem tudo que precisa para montar o modelo, juntando todas as ideias obtidas até aqui, o processo por meio do qual você irá iterar os parâmetros da sua regressão é o seguinte:\n",
    "\n",
    "$$\\theta_{i+1} = \\theta_{i} - \\mu\\frac{\\partial}{\\partial\\theta}EQM$$\n",
    "\n",
    "Onde\n",
    "\n",
    "$\\theta_i$ é o valor de $\\theta$ (0 ou 1) na i-ésima iteração;\n",
    "\n",
    "$\\mu$ é o learning rate.\n",
    "\n",
    "Com isso, você pode achar o parâmetros da regressão."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# crie aqui a função que realiza a iteração de theta\n",
    "\n",
    "num_iter = 512\n",
    "\n",
    "def itera_theta(num_iter, theta_0, theta_1, lr, X, y, m):\n",
    "    for i in range(num_iter):\n",
    "        theta_0 -= lr*dif_theta_0(theta_0, theta_1, X, y, m)\n",
    "        theta_1 -= lr*dif_theta_1(theta_0, theta_1, X, y, m)\n",
    "    return theta_0, theta_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-7.184679722822106, 2.0536902448632004)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta_0_end, theta_1_end = itera_theta(num_iter, theta_0_ini, theta_1_ini, learning_rate, X, y, m)\n",
    "theta_0_end, theta_1_end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = theta_0_end + theta_1_end*X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEWCAYAAABv+EDhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAA2Q0lEQVR4nO2deXhU5dXAf4cQJbgQFLTKUrB1Y0cCWCPKouAGplpUqihawWqluCGgtEVLS9xprZXi8lmVgoiKCyq1IlpxI2FxAa0LKAmooAZBgobk/f64d8Jk5s5+79xZzu958mTmrucuc877nnPe84oxBkVRFCX/aOa3AIqiKIo/qAFQFEXJU9QAKIqi5ClqABRFUfIUNQCKoih5ihoARVGUPEUNQA4hIr8Xkc9EpLuIvOTD+TuJiBGR5uk+t1eIyHUicq/fcviNiAwUkao4t50mIg+7dN6lInKxG8fKBkTkXhFZIyIdRORFr8+XswZARH4pIhUisl1ENonIcyJyrN9yeUwPYDBwB/Bfn2XJCYwxfzbG5I0CUnynDXAu8Agw3+uT5UxLLRgRuQqYDPwaWAz8AJwEnA686qNoURGR5saYXcnub4z5hf3xBJdEShupXnu6j6tkF26/B169V8aYMvvjMW4fO9IJc+oPaAVsB0ZG2WZPYCaw0f6bCexprxsIVAHXAl8Cm4Ay4BTgf8DXwHVBx5oGLMCy2NuAFUDPoPWTgY/tdWuAnwetGwMsw2qxfwVMB34CLLG/bwHmAMVB+3QAHgc229v8zV4ea78jgaVADfAeMCLCvTkbqAhZdiXwlP35VGAl8C2wAZgWtF0nwADN7e8HA0/Z9+wjYKzDfXvYPtbF9rO7z77n1fb9KLC3/ynwMrDVvr5HIsgfkOFXwGfAK/byi4C1wDdYjYIfB+3zF/tavgUqgQEhcj5sf25hy/uVfR+XAwdGkCPSc2oGTAU+xXq/HgRahch+oS3PN1iNmL7A2/Y5/xblvZ4GPGrLuA14BzgMmGKfawMwNGj7aM+nCHjAlmENMBGoCtn3Mfv61gG/dbpn9vcRWO9cDdY7eGSUazgReN9+zn+zn/nFQesjPkcX3oOhwAf2uf8efG6cf6t7Arfax/8CmAUU2du3AZ6xr/lrrB55M3vdJKz3e5t9viH28n7A6/Y+m+zr3yNIvmOw3rmt9v9jUtaXbineTPnDaunvwlZCEba5EXgDOABoC7wG/NFeN9De//dAITDWfsn/BewDdAVqgc5BL3sd8At7+2vsH0ShvX6k/WNphqVcvwMOCnqpdgHjsXpjRViK7kT75WoLvALMtLcvAFbbL+FeWArpWHtdtP0KsX7g1wF7YLmJtgGHO9yblva6Q4OWLQfOCbo/3e3r6WG/+GUhP7qAAXgF64fUAuhl38fBIfetzD5WEfAE8A/72g4A3gIusbefC1xvb9t43VF++A/axynC6vl9hGUEm2Mp4NeC9jkP2N9edzXwOdAiVJkBlwBP2/eoAOgD7OsgQ7TndJEtyyHA3lhG4qEQ2WfZ+wwFdgIL7fvRDkuRHx/h2qfZ2w+zr+VBrHfxena/y+uCto/2fMqxlNZ+WMbsXWwDYD+DSqzfyB72tXwCDHO4Z4dhvfMn2jJca1//Hg7yt8F69wK/pSuxfh8BJRz1OabyHtjn/hY4w143Aev9DDYAob/VO7AM6H5YuuFpYIa9/Qz7ORbafwMAAQ7HMsQHB8n5E/tzH+Bo+/idsAzVFfa6/bCM1mh7/Sj7+/4p6Uu/Fbbbf1j+s89jbPMxcErQ92HA+iAFV8vuluc+9ovUP2j7SnYrvWnAG0HrmmFZ7wERzr0KOD3opfoshqxlwEr788+wfqQRjVuE/QZgKbVmQevnEtR6D9n3YeD39udDsX6ULSNsOxO4I+hlNvYL2gGoB/YJ2nYG8EDQfXslaN2BwPfYLSh72SjgJfvzg8BsoH2M6w7IcEjQsueAX4U8ox1Ebj1+g92Lo6kyuwirsdAjhgwRnxPwInBZ0PfDsRRN4EdvgHZB678Czg76/hi2UnA49jTghaDvw7F6w6HvcnEcz+cT4KSgdePYbQD6h763WL2M/3O4Z78D5ofc+2pgoIP859P0tyRYvfGAEo77OSb6Htjnfj3k3BtoagA+C1n/HbbyDnru6+zPNwJPAj8NkeunWEb8BOxGYpT36ArgCfvzaOCtkPWvA2OiHSPWXy4Ggb8C2sTIRDkYqwse4FN7WeMxjDH19uda+/8XQetrsVpvATYEPhhjGrBe2oMBROR8EVklIjUiUgN0w2pthO1rb3+giMwTkWoR+RZLGQe27wB8ahx8jzH2OxjYYMsWfM3tQo9j8y8s5QvwS2ChMWaHfZ7+IvKSiGwWka1YLoo2Dsc4GPjaGLMtyjmDr/3HWC2lTUH36h9YLV+wWo4CvCUi74nIRRFkj3TsvwQd92v7WO3sa7pGRNaKyFZ7fasI1/QQlttgnohsFJGbRaTQYbuIzwnnd685lgEMEPquRXv3QgnddovDu7w3sZ/PwTS9h8Ey/xg4OHA/7Xt2Xcg1BGhyvfY7uAHnd6/JOY2l5eJ+jhGId3+nc4dmPQUfqy1WT7Ay6HjP28sBbsHqbfxbRD4Rkcn2cT/CUuzTgC/t32xAVxwmIs+IyOf2b/jPNP0NBz8DiP4bjotcNACvY7Uky6JssxHrZQjQ0V6WLB0CH0SkGdAe2CgiPwbuAS7H6qoVY3WlJWhfE3KsP9vLuhtj9sVyTwS23wB0jGDcou23EehgyxagI1ZLzIkXgLYi0gvLEPwraN2/sLq9HYwxrbC6uRJ2BOuc+4nIPlHOGXztG7CeWxtjTLH9t68xpiuAMeZzY8xYY8zBWK6Yv4vITyPI73TsS4KOW2yMKTLGvCYiA7CMy1lAa/sZbXW6JmNMnTHmBmNMFyx/7GlYLcdQoj0np3dvF00VdzqI9Xw2EfRe2+sCbMBq6Qbfz32MMadEOE/j9YqI2Md1eveanDNo2+DzOj7HKNcZ13tgn7t9yLnbRznWFiyD2jXoWK2MMXsDGGO2GWOuNsYcghUDuUpEhtjr/mWMOda+Lwa4yT7m3Vjxj0Pt3/B1NP0NB783EP03HBc5ZwCMMVuxfJN3iUiZiLQUkUIROVlEbrY3mwtMFZG2ItLG3j6VvOU+InKG/YO/AkuRvYHlezRY7gBE5EKsHkA09sHqtm8VkXZYwbcAb2G9qOUispeItBCR0jj2exOrq3utfS8GYrkH5jkJYIypwwom3oLle3whRL6vjTE7RaQfVg/B6RgbsNwlM2w5e2AF5BzvszFmE/Bv4DYR2VdEmonIT0TkeAARGSkigR/kN1j3tcHpWA7MAqaISFf7WK1EZGTQ9ezCdtmIyO+BfZ0OIiKDxBpjUYDlL66LIEO05zQXuFJEOovI3liG+5EIvQXPiOP5zMe6Z63t+z4+aPe3gG0iMklEikSkQES6iUhfh1PNB04VkSF2b+lqrN+Hk9JeBHQN+i39FvhR0PpozzEeou2/COhu64zmwG9Czt0EuydzD3CHiBxgH6+diAyzP58mIj+1DclWLHdbg4gcLiKDRWRPrHhNLbvfoX2w3qvtInIEcGnQKZ8FDhMrvb25iJwNdMEKNCdNzhkAAGPMbcBVWEGezViW/3KsYBpYEfwKrMyKd7Ayd6ancMonsQK8gSDNGXZrcQ1wG1av5Aus4OmyGMe6ATgK66VZhBUkDFxXPZbi/inWi7LNPm+s/X6w9zsZq+Xyd+B8Y8z7UeT4F5af8tEQ5XQZcKOIbMMynNFylUdh+WI3YgV4/2CM+U+U7c/HCiquwbqXC4CD7HV9gTdFZDtWD2SCMeaTKMdqxBjzBFYra57dtX4X616A5dJ5HivD61OsH+UGp+NgKYQFWPd+LVaWyEMO5wt+Tp9huRICz+l+e59XsAK0O2mqXNNJtOdzA9b9WIdlmBuv076+07ACx+uw3ql7sVxnTTDGfIDVG73T3m44MNx+J0O33YKVNFGO5co9lKDfS4znGJNo+wed+2b73F2wdMT3UQ45CcvN84Z9vP9gxXSwZf8PVqPsdeDvxpiXsJI0yu178TmWi3OKvc81WA2qbVjG5ZEg2b/CuudX2/JdC5xmy500YgcTlCQRkWlYgZ7z0nzejsB0Y4yTC0JRlBSw3aVVwLm24s5JcrIHkOvYroMtWNkYiqK4gIgME5Fi2z0T8L+/4bNYnqIGIDu5CMsARHOnKIqSGD/DShEPuKrKjDG10XfJbtQFpCiKkqdoD0BRFCVPyapicG3atDGdOnXyWwxFUZSsorKycosxpm3o8qwyAJ06daKiosJvMRRFUbIKEQkdRQyoC0hRFCVvUQOgKIqSp6gBUBRFyVOyKgbgRF1dHVVVVezcudNvURSPaNGiBe3bt6ew0KnwpqIoyZL1BqCqqop99tmHTp06YdVdUnIJYwxfffUVVVVVdO7c2W9xFCWnyHoDsHPnTlX+OYyIsP/++7N582a/RVGUtLNwZTW3LP6AjTW1HFxcxMRhh1PWO6UpAJqQ9QYAUOWf4+jzVfKRhSurmfL4O9TWWfP5VNfUMuXxdwBcMwIaBFYURclAbln8QaPyD1BbV88tiz9w7RxqAFygoKCAXr160a1bN4YPH05NTY3fIjXyxRdfMGjQIE466SR+97vfJbTvAw88wOWXXx62/JRTTsmoa1SUXGRjjXMdukjLk8F3F5A9u1IFUG2MOc1veZKhqKiIVatWAXDBBRdw1113cf3116d0zF27dtG8eeqP58ADD+Sll9wtZ/7ss8+6erxQ3Lp2RclmDi4uotpB2R9cXOTaOTKhBzABa3alnOBnP/sZ1dXWNJ0ff/wxJ510En369GHAgAG8//77jcuPPvpounfvztSpU9l7b2uO76VLlzJgwABGjBhBly5dqK+vZ+LEifTt25cePXrwj3/8A4BNmzZx3HHHNfY6/vvf/1JfX8+YMWPo1q0b3bt354477gDgnnvuoW/fvvTs2ZMzzzyTHTt2ALB+/XoGDx5Mjx49GDJkCJ999lnc19ipUye2bNnC+vXrOfLIIxk7dixdu3Zl6NCh1NbWRr32p59+mv79+9O7d29OOOEEvvjCmgp32rRpjB49mtLSUkaPHp3qY1CUrGfisMMpKixosqyosICJww6PsEfi+NrMsucaPRX4E9YUjqlxxRVgt8Rdo1cvmDkzrk3r6+t58cUX+dWvfgXAuHHjmDVrFoceeihvvvkml112GUuWLGHChAlMmDCBUaNGMWvWrCbHWLFiBe+++y6dO3dm9uzZtGrViuXLl/P9999TWlrK0KFDefzxxxk2bBjXX3899fX17Nixg1WrVlFdXc27774L0OiiOeOMMxg7diwAU6dO5b777mP8+PGMHz+eCy64gAsuuID777+f3/72tyxcuDDh2/Phhx8yd+5c7rnnHs466ywee+wxzjvvvIjXfuyxx/LGG28gItx7773cfPPN3HbbbQCsWbOGV199laIi91o4ipKtBAK9uZwFNBNrbst9Im0gIuOAcQAdO3ZMj1QJUltbS69evaiurubII4/kxBNPZPv27bz22muMHLl7zurvv7emF3399dcble0vf/lLrrnmmsZt+vXr15jv/u9//5u3336bBQsWALB161Y+/PBD+vbty0UXXURdXR1lZWX06tWLQw45hE8++YTx48dz6qmnMnToUADeffddpk6dSk1NDdu3b2fYsGGNMjz+uDVt8OjRo7n22muTuvbOnTvTq1cvAPr06cP69eujXntVVRVnn302mzZt4ocffmiS2z9ixAhV/ooSRFnvdq4q/FB8MwAichrwpTGmUkQGRtrOGDMbmA1QUlISffaaOFvqbhOIAezYsYNhw4Zx1113MWbMGIqLixtjA/Gy1157NX42xnDnnXc2Ku1gXnnlFRYtWsSYMWO46qqrOP/881m9ejWLFy9m1qxZzJ8/n/vvv58xY8awcOFCevbsyQMPPMDSpUtTvNqm7Lnnno2fCwoKqK2tpaGhIeK1jx8/nquuuooRI0awdOlSpk2b1rgu+NoVRfEeP2MApcAIEVkPzAMGi8jDPsqTMi1btuSvf/0rt912Gy1btqRz5848+uijgKXMV69eDcDRRx/NY489BsC8efMiHm/YsGHcfffd1NXVAfC///2P7777jk8//ZQDDzyQsWPHcvHFF7NixQq2bNlCQ0MDZ555JtOnT2fFihUAbNu2jYMOOoi6ujrmzJnTeOxjjjmm8dxz5sxhwIABrt2HfffdN+K1b926lXbtrBbNP//5T9fOqSh+s3BlNaXlS+g8eRGl5UtYuLLab5Fi4psBMMZMMca0N8Z0As4BlhhjzvNLHrfo3bs3PXr0YO7cucyZM4f77ruPnj170rVrV5588kkAZs6cye23306PHj346KOPaNWqleOxLr74Yrp06cJRRx1Ft27duOSSS9i1axdLly6lZ8+e9O7dm0ceeYQJEyZQXV3NwIED6dWrF+eddx4zZswA4I9//CP9+/entLSUI444ovHYd955J//3f/9Hjx49eOihh/jLX/7iKMMDDzxA+/btG/+qqqriug+Rrn3atGmMHDmSPn360KZNm7jvq6JkMoFBW9U1tRh2D9rKdCOQEXMC2y6ga2KlgZaUlJjQCWHWrl3LkUce6Z1wHrBjxw6KiooQEebNm8fcuXMbFaTiTDY+ZyV/KC1f4piy2a64iGWTB/sgUVNEpNIYUxK63O8gMADGmKXAUp/FSBuVlZVcfvnlGGMoLi7m/vvv91skRVFSIB2DtrwgIwxAvjFgwIBGn7iiKNlBtMJs6Ri05QWZMBBMURQlo4nl40/HoC0vUAOgKIoSg1iF2cp6t2PGGd1pV1yEYPn+Z5zR3dMcfjdQF5CiKEoM4vHxez1oywu0B6AoihKDSL78TPfxx0INQIoMGjSIxYsXN1k2c+ZMLr300oj7DBw4kNB01kzlqaeeory83G8xFMVXstXHHwt1AaXIqFGjmDdvXpNyDfPmzePmm2927Rz19fUUFBTE3jAGyZRZHjFiBCNGjEj53IqSzaSjMFsAr6eBDCbvegBuD9f+xS9+waJFi/jhhx8Aq8zyxo0bGTBgAJdeeiklJSV07dqVP/zhD477z507l+7du9OtWzcmTZrUuHzvvffm6quvpmfPnrz++us8/PDD9OvXj169enHJJZdQX18fsQR0MGPGjOHXv/41/fv359prr024THPwpDCPPvoo3bp1o2fPnhx33HEp3TdFyTbKerdj2eTBrCs/lWWTB3um/NM5ojivDIAXN3e//fajX79+PPfcc4DV+j/rrLMQEf70pz9RUVHB22+/zcsvv8zbb7/dZN+NGzcyadIklixZwqpVq1i+fHljldDvvvuO/v37s3r1avbff38eeeQRli1bxqpVqygoKGDOnDlNSkC/8847XHjhhY4yVlVV8dprr3H77bczbtw47rzzTiorK7n11lu57LLLABrLNK9cuZJzzjnHsQdz4403snjxYlavXs1TTz2V9D1TFMWZ0GyjgR9XsHb6yZQd1R5eftn18+WVCyhaKlcq1jzgBjr99NOZN28e9913HwDz589n9uzZ7Nq1i02bNrFmzRp69OjRuN/y5csZOHAgbdu2BeDcc8/llVdeoaysjIKCAs4880wAXnzxRSorK+nbt68lc20tBxxwAMOHD3csAR3KyJEjKSgoSLpMc4DS0lLGjBnDWWedxRlnnJH0/VIUP0inayVZAllFx39SyT8fDfEa2L9/N8krA+DVcO3TTz+dK6+8khUrVrBjxw769OnDunXruPXWW1m+fDmtW7dmzJgx7Ny5M+5jtmjRotHvb4zhggsuaCzwFoxTCehQAmWWky3THGDWrFm8+eabLFq0iD59+lBZWcn+++8f9zUpil8Eev+BBmCg9w9klBE44dv13HN303m432rfhSt/cyfLWrZ0/Xx55QLyKpVr7733ZtCgQVx00UWMGjUKgG+//Za99tqLVq1a8cUXXzS6iILp168fL7/8Mlu2bKG+vp65c+dy/PHHh203ZMgQFixYwJdffgnA119/zaeffhqxBHQkUi3T/PHHH9O/f39uvPFG2rZty4YNG+K8Q4riL7EGcvnOxo0gEqb8O016hgvG3OZZtlFe9QAmDju8SSsA3EvlGjVqFD//+c8ba+wHyjUfccQRdOjQgdLS0rB9DjroIMrLyxk0aBDGGE499VROP/30sO26dOnC9OnTGTp0KA0NDRQWFnLXXXdRVFTEhRdeSENDA4BjDyGUOXPmcOmllzJ9+nTq6uo455xz6NmzZ2OZ5tatWzN48GDWrVsXtu/EiRP58MMPMcYwZMgQevbsmehtUhRfyNhibTt3gsMseKUzXmRjTS3tPHZVZUQ56Hhxoxx0NvgBlXC0HLSSChlXrtkYaObggPn+e9hjD9dPl9HloNNJNg7XVhQlNeLp/aetcSgSvuzzz+HAAx0391KuvDMAiqLkH7EGcqUlSOyk+CsqoE+fiLt4LVdOGABjDOJ0c5WcIJvclErmEq3371WKOOCs+OfMgV/+MupuC1dWc/X81dSHvP+uyUUOZAG1aNGCr776SpVEjmKM4auvvqJFixZ+i6LkMJ4EiffYI1z5l5VZ/v84lP+Ux98JU/6uyBVE1vcAAhOVb9682W9RFI9o0aIF7du391sMJYdxdUavM8+Exx9vuqx5c6iri/sQTj2SlOVyIOsNQGFhoeOoVUVRlHhxJUX8uuvAKRU7Ce9EtBa+m1VIs94AKIqiJEK0rJqksm2eeQaGDw9fnoJbOlKPpEDE1ZnG1AAoipI3xMqqSUixfvIJ/OQn4ctdiEdG6pG4Pc2kb0FgEekgIi+JyBoReU9EJvgli6Io+YErJSFqa63gbqjyb2hwRflD+uYY9rMHsAu42hizQkT2ASpF5AVjzBofZVIUJYdJOdvHKaVz+3awCy66SToGrfrWAzDGbDLGrLA/bwPWAjpEV1EUz0i6IKRIuPJ//32rxe+B8k8XGTEOQEQ6Ab2BNx3WjRORChGp0FRPRckt3J6hLxYJz+3rpPgfeshS/Idn93zAkAFBYBHZG3gMuMIY823oemPMbGA2WMXg0iyeoige4UeN/rizfZxcPeecA3PnJn3uTCxE6asBEJFCLOU/xxjzeKztFUXJHTwtvxCFqL71SCVlUgzuTl34DnPe+IzAUTJlQho/s4AEuA9Ya4y53S85FEVJLwG3j1OeO1jKMV0uoUacXD1gKf4Ulf/CldVNlH+ATJiQxs8eQCkwGnhHRFbZy64zxjzrn0iKonhJqNsnEgZvWsmhbpgnnryBA954JWy7zpOesdw0K6tTPvctiz8IU/4B/J6QxjcDYIx5FdASnoqSpSTj045V4yYUN11CwcbnnFXPU774b2HbHDn1OddjEtGUvFs1fZLF9yCwoijZR7IB3GRavG61km9Z/AGHfraWpx68KnylMZSWL6E25FxuGKBIZR0EPJvrN17UACiKkjDJBnAjKcN2dkvYtYqcoWzbxrIpQ8IWd772KZBmrMO7eYOdyjoIcO7RHfM7C0hRlOwkWWUZq+pmyhU5nXAI7vb9zUNs3rs1sNv4uFoSOoiUCs15jBoARVESJlllGY8ydE1ROij+q8sm8djhAxq/BxsYV0pCRyBT5yKXbJpJq6SkxFRUVPgthqLkPU7ZPF5Uq0wKp3TOk0+GZ5+NGbjOxMFabiAilcaYkrDlagAURUmGjFOWHg3iygUiGQB1ASmKkhQZ49ZQxZ80GVEMTlEUJWEijN4tnfEiC1dU+SBQ9qE9AEVRsosILf5Ok56xPmRInZ1sQA2Aoiiu40l84Kqr4I47whb/ZPIi6kPcPekoKpcLqAFQFMVVkhklHNVgvPUW9O8fvs+KKqY8/g71EUpL+F1nJxtQA6AoiqvEGiUcquwHHdGWxyqrwwxGs521jDjm0PAT1NVB8+bcUr4kal0hv+vsZANqABRFSRqnlnu0UcJOvQOnUslrp58M00MWvvcedOnS5HiRcGsAV8alurqMGgBFUZIikqunuGUh3+yoC9v+4OIix95BsPJff9NpYfvdPnw8d3YZxsFPfc7E71s1KuBIo5ELRFwZkObHjGXpRtNAFUVJikiuHmMIm3dXgEFHtI3Yal9/02lhyv/jNh05cupz/LXLsCbzAwQmiYk0v+9tZ/V0RUFHc2XlCtoDUBQlKSIp8621dZx7dMcmrh0DPFZZHdY7cGrxg1WXv0VhM2pDehLBsQSvi6x5VR00k1ADoChKUkQrCPfS+5sdp0Dcs3kzigoLLB+/A4GZuGYMO5wrH1nluE2wAvZyNLJX1UEzCTUAipKDpCN4Ga16ZiTlvWraMOeD2Xn864IW3bL4A18VsJfVQTMFjQEoSo4RCF5W19Q6+s7doqx3O2ac0Z12xUUIVl39QPA1VEk7+fiBqJOuR/Lxp0sBR7u+XEGrgSpKjlFaviTirFvLJg9OiwwBI/Tnx2/i52uWhm8Qp97J9TTMdKHVQBUlT8iE4GXZF+9Q5uTnT7DBmTEVR3MUNQCKkqVEah1HCl42E6Hz5EXetqRra6Fly/DlO3ZAUVFUuZX0ozEARclCovn5Bx3R1nGfemM8jQkgEq78n3/eavUHKf90xCeU+PDVAIjISSLygYh8JCKT/ZRFUbKJaIOUXnp/c8z9XR3Q5FSX/9hjLcU/rGnWTz4MrsomfHMBiUgBcBdwIlAFLBeRp4wxa/ySSVGyBTf8/CnHBJKYiSsT4hPKbvyMAfQDPjLGfAIgIvOA0wE1AIoSg1iDlJzWRdo2YRJQ/KH+/lZFhdTUOtcJUtKPnwagHbAh6HsVEFb0W0TGAeMAOnbsmB7JlJwjGwOP0WSONkip4tOvefiNz6IeO6l8+gQV/w1Pv9ek7EN1TS2FBUJhM6GuYfc+uTa4KpvI+CCwMWa2MabEGFPStq1zcEtRopGNgcdYMkcbpBQpBlAgktyApghz70YaxBWQ3akiaF29Ye8WzXN6cFU24WcPoBroEPS9vb1MUVwl1gQlbuFmLyMemSPlyEfypzcYw7ryU+MXIgkfPzjLHkzNjjpW/n5o/HIonuFnD2A5cKiIdBaRPYBzgKd8lEfJUdIReHS7l5GKzJH86XH72YcPT6jFH0osGdXfnzn4ZgCMMbuAy4HFwFpgvjHmPb/kUXKLhSurKS1fQufJi2gWoSXrpiJyO70xFSWedA2d//7XUvzPPNN0eZyKPx4Z1d+fWfg6EtgY8yzwrJ8yKLlH6ExO9Q7Ky21F5HYvI95KlNHcTnG7o374AfbcM3z5119D69auyA5QXFTItBFd1d+fQWgpCCXniOSDLhChwRhPsoDcrh0fjxKPNWVhXNfn1Dt68EEYPTopueOVXckM1AAoOYdrQdAE8KJ2fCwlnlJw20nxt2sHVVXJiBpGJNmzMR03l1EDoOQcfszk5EerN5KhizoILMnMnkSIpOTzYZL1bEMNgJJz+DWTU3CrN6AEr3xkVUxjkGyrOJKhE/uYTY6RBsUP0d1S6UrHVeIn4weCKUqi+D2TUyIpoamkj0aq+mlgd/ZRgoO4UiWaktc6QJmH9gCUnMTPiUQSaemm0iqOVvVz2ZQhMMVhhcczAEZT8vkwyXq2oQZAUVwmkZZuKq1ip20c592FuAq1uRGziKbk82GS9WxDXUCK4jKJDOJKZcBX8DZ3P/HnhCZd96o+UrRBaF665oIH/pWWL8noOk+ZhPYAFMVlEmnpptIqnjjscOb9dT7zHrgqfGUS9XrcCMjGyobywjWn2UXJowZAUVwmkZTQpNNH6+spO6o9ZSGLn39+OScNK4kpo5cB2XTHXzS7KHnUACiKBySiBBNWmE5ZPX/8I0ydyklxHiKXArKaXZQ8GgNQlGwhWkrn1KkJHSrpgnEZSMrVT/MYNQCKkkE4BjM9yOX3e6yEm+SSMUs3YjzOC3aTkpISU1FR4bcYiuIJocHMRFI68x2tMRQdEak0xoQFhzQGoCgZQiCYGU3xL1xZzS3lSxJSdPmgHP0c+JfNqAFQlAxh2ZQhjss7T3qGdeWnJpXu6FaKZD4YkXxEDYCi+E2EQm2dJlkzc7Wzg5nJpDu6kSLpZEQmPrqaG55+j5oddWoQshg1AIriF2PHwr33hi0OKH5oGsxMJt3RjRRJJyNS12D4ZkcdoAOvshnNAlKUdPPuu1arP1T5NzSwcEVVxMycZNId3UiRjMdYpDL/seIf2gNQlHRhDDRzaHN98AEcdhgQPZiZTNmIQUe0Zc4bnxGcN5RoimSkQWOh6MCr7EN7AIqSDkTClP/Ho35lGQVb+cci0dz9hSureayyuonyF+DMPollzDjl2TuhA6+yD+0BKIqXRAnwFhUWMCN05q4YJJLu6OS7N0SfRyDSOQPH21hTS6uiQr77YRd19btNiw68yk58MQAicgswHPgB+Bi40BhT44csiuIJMTJ7wPuCZW7WyAk1PJoWmhv41QN4AZhijNklIjdhzV00ySdZFMU9Iij+zpOewWn8rpd+cy8LvunAq9zAlxiAMebfxphd9tc3gPZ+yKEorhGjXo8fBcu0Ro4Si5gGQETGi0hrD2W4CHguyvnHiUiFiFRs3pyY7zLf0FmRfCDOQm1+KONcKvimeEPMYnAiMh04B1gB3A8sNnFUkBOR/wA/clh1vTHmSXub64ES4Ix4jqnF4CITOloTLAWjP3iPiODqiVaoTf3mil9EKgYXVzVQERFgKHAhlsKeD9xnjPk4BYHGAJcAQ4wxO+LZRw1AZErLlzj6e9sVF7Fs8mAfJPIG35Xo9Onwu9+FL0+hQqfv16TkPClVAzXGGBH5HPgc2AW0BhaIyAvGmGuTEOYk4Frg+HiVvxKdfJgVyde5X9evh86dw5fX1zsP7ooTnc9W8ZN4YgATRKQSuBlYBnQ3xlwK9AHOTPK8fwP2AV4QkVUiMivJ4yg2+TArUrTCZp4iEq7833478sjeBPDtmhSF+HoA+2H56D8NXmiMaRCRCIXLo2OM+Wky+ymRSaZMQLaR9l6Ok5///PPhn/907RT50HNTMpeYBsAY84co69a6K46SLKGjNXPRl5y2icyTCPDGg5Ovv7hlYWNVzWCKWxamdC5FiQctBZFD5PrgHM97OR4pfojs6xfH4WE666OSHtQAKFmDZ70cDxV/gEi+/kjU1Ib3ChTFbdQAKFmFq72cNCj+AIn69AWr15DLPTrFf7QctJJ/xDl6100ixSmKiwpxMkMGNBNI8Rw1AErWkXTJCx8Uf4BIpSCmjegaIQqgmUCK96gBULKKQDC1uqYWw+5galQj8Pe/+6b4A0Sry9MuD8ZwKJmJxgCUrCLawKkwf/kXX8CPHMpR1dVB8/S/+pHiF/kwhkPJTNQAKFlF3AOnnFr8r70GP/tZyjK4XbsnH8ZwKJmJGgAlq4g5GMxJ8ZeVwRNPuHL+eGr3JGMgcn0Mh5KZaAxAySoiBVOXTRkS2c/voPyTDSTHqt2TVIxCUXxCewBKVhHqLll3U4RyVDHq8idbgTOWCyqhGIWi+IwaAMU3kvWll/VuR9lREWYRjSOrJxUlHcsFpcXdlGxCDYDiC0m3wl0YvZuMkg4Yq+qaWgSa5O4HZ+ykrWCdoriAxgDylGR84G7OOZxwHXwXB3ElOndCsF8fLOUfkCR0nl2diF3JJtQA5CHJBCrdDm5Gam1X19Q2NTA9e7o+iCtRJe1krAy7p9sM7rHoROxKNqEuoDwkGR+428HNSK4SsJRrtzdfpGzKEIeVqY/cTTTvPlGXkaZ0KtmCGoA8JBkfuNvBTafRrwB7fb+D92aeFb7Dzp2w555JncuJRJR0JGNV3LKQ0vIlOnhLyVrUBZSHJDN/sNtzDoe6SgDW33RamPIfdc6frVa/i8o/UZxcRoUFwvaduzTfX8lq1ADkIckEKr0Ibpb1bseyyYNZd9NprA/J519ySAmdJj3DZz37J318t3Dy6++1R3PqGpq6o3QydyXbUBdQHpJM7RlP6tVESOnsNOkZILOyZ0JdRp0nL3LcTvP9lWxCDUCekkyg0rXgZgzFD1AgktHZM5rvr+QCagByBKdRtZBhFSbjUPwBGozJWOUPWsJZyQ18NQAicjVwK9DWGLPFT1myGadRtRMXrAZDo586kXo3bskUq15Pp0nPOE6HCJnfktYSzkou4JsBEJEOwFDgM79kyBWccvTr6sPz5dNVlCxgkNZOP9lxfXCLPzCqNlJphUxG8/2VbMfPHsAdwLXAkz7KkBMkEnhMR5CyzbkjWbv29bDlTq4e2D2qVlvSipJefDEAInI6UG2MWS2Rinvt3nYcMA6gY8eOaZAu+4g2qtZpW8946SUYPJhjQxZHUvwBAiUVFEVJL54ZABH5D+AwISvXA9dhuX9iYoyZDcwGKCkpSc8M3lmGU0CysECaxADAQ9fKzp1QFG5YjrxyAbV7tGj83rplITvrGjRwqigZgmcGwBhzgtNyEekOdAYCrf/2wAoR6WeM+dwreXKZSAFJp2Wuu1YcenCv/+WfXLT5gDBF/4fhXdMjk6IocSHGheJaKQkgsh4oiScLqKSkxFRUVHgvlBIbJ9fdccfByy8D7k+crihK8ohIpTGmJHS5jgNQEiPOCVk0Q0ZRMh/fDYAxppPfMihx4MJMXIqiZBa+GwAlw1HFryg5ixoAxRlV/IqS86gByDI8D66mUfFroFhR/EXnA8gi3J6XtwlXXun63LvR8PRaFEWJC+0BZBFuz8sLwKpV0Lt3+HKPW/zNRKg3zhOqaC9AUdKDGoAswtV5eXftgsLC8OXffAPFxYkfLwahFUtDlX8AnVBFUdKHuoCyCNfm5RUJV/5PPGG1+j1Q/uDce3HC6VoWrqymtHwJnScvorR8ibqJFMUl1ABkESnPyysS5uf/4piBlM54kc5vFHqqXONp2Ttdi8YKFMU71AWUAunOYkl6EpIImT0LV1RZbhlbOXs5aUykiqUFIjQYE/FaPIl7KIoCqAFIGqdZuNIx41ZCJRZipHTeUr4kbco10hSKseb9dTXuoShKE9QFlCTRWqa+4+DqAcJSOtOpXMt6t2PGGd1pV1yEYM0BEM+k767FPRRFCUN7AEmSkS3TBAdxRXLLeKVckykQp5OvK4p3aA8gSTKqZTpkSFKDuFIOKqeBZHsOiqLERnsASZIRLdM5c+C888KXxzmIK+mgcprR0tKK4g1qAJLEV+VZVQUdOoQvT2L0rhfKVWv8KEp2oAYgBSIpT88UoDHQzMFr59Ho3WTwKztKUZTEUQPgAsEKv7hlIdt37mqcjN01Bejk43/hBTjBceplz4hl3DRvX1GyBzUAKRLa4v1mR13YNikpQCfFP2ECzJyZsJyp9kriad1nZHaUoiiOqAFIkXhr3CSsAF2sy++WWyae1n26U0sVRUkeTQNNkXgVe9wKMM5BXIng1qC1eFr32ZBaqiiKhRqAFIlHscelAD1Q/AHccsvEM/ZB8/YVJXtQF1CKOI0HKCwQ9tqjOVtr62L729MwBaNbbpl4xz5o3r6iZAe+GQARGQ/8BqgHFhljrvVDjlSDo0mPB5gwAf761/DlHszE5dagtWwZOKYoSnyI8UDhxDypyCDgeuBUY8z3InKAMebLWPuVlJSYiooK1+QIDY5CfBUqU+Ktt6B///DlKT6HWIZMB2cpSv4iIpXGmJLQ5X71AC4Fyo0x3wPEo/y9IK0561u3Og/WamiI7AZywEmRAzGzfNQtoyhKKH4ZgMOAASLyJ2AncI0xZrnThiIyDhgH0LFjR1eFSEvOeoTRuz1/O5cf9i1mxqqNYYo5Ums9Ujrnns2b6eArRVESxjMDICL/AX7ksOp6+7z7AUcDfYH5InKIcfBHGWNmA7PBcgG5KaPnOesOLfvTR9/G6oNt37uDko6Wsx+pxxJpHIIOvlIUJRqepYEaY04wxnRz+HsSqAIeNxZvAQ1AG69kiYRnOesOKZ3lx4+h06Rndit/m+qa2iZz8UZzS7mVtqkoigL+jQNYCAwCEJHDgD2ALekWwvWcdadc/p49wRiePml0xN2CJzqP5paKpNBbtyzUwVeKoiSMXzGA+4H7ReRd4AfgAif3jxc4+deXTR6c2kHjyOWfOOxwJj66urFIXCiBVn40t1SkdM4/DO8KaHqmoiiJ4YsBMMb8ADjMZOItrpcqbtMGvvoqfLmDLSvr3Y4bnn7PsVhcgI01tdxxdq+IOfux8vBV4SuKkgh5NRLYtbTPSy+FWbPCl8foxNREUf5gtfLjUfKq6BVFcYO8MgApp30uWAAjR4Yvj9N7Fcm9A0199qrkFUVJBzlvAIJ9/s1EqHdQ1jGzZT76CA49NHx5gmELJx8+QHFRIdNGdFWlryhKWslpAxDq83dS/lGzZXbuhCIH45Dg6N0AWktHUZRMIqcNQKTJWgpEaDAmugJ2UvA1NdCqVUoyqXtHUZRMIacNQCTffoMxrCs/1XknJ8X/3nvQpYuLkimKovhPTk8IE88EJo04DeKaN8/y86vyVxQlB8lpAxBXqQcnxf+b31iK/+yz0yCloiiKP+S0AYhU6gFgwTE/D1f87dpZiv9vf0u/sIqiKGkmp2MAEB50/e+9Cxgwtmku/8f7d+CdF17X4KyiKHlFzhuARtatg0MOYUDwotYHMWjcPQC009r5iqLkGflhAO64A666qvHrsh/34Nxz/txkk0ytna9TOSqK4hX5YQDWrLH+jxxJ6VG/9nYSGBdxvXidoihKEDkdBG7knnus4O78+d5NAuMB0YrXKYqipEp+9ACCyKZyDGmZs1hRlLwl7wwAZE85Bs/nLFYUJa/JDxdQlpJN7ipFUbKPvOwBZAvZ5K5SFCX7UAOQ4WSLu0pRlOxDXUCKoih5ihoARVGUPCXvXUDRRtrqKFxFUXKZvDYA0UbaAjoKV1GUnMYXAyAivYBZQAtgF3CZMeatdMsRa6RtpHVqABRFyQX86gHcDNxgjHlORE6xvw9MtxDJjLTVUbiKouQKfgWBDbCv/bkVsNEPIaJNGZnQdJKKoihZiF8G4ArgFhHZANwKTIm0oYiME5EKEanYvHmzq0JEG2mro3AVRcl1PHMBich/gB85rLoeGAJcaYx5TETOAu4DTnA6jjFmNjAboKSkxLgpYzwjbTULSFGUXEWMcVWnxndSka1AsTHGiIgAW40x+8bar6SkxFRUVCR8Pk3nVBQlnxGRSmNMSehyv1xAG4Hj7c+DgQ+9OlEg1bO6phbD7nTOhSurvTqloihKVuBXFtBY4C8i0hzYCYzz6kTRUj21F6AoSj7jiwEwxrwK9EnHuXRSFUVRFGdyvhaQpnMqiqI4k/MGQNM5FUVRnMn5WkA6qYqiKIozOW8AQCdVURRFcSLnXUCKoiiKM2oAFEVR8hQ1AIqiKHmKGgBFUZQ8RQ2AoihKnuJLMbhkEZHNwKcJ7tYG2OKBOJlOPl63XnP+kI/Xnco1/9gY0zZ0YVYZgGQQkQqnKni5Tj5et15z/pCP1+3FNasLSFEUJU9RA6AoipKn5IMBmO23AD6Rj9et15w/5ON1u37NOR8DUBRFUZzJhx6AoiiK4oAaAEVRlDwlpw2AiJwkIh+IyEciMtlvedKBiNwvIl+KyLt+y5IuRKSDiLwkImtE5D0RmeC3TF4jIi1E5C0RWW1f8w1+y5QuRKRARFaKyDN+y5IuRGS9iLwjIqtEpMK14+ZqDEBECoD/AScCVcByYJQxZo2vgnmMiBwHbAceNMZ081uedCAiBwEHGWNWiMg+QCVQlsvPWkQE2MsYs11ECoFXgQnGmDd8Fs1zROQqoATY1xhzmt/ypAMRWQ+UGGNcHfyWyz2AfsBHxphPjDE/APOA032WyXOMMa8AX/stRzoxxmwyxqywP28D1gI5PQGEsdhufy20/3KzNReEiLQHTgXu9VuWXCCXDUA7YEPQ9ypyXCkoICKdgN7Amz6L4jm2K2QV8CXwgjEm568ZmAlcCzT4LEe6McC/RaRSRMa5ddBcNgBKniEiewOPAVcYY771Wx6vMcbUG2N6Ae2BfiKS0y4/ETkN+NIYU+m3LD5wrDHmKOBk4De2qzdlctkAVAMdgr63t5cpOYjtB38MmGOMedxvedKJMaYGeAk4yWdRvKYUGGH7w+cBg0XkYX9FSg/GmGr7/5fAE1gu7pTJZQOwHDhURDqLyB7AOcBTPsukeIAdEL0PWGuMud1vedKBiLQVkWL7cxFWssP7vgrlMcaYKcaY9saYTli/5yXGmPN8FstzRGQvO7kBEdkLGAq4kuWXswbAGLMLuBxYjBUUnG+Mec9fqbxHROYCrwOHi0iViPzKb5nSQCkwGqtFuMr+O8VvoTzmIOAlEXkbq7HzgjEmb9Ii84wDgVdFZDXwFrDIGPO8GwfO2TRQRVEUJTo52wNQFEVRoqMGQFEUJU9RA6AoipKnqAFQFEXJU9QAKIqi5ClqABQlSewqpOtEZD/7e2v7eyefRVOUuFADoChJYozZANwNlNuLyoHZxpj1vgmlKAmg4wAUJQXsEhSVwP3AWKCXMabOX6kUJT6a+y2AomQzxpg6EZkIPA8MVeWvZBPqAlKU1DkZ2ATkdDVOJfdQA6AoKSAivbAKsR0NXGnPTqYoWYEaAEVJErsK6d1Y8w98BtwC3OqvVIoSP2oAFCV5xgKfGWNesL//HThSRI73USZFiRvNAlIURclTtAegKIqSp6gBUBRFyVPUACiKouQpagAURVHyFDUAiqIoeYoaAEVRlDxFDYCiKEqe8v+lXHeUgJmkwAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X,y, label=\"Valores reais\")\n",
    "plt.plot(X,y_pred, color=\"red\", label=\"Regressão Linear\")\n",
    "plt.title(\"Comparação valores reais com modelo de regressão\")\n",
    "plt.xlabel(\"X\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pronto, a partir daqui é com você. Mas nós vamos dar mais uma mãozinha. Nós preparamos um roteiro e __ATENÇÃO__ todos os pontos são __OBRIGATÓRIOS__ mas a execução é totalmente por sua conta.\n",
    "\n",
    "- Leia o arquivo \"desafio.csv\" na pasta data\n",
    "- Obtenha as variáveis X e y no dataset\n",
    "- Inicialize (e deixe bem claro onde fez isso) os parâmetros de seu modelo:\n",
    "    - Learning rate;\n",
    "    - Número de iterações;\n",
    "    - Número de amostras;\n",
    "    - $\\theta_0$ e $\\theta_1$ iniciais, gerados aleatoriamente.\n",
    "- Desenvolva a função que calcula EQM\n",
    "- Desenvolva uma (ou duas) funções que devolva a derivada parcial de EQM para cada um dos $\\theta$\n",
    "- Desenvolva a função que itera $\\theta_0$ e $\\theta_1$ e devolva os valores finais\n",
    "- Plote um gráfico contendo:\n",
    "    - Os valores reais de X e y\n",
    "    - A reta formada pelos valores de $\\theta$ encontrados por você\n",
    "    \n",
    "Ainda que você não consiga concretizar um dos passos, NÃO desista. Novamente, o foco não é no resultado, mas na qualidade de seu código.\n",
    "\n",
    "__BOA SORTE!__"
   ]
  }
 ],
 "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}