16_Regresion_Lineal_Simple.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 16 - Regresion Lineal Simple\n",
    "\n",
    "\n",
    "* En este Notebook vamos a ver que es la Regresión Lineal y como se implementaría con la técnica del gradiente descendente:\n",
    "<span></span><br>\n",
    "    1. [Regresión Lineal](#M1)\n",
    "<span></span><br>\n",
    "    2. [Gradiente Descendente: Regresión Lineal Simple](#M2)\n",
    "<span></span><br>\n",
    "    3. [Pseudocódigo del Gradiente Descendente para la Regresión Lineal Simple](#M3)\n",
    "<span></span><br>\n",
    "    4. [Implementación: Regresión Lineal](#M4)\n",
    "<span></span><br>\n",
    "    5. [Ejemplo de Regresión Lineal](#M5)\n",
    "    \n",
    "<hr>\n",
    "\n",
    "# <a name=\"M1\">1. Regresión Lineal</a>\n",
    "\n",
    "* La regresión lineal es uno de los algoritmos clásicos más extendidos y fáciles de entender.\n",
    "\n",
    "\n",
    "* Lo que se pretende hacer es ***modelar la relación*** que existe ***entre*** una ***variable dependiente <span style=\"color:blue; font-size:18px\">Y</span>*** y ***una o más variables independientes <span style=\"color:blue; font-size:18px\">X</span>***:\n",
    "\n",
    "\n",
    "<img src=\"./imgs/15_01_rls.png\" style=\"width: 200px;\"/>\n",
    "\n",
    "\n",
    "* Donde ***a y b*** son dos constantes (coeficientes o parámetros del modelo lineal) que definen, respectivamente, ***la pendiente y el término independiente*** (u ordenada en el origen).\n",
    "\n",
    "\n",
    "* La regresión lineal la podemos imaginar como un problema que consiste en ***obtener la línea azul (y = aX+b) que mejor se ajusta a los puntos rojos dados*** en la imagen.\n",
    "\n",
    "\n",
    "<img src=\"./imgs/15_02_rls.png\" style=\"width: 400px;\"/>\n",
    "\n",
    "\n",
    "* Para obtener esta línea azul, podemos usar ***métodos como el de los mínimos cuadrados***, que busca minimizar la distancia vertical de todos los puntos rojos a la línea azul.\n",
    "\n",
    "\n",
    "* El calcular por ***mínimos cuadrados*** la relación entre las variables dependientes (Y) e independientes (X) es ***muy costoso computacionalmente*** y por tanto si lo tenemos que hacer para muchos datos, el tiempo que se necesita para obtener el resultado puede ser \"infinito\".\n",
    "\n",
    "\n",
    "* El objetivo del ***Machine Learning*** es el de poder dar esta relación (modelo o hipótesis) en un ***tiempo razonable***,  utilizando ***técnicas y algoritmos que permitan obtener la mejor aproximación posible***.\n",
    "\n",
    "\n",
    "<hr>\n",
    "\n",
    "\n",
    "# <a name=\"M2\">2. Gradiente Descendente: Regresión Lineal Simple</a>\n",
    "\n",
    "\n",
    "* Una de las técnicas utilizadas para obtener la relación entre X e Y es la del ***gradiente descendente***.\n",
    "\n",
    "\n",
    "* Dada la hipótesis ***y = aX+b***, el objetivo es el de ***calcular los parámetros ‘a’ y ‘b’ que mejor ajusten la recta a los datos de entrenamiento***.\n",
    "\n",
    "\n",
    "* Para obtener estos parámetros y poder ajustar correctamente la recta necesitamos ***definir una función de perdida (o función de coste)*** que nos diga cual es nuestro ***error para los datos de entrenamiento***, dado un par de valores concretos de ‘a’ y ‘b’.\n",
    "\n",
    "\n",
    "* El ***error*** (error para un ejemplo concreto) y la ***función de perdida*** (el error de todos los ejemplos del conjunto de datos de entrenamiento) suelen ser los siguientes para los problemas de regresión:\n",
    "<span></span><br><br>\n",
    "    - **<span style=\"color:red\">Error:</span>**<br><br>\n",
    "    <span style=\"font-size:20px\">$$error(x^{(i)},y^{(i)},a,b) = (a \\cdot x^{(i)} + b) - y^{(i)}$$</span>\n",
    "<span></span><br><br> \n",
    "    o definiendo: $h(x) = a \\cdot x + b$, definimos el error como:<br><br>\n",
    "    <span style=\"font-size:20px\">$$error(h(x^{(i)}), y^{(i)}) = h(x^{(i)}) - y^{(i)}$$</span>\n",
    "<span></span><br><br> \n",
    "    - **<span style=\"color:red\">Función de Perdida:</span>**<br><br>\n",
    "    <span style=\"font-size:20px\">$$función\\;perdida = E(parámetros) = \\frac{1}{2N} \\sum_{i=1}^{N} error(h(x^{(i)}), y^{(i)})^2$$</span>\n",
    "    \n",
    "<span></span><br><br>   \n",
    "* Por tanto el objetivo de la Regresión Lineal es el de ***encontrar los parámetros ‘a’ y ‘b’ que minimicen la función de perdida***:\n",
    "\n",
    "<span></span><br><br> \n",
    "    <span style=\"font-size:20px\">$$\\underset{a,b}{min} \\: E(a,b) = \\frac{1}{2N} \\sum_{i=1}^{N} ((a \\cdot x^{(i)} + b) - y^{(i)})^2$$</span>\n",
    "<span></span><br><br>   \n",
    "\n",
    "\n",
    "* La técnica del gradiente descendente consiste en ***derivar de forma parcial la función de perdida para cada uno de los parámetros (‘a’ y ‘b’) y moverse una determinada cantidad (α) en el sentido contrario a la pendiente de la derivada***, con el objetivo de encontrar los parámetros (‘a’ y ‘b’) que minimicen la función de perdida:\n",
    "<span></span><br><br>   \n",
    "    <span style=\"font-size:20px\">$$\\Theta^{new}_{j} := \\Theta^{old}_{j} - \\alpha  \\frac{\\partial }{\\partial \\Theta_j}E(\\Theta_0,...,\\Theta_j)$$</span>\n",
    "    \n",
    "    \n",
    "* Para el caso de una ***regresión lineal simple del estilo $y = a \\cdot x + b$*** tenemos que encontrar los ***mejores valores de 'a' y 'b'*** que minimicen la función de perdida.\n",
    "\n",
    "\n",
    "* Para ello ***necesitamos tener un modelo o hipótesis inicial*** que podemos generar de diferentes maneras (por ejemplo de forma aleatoria) y ***tener unos valores iniciales de 'a' y 'b' que vayamos ajustando en función del error cometido***.\n",
    "\n",
    "\n",
    "* La ***forma de ajustar estos valores de 'a' y 'b' seria derivando de manera parcial la función de perdida respecto a 'a' y 'b'***, quedando esta actualización de la siguiente forma:\n",
    "<span></span><br><br>   \n",
    "    <span style=\"font-size:20px\">$$a^{new} := a^{old} - \\alpha  \\frac{1}{N}\\sum_{i=1}^{N} ((a^{old} \\cdot x^{(i)} + b^{old}) - y^{(i)}) \\cdot x^{(i)}$$</span>\n",
    "<span></span><br><br>   \n",
    "    <span style=\"font-size:20px\">$$b^{new} := b^{old} - \\alpha  \\frac{1}{N}\\sum_{i=1}^{N} ((a^{old} \\cdot x^{(i)} + b^{old}) - y^{(i)})$$</span>\n",
    "<span></span><br><br>\n",
    "\n",
    "\n",
    "* Cada vez que actualizamos los parámetros 'a' y 'b' lo hacemos tras haber visto el error cometido por cada uno de los elementos de nuestro Dataset (o conjunto de entrenamiento). ***El recorrer todos los elementos del Dataset, ver el valor de la función de perdida y actualizar los parámetros, se conoce como <span style=\"color:red\">'Epoch'</span>***.\n",
    "\n",
    "\n",
    "* La actualización de los parámetros 'a' y 'b' se hace en cada Epoch, realizando tantos Epochs como sean necesarios hasta que lleguemos a una ***condición de parada*** como por ejemplo:\n",
    "\n",
    "    - Haber realizado 'N' Epochs\n",
    "    - El valor de la función de perdida entre una iteración y otra sea el mismo.\n",
    "    - El valor de la función de perdida entre una iteración y otra tengan una diferencia inferior a un umbral definido.\n",
    "    - El valor de los parámetros 'a' y 'b' entre una iteración y otra tengan una diferencia inferior a un umbral definido.\n",
    "    - Etc.\n",
    "    \n",
    "    \n",
    "* El hiperparámetro **<span style=\"color:red\">$\\alpha$</span>** se conoce como **<span style=\"color:red\">'Learning Rate'</span>** y nos indica la cantidad (α) en el que el gradiente descentente tiene que moverse en el sentido contrario a la pendiente de la derivada. En otras palabras, nos ***indicar 'cuanto' se ajusta el modelo o hipótesis en cada uno de los 'Epochs'***.\n",
    "\n",
    "\n",
    "* El hiperparámetro ***$\\alpha$</span> es un valor \"constante\" que debe de asignarse previo a la ejecución***. Por simplicidad en este curso lo consideraremos como constante, pero existen técnicas (como el recocido simulado entre otras) que optimizan el valor de $\\alpha$ para cada epoch.\n",
    "\n",
    "\n",
    "<hr>\n",
    "\n",
    "\n",
    "# <a name=\"M3\">3. Pseudocódigo del Gradiente Descendente para la Regresión Lineal Simple</a>\n",
    "\n",
    "\n",
    "* Los pasos a dar para obtener el modelo o hipótesis para un problema de regresión lineal sería el siguiente:\n",
    "\n",
    "    1. Definir valor de $\\alpha$\n",
    "    2. Definir número de Epochs\n",
    "    3. Definir condición de parada\n",
    "    4. Generar modelo o hipótesis inicial (de manera aleatoria por ejemplo)\n",
    "    5. Mientras no haya condición de parada ejecutar Epochs:\n",
    "        - Calculamos valor de la función de perdida para el modelo o hipótesis 'old'\n",
    "        - Generamos nuevo modelo o hipótesis 'new' actualizando los parámetros 'a' y 'b'\n",
    "        \n",
    "\n",
    "* Pseudocódigo:\n",
    "\n",
    "\n",
    "```python\n",
    "alpha = 0.01\n",
    "num_epochs = 100\n",
    "condicion_parada = True\n",
    "\n",
    "# inicializamos modelo\n",
    "a_new = random()\n",
    "b_new = random()\n",
    "\n",
    "it_counter = 0\n",
    "while condicion_parada and it_counter < num_epochs:\n",
    "    \n",
    "    # Reasignamos parámetros\n",
    "    a_old = a_new\n",
    "    b_old = b_new\n",
    "    \n",
    "    # Inicializamos errores a cero\n",
    "    funcion_perdida = 0\n",
    "    sum_a = 0\n",
    "    sum_b = 0\n",
    "    \n",
    "    # Recorremos el Dataset para calcular los errores\n",
    "    for i in dataset:\n",
    "        hipotesis_i = (a_old * x[index]) + b_old \n",
    "        error_i = hipotesis_i - y[index]\n",
    "        funcion_perdida += error_i^2\n",
    "        sum_a += error_i * x[i]\n",
    "        sum_b += error_i\n",
    "    \n",
    "    # Actualizamos los valores de los parámetros\n",
    "    a_new = a_old - (alpha * 1/len(dataset) * sum_a)\n",
    "    b_new = b_old - (alpha * 1/len(dataset) * sum_b)\n",
    "    \n",
    "    # Calculamos el valor de la función de perdida del epoch\n",
    "    funcion_perdida = funcion_perdida / 2*len(dataset)\n",
    "    \n",
    "    it_counter+= 1\n",
    "```\n",
    "\n",
    "\n",
    "<hr>\n",
    "\n",
    "\n",
    "# <a name=\"M4\">4. Implementación: Regresión Lineal</a>\n",
    "\n",
    "\n",
    "* En el siguiente fragmento de código, esta implementado la ***regresión lineal simple con el gradiente descendente***, siguiendo el Pseudocódigo mostrado anteriormente junto con alguna lógica programática adicional.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import math\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline \n",
    "\n",
    "\n",
    "def print_iteration_status(epoch, a, b, funcion_perdida):\n",
    "    \"\"\"\n",
    "    Función que imprime por pantalla el resultado del epoch:\n",
    "        - epoch: número del epoch.\n",
    "        - a: parámetro 1.\n",
    "        - b: parámetro 2.\n",
    "        - funcion_perdida: Valor de la función de perdida.\n",
    "    \"\"\"\n",
    "    print ('\\nEpoch {}'.format(epoch))\n",
    "    print ('\\t Y = {a:0.4f} X + {b:0.4f}'.format(a=a, b=b))\n",
    "    print ('\\tFunción de Perdida = {:0.4f}'.format(funcion_perdida))\n",
    "\n",
    "    \n",
    "def is_convergence(a_new, b_new, a_old, b_old, tolerance):\n",
    "    \"\"\"\n",
    "    Función que recibe como argumentos los parámetros antiguos y nuevos de la regresión \n",
    "    y compara los valores para ver si estan por debajo de un umbral y activar la condición\n",
    "    de parada.\n",
    "        - a_new: nuevo valor del parámetro a\n",
    "        - b_new: nuevo valor del parámetro b\n",
    "        - a_old: antiguo valor del parámetro a\n",
    "        - b_old: antiguo valor del parámetro b\n",
    "        - tolerance: Valor de tolerancia\n",
    "    \"\"\"\n",
    "    return math.fabs(a_new - a_old) < tolerance and \\\n",
    "           math.fabs(b_new - b_old) < tolerance\n",
    "\n",
    "\n",
    "def linear_regression(X, y, alpha, num_epochs, tolerance, verbose=False):\n",
    "    \"\"\"\n",
    "    Función que devuelve el modelo o hipótesis de la regresión y la función de perdida por epoch, \n",
    "    recibiendo como parámetros:\n",
    "        - X: Valores de la variable independiente.\n",
    "        - y: Valores de la variable dependiente.\n",
    "        - alpha: Learning Rate.\n",
    "        - num_epochs: Número máximo de epochs.\n",
    "        - tolerance: Valor de tolerancia de los parámetros para la condición de parada.\n",
    "        - verbose: Boolean para indicar si queremos imprimir por pantalla el estado del epoch.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Inicializamos los parámetros de manera aleatoria\n",
    "    a_new, b_new = (random.randrange(0, 10),) * 2\n",
    "    a_old, b_old = (tolerance,) * 2\n",
    "    \n",
    "    # Contador de Eposchs\n",
    "    it_counter = 0\n",
    "    \n",
    "    # Guardamos en una lista los errores cometidos en cada Epoch\n",
    "    errores = []\n",
    "    \n",
    "    # Epochs\n",
    "    while not is_convergence(a_new, b_new, a_old, b_old, tolerance) and it_counter < num_epochs:\n",
    "        \n",
    "        # Reasignamos los valores de los parámetros del epoch anterior\n",
    "        a_old = a_new\n",
    "        b_old = b_new\n",
    "        \n",
    "        # Inicializamos a cero la función de perdida para cada parámetro\n",
    "        funcion_perdida = 0\n",
    "        sum_a = 0\n",
    "        sum_b = 0\n",
    "        \n",
    "        # Recorremos el Dataset para ver los errores cometidos\n",
    "        for index, elem in enumerate(X):\n",
    "            hipotesis = (a_old * X[index]) + b_old    # Resultado del modelo o hipótesis\n",
    "            error_i = hipotesis - y[index]            # Error cometido en la predicción\n",
    "            funcion_perdida += math.pow(error_i, 2)   # Acumulamos el error a la función de perdida\n",
    "            sum_a += error_i * X[index]               # Acumulado del error por el valor de X (para cálculo de a_new)\n",
    "            sum_b += error_i                          # Acumulado del error (para cálculo de b_new)\n",
    "        \n",
    "        # Actualizamos Parámetros\n",
    "        a_new = a_old - ((alpha / len(X)) * sum_a)\n",
    "        b_new = b_old - ((alpha / len(X)) * sum_b)\n",
    "        \n",
    "        # Calculamos el error \n",
    "        funcion_perdida = funcion_perdida / (2 * len(X))\n",
    "        errores.append(funcion_perdida)\n",
    "        \n",
    "        # Incrementamos contador de Epochs\n",
    "        it_counter += 1\n",
    "        \n",
    "        # Imprimimos el estado de la interacción\n",
    "        if verbose:\n",
    "            print_iteration_status(it_counter, a_new, b_new, funcion_perdida)\n",
    "    \n",
    "    return a_new, b_new, errores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "# <a name=\"M5\">5. Ejemplo de Regresión Lineal</a>\n",
    "\n",
    "\n",
    "* Dado un ***conjunto de datos***, obtenidos de forma empírica en el que se muestra cuantas ***calorías quema una persona en función de los minutos que corre***, se pretende encontrar la ***relación entre minutos-calorías***:\n",
    "\n",
    "\n",
    "<span style=\"font-size:16px\">$Calorias = a \\cdot Tiempo + b$</span>\n",
    "\n",
    "\n",
    "* Veamos a continuación el conjunto de datos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "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>Calories</th>\n",
       "      <th>Time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>749.3</td>\n",
       "      <td>40.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>68</th>\n",
       "      <td>291.6</td>\n",
       "      <td>24.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>997.7</td>\n",
       "      <td>71.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>47</th>\n",
       "      <td>696.0</td>\n",
       "      <td>39.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>71</th>\n",
       "      <td>212.0</td>\n",
       "      <td>8.7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    Calories  Time\n",
       "29     749.3  40.1\n",
       "68     291.6  24.6\n",
       "10     997.7  71.3\n",
       "47     696.0  39.7\n",
       "71     212.0   8.7"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv(\"./data/calorias_running/calories_time_reduc.csv\")\n",
    "df.sample(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Por tanto tenemos:\n",
    "    - ***y***: Calories\n",
    "    - ***X***: Time\n",
    "    \n",
    "    \n",
    "* Podemos ver la relación entre los minutos corridos y las calorías:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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": [
    "# Pasamos los valores a un numpy array\n",
    "X = df['Time'].values\n",
    "y = df['Calories'].values\n",
    "\n",
    "# Creamos la gráfica y visualizamos la relación entre minutos y calorías.\n",
    "fig, ax =  plt.subplots(figsize=(6, 4))\n",
    "ax.scatter(X, y,  color='blue', marker='.', )\n",
    "ax.set_title(\"Calorías quemadas por minutos corriendo\")\n",
    "ax.set_xlabel(\"Minutos\")\n",
    "ax.set_ylabel(\"Calorías\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* A continuación vamos a ajustar el modelo para obtener la relación entre las calorías quemadas por minutos corriendo.\n",
    "\n",
    "\n",
    "* Para ello vamos ha hacer uso de la implementación de la regresión lineal con el gradiente descendente, pasándole los siguientes parámetros:\n",
    "\n",
    "    - X: Minutos (Variable Independiente)\n",
    "    - y: Calorías (Variable Dependiente)\n",
    "    - Learning Rate: 0.0001\n",
    "    - num_epochs: 50\n",
    "    - tolerancia sobre los parámetros: 0.01\n",
    "    - Verbose: True para ver la evolución"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 1\n",
      "\t Y = 10.0441 X + 9.0230\n",
      "\tFunción de Perdida = 36514.2953\n",
      "\n",
      "Epoch 2\n",
      "\t Y = 10.8928 X + 9.0420\n",
      "\tFunción de Perdida = 26627.8954\n",
      "\n",
      "Epoch 3\n",
      "\t Y = 11.5826 X + 9.0577\n",
      "\tFunción de Perdida = 20096.2505\n",
      "\n",
      "Epoch 4\n",
      "\t Y = 12.1433 X + 9.0708\n",
      "\tFunción de Perdida = 15780.9877\n",
      "\n",
      "Epoch 5\n",
      "\t Y = 12.5990 X + 9.0817\n",
      "\tFunción de Perdida = 12930.0196\n",
      "\n",
      "Epoch 6\n",
      "\t Y = 12.9694 X + 9.0908\n",
      "\tFunción de Perdida = 11046.4654\n",
      "\n",
      "Epoch 7\n",
      "\t Y = 13.2705 X + 9.0986\n",
      "\tFunción de Perdida = 9802.0516\n",
      "\n",
      "Epoch 8\n",
      "\t Y = 13.5152 X + 9.1052\n",
      "\tFunción de Perdida = 8979.8978\n",
      "\n",
      "Epoch 9\n",
      "\t Y = 13.7141 X + 9.1108\n",
      "\tFunción de Perdida = 8436.7181\n",
      "\n",
      "Epoch 10\n",
      "\t Y = 13.8758 X + 9.1157\n",
      "\tFunción de Perdida = 8077.8479\n",
      "\n",
      "Epoch 11\n",
      "\t Y = 14.0072 X + 9.1200\n",
      "\tFunción de Perdida = 7840.7453\n",
      "\n",
      "Epoch 12\n",
      "\t Y = 14.1140 X + 9.1237\n",
      "\tFunción de Perdida = 7684.0907\n",
      "\n",
      "Epoch 13\n",
      "\t Y = 14.2008 X + 9.1271\n",
      "\tFunción de Perdida = 7580.5856\n",
      "\n",
      "Epoch 14\n",
      "\t Y = 14.2713 X + 9.1301\n",
      "\tFunción de Perdida = 7512.1947\n",
      "\n",
      "Epoch 15\n",
      "\t Y = 14.3286 X + 9.1328\n",
      "\tFunción de Perdida = 7467.0027\n",
      "\n",
      "Epoch 16\n",
      "\t Y = 14.3752 X + 9.1353\n",
      "\tFunción de Perdida = 7437.1375\n",
      "\n",
      "Epoch 17\n",
      "\t Y = 14.4131 X + 9.1377\n",
      "\tFunción de Perdida = 7417.3982\n",
      "\n",
      "Epoch 18\n",
      "\t Y = 14.4439 X + 9.1399\n",
      "\tFunción de Perdida = 7404.3487\n",
      "\n",
      "Epoch 19\n",
      "\t Y = 14.4689 X + 9.1419\n",
      "\tFunción de Perdida = 7395.7191\n",
      "\n",
      "Epoch 20\n",
      "\t Y = 14.4892 X + 9.1439\n",
      "\tFunción de Perdida = 7390.0095\n",
      "\n",
      "Epoch 21\n",
      "\t Y = 14.5057 X + 9.1458\n",
      "\tFunción de Perdida = 7386.2291\n",
      "\n",
      "Epoch 22\n",
      "\t Y = 14.5191 X + 9.1477\n",
      "\tFunción de Perdida = 7383.7232\n",
      "\n",
      "Epoch 23\n",
      "\t Y = 14.5300 X + 9.1494\n",
      "\tFunción de Perdida = 7382.0594\n",
      "\n",
      "Epoch 24\n",
      "\t Y = 14.5389 X + 9.1512\n",
      "\tFunción de Perdida = 7380.9519\n"
     ]
    }
   ],
   "source": [
    "a, b, errores = linear_regression(X=X, y=y, alpha=0.0001, num_epochs=50, tolerance=0.01, verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resultados\n",
    "\n",
    "\n",
    "* Tras la ejecución de la regresión lineal tenemos como resultado un modelo o hipótesis en el que ya conocemos los valores de los parámetros 'a' y 'b'.\n",
    "\n",
    "\n",
    "* En la siguiente gráfica podemos ver las relaciones entre los minutos corridos y las calorías quemadas, asi como la recta de regresión:"
   ]
  },
  {
   "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": [
    "fig, ax =  plt.subplots(figsize=(6, 4))\n",
    "ax.scatter(X, y,  color='blue', marker='.', )\n",
    "ax.plot(X, [(a*x + b) for x in X], color='red')\n",
    "ax.set_title(\"Calorías quemadas por minutos corriendo\")\n",
    "ax.set_xlabel(\"Minutos\")\n",
    "ax.set_ylabel(\"Calorías\")\n",
    "ax.text(0, 1200,\"Calorías = {a:0.4f}·Tiempo + {b:0.4f}\".format(a=a, b=b))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Podemos observar tambien como evoluciona la función de perdida por epoch, viendo como en cada epoch el error es menor que en el epoch anterior:"
   ]
  },
  {
   "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": [
    "fig, ax =  plt.subplots(figsize=(6, 4))\n",
    "ax.plot([index for index, value in enumerate(errores)], [error for error in errores], color='green')\n",
    "ax.set_title(\"Función de perdida por Epoch\")\n",
    "ax.set_xlabel(\"Epoch\")\n",
    "ax.set_ylabel(\"Función de Perdida\")\n",
    "ax.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "*Este Notebook ha sido desarrollado por **Ricardo Moya García** y registrado en Safe Creative como ***Atribución-NoComercial-CompartirIgual***.*\n",
    "\n",
    "<img src=\"./imgs/CC_BY-NC-SA.png\" alt=\"CC BY-NC\">"
   ]
  }
 ],
 "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}