24_Hold_Out_Regresion_Lineal_Multiple.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 24 - Hold Out: Regresion Lineal Multiple\n",
    "\n",
    "\n",
    "* El objetivo de este Notebook es el de resolver un problema de regresión con unos ***datos de entrenamiento*** y **testear el modelo o hipótesis obtenido con los datos de test.**\n",
    "\n",
    "\n",
    "* Para ello, dado un Dataset, vamos a particionar los datos con la técnica de particionado ***Hold Out*** y vamos a:\n",
    "\n",
    "    1. Entrenar el modelo con los datos de Entrenamiento\n",
    "    2. Evaluar el modelo con los datos de Entrenamiento\n",
    "    3. Evaluar el modelo con los datos de Test\n",
    "    4. Conclusiones: Comparativa de las evaluaciones del modelo con los datos de Entrenamiento y Test\n",
    "\n",
    "\n",
    "* El ejemplo que vamos a realizar consiste en predecir cuantas calorías voy a quemar en función de los minutos que voy a estar corriendo, la velocidad media a la que corro y mi peso. Por ello tenemos un conjunto de datos tomados de forma empírica que nos dan esa relación. Por tanto el objetivo es encontrar los parámetros de la recta que mejor se ajustan a esos datos.\n",
    "\n",
    "\n",
    "* El ejemplo que vamos a realizar, consiste en predecir cuantas ***calorías quema una persona en función de los minutos que corre, la velocidad a la que corre y su peso corporal***. Por ello tenemos un conjunto de datos tomados de forma empírica que nos dan esa relación.\n",
    "\n",
    "\n",
    "* El objetivo es encontrar los parámetros $\\beta_0, \\beta_1, \\beta_2, \\beta_3$ que ***mejor se ajustan a los datos de entrenamiento***.\n",
    "\n",
    "<span style=\"font-size:18px\">$$Calorias = \\beta_0 + \\beta_1 \\cdot Tiempo + \\beta_3 \\cdot Velocidad + \\beta_3 \\cdot Peso$$</span>\n",
    "\n",
    "\n",
    "* Para ello vamos a realizar los siguientes pasos:\n",
    "\n",
    "    1. Carga de Datos\n",
    "    2. Cambio de estructura de datos a numpy\n",
    "    3. Particionado de datos en Entrenamiento y Test\n",
    "    4. Generación del modelo con los datos de Entrenamiento\n",
    "    5. Evaluación del modelo con los datos de Entrenamiento\n",
    "    6. Evaluación del modelo con los datos de Test\n",
    "    7. Conclusiones: Comparativa de resultados\n",
    "\n",
    "<hr>\n",
    "\n",
    "\n",
    "* En primer lugar importemos las librerías necesarias:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn import linear_model\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import mean_absolute_error, mean_squared_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "## 1. Carga de Datos\n",
    "\n",
    "\n",
    "* El primer paso que vamos a realizar es el de cargar los datos que los tenemos en los siguientes ficheros:\n",
    "    - ***DataSet***: \"./data/calorias_running/calories_time_weight_speed.csv\"\n",
    "\n",
    "\n",
    "* Para ello ***leeremos el csv con pandas*** (pasandolo a un dataframe), teniendo las siguientes columnas:\n",
    "    - Calorias\n",
    "    - Tiempo\n",
    "    - Peso\n",
    "    - Velocidad"
   ]
  },
  {
   "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>Calorias</th>\n",
       "      <th>Tiempo</th>\n",
       "      <th>Peso</th>\n",
       "      <th>Velocidad</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4549</th>\n",
       "      <td>102.1</td>\n",
       "      <td>8.4</td>\n",
       "      <td>59.2</td>\n",
       "      <td>12.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2230</th>\n",
       "      <td>578.4</td>\n",
       "      <td>33.5</td>\n",
       "      <td>71.9</td>\n",
       "      <td>13.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1951</th>\n",
       "      <td>772.3</td>\n",
       "      <td>66.6</td>\n",
       "      <td>68.9</td>\n",
       "      <td>9.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3111</th>\n",
       "      <td>711.4</td>\n",
       "      <td>68.8</td>\n",
       "      <td>60.1</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>76</th>\n",
       "      <td>488.7</td>\n",
       "      <td>32.4</td>\n",
       "      <td>84.7</td>\n",
       "      <td>10.3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Calorias  Tiempo  Peso  Velocidad\n",
       "4549     102.1     8.4  59.2       12.0\n",
       "2230     578.4    33.5  71.9       13.9\n",
       "1951     772.3    66.6  68.9        9.7\n",
       "3111     711.4    68.8  60.1       10.0\n",
       "76       488.7    32.4  84.7       10.3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv(\"./data/calorias_running/calories_time_weight_speed.csv\")\n",
    "df.sample(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "## 2. Cambio de estructura de datos a numpy\n",
    "\n",
    "\n",
    "* Vamos a pasar los datos de las calorias y el tiempo a una nueva estructura de datos para que scikit-learn puedan trabajar con los datos:\n",
    "<span></span><br><br>\n",
    "    - Las ***columna Tiempo, Peso y Velocidad*** representan las variables independientes 'x<sub>n</sub>' y las vamos a pasar a un array de array (***numpy array***)\n",
    "<span></span><br><br>\n",
    "    - La ***columna calorias*** que representa la variable dependiente 'y', la vamos a pasar a un ***numpy array***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df[['Tiempo', 'Velocidad', 'Peso']].values\n",
    "y = df['Calorias'].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "## 3. Particionado de datos en Entrenamiento y Test\n",
    "\n",
    "\n",
    "* En este punto vamos a dividir el dataset en un conjunto de datos de entrenamiento y datos de test.\n",
    "\n",
    "\n",
    "* Para ello vamos a llamar a la función ***train_test_split()*** y dividimos los datos en entrenamiento y test. Para este ejemplo vamos a coger un ***20% de datos de test y un 80% de datos de entrenamiento.***\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(2)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "## 4. Generación del modelo con los datos de Entrenamiento\n",
    "\n",
    "* A continuación pasamos a crear un objeto de la clase \"***LinearRegression()***\" para la resolución del problema de regresión.\n",
    "\n",
    "\n",
    "* Una vez instanciado, procedemos a ajustar (entrenar) el modelo (o hipótesis) llamando al método ***fit(X,y)*** que recibe como parámetros el conjunto de datos de entrenamiento de las variables independientes 'X' y la variable dependiente 'Y'.\n",
    "\n",
    "\n",
    "* Una vez ajustado (o entrenado) el modelo (o hipótesis), tendremos ajustados los parámetros ***$\\beta_n$*** de la siguiente manera:\n",
    "\n",
    "<span style=\"font-size:16px\">$$Calorias = \\beta_0 + \\beta_1 \\cdot Tiempo + \\beta_3 \\cdot Velocidad + \\beta_3 \\cdot Peso$$</span>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression()"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creamos un objeto de la clase LinearRegression\n",
    "reg_mul = linear_model.LinearRegression()\n",
    "\n",
    "# Entrenamos el modelo pasandole las variables independientes y dependiente\n",
    "reg_mul.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "## 5. Evaluación del modelo con los datos de Entrenamiento\n",
    "\n",
    "\n",
    "* Llegados a este punto podemos medir el ***error que comete el modelo***, en este caso con los datos de entrenamiento, que son datos que se han utilizado para generar el modelo (o hipótesis).\n",
    "\n",
    "\n",
    "* Para ello vamos a utilizar 2 medidas de ***Accuracy***:\n",
    "\n",
    "    1. ***MAE***: Mean Absolute Error (Error Absoluto Medio)\n",
    "    2. ***MSE***: Mean Squared Error (Error Cuadrático Medio) \n",
    "    \n",
    "    \n",
    "* Para calcular esta medidas, necesitamos tener el valor real de la salida y la predicción del modelo.\n",
    "\n",
    "\n",
    "* Para obtener la predicción del modelo, utilizamos el método ***.predict(X)*** pasándole los datos a predecir y obteniendo el resultado.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error Absoluto Medio (MAE): 48.14348666783389\n",
      "Error Cuadrático Medio (MSE): 4425.892283745691\n"
     ]
    }
   ],
   "source": [
    "# Obtenemos las predicciones del modelo con los datos de entrenamiento\n",
    "y_predict = reg_mul.predict(X_train)\n",
    "\n",
    "# Calculamos los errores\n",
    "mae_train = mean_absolute_error(y_true=y_train, y_pred=y_predict)\n",
    "mse_train = mean_squared_error(y_true=y_train, y_pred=y_predict)\n",
    "\n",
    "print(\"Error Absoluto Medio (MAE): {error}\".format(error=mae_train))\n",
    "print(\"Error Cuadrático Medio (MSE): {error}\".format(error=mse_train))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "## 6. Evaluación del modelo con los datos de Test\n",
    "\n",
    "\n",
    "* Vamos a realizar los mismos pasos que en el punto anterior, pero en este caso vamos a ver el error cometido con los datos de test.\n",
    "\n",
    "\n",
    "* Para ello necesitamos predecir cual es la salida del modelo con los datos de test y esto lo hacemos llamando al método ***.predict(X)***.\n",
    "\n",
    "\n",
    "* Con las predicciones y los resultados reales calculamos los errores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error Absoluto Medio (MAE): 48.44305689079678\n",
      "Error Cuadrático Medio (MSE): 4508.549637473969\n"
     ]
    }
   ],
   "source": [
    "# Obtenemos las predicciones del modelo con los datos de test\n",
    "y_predict = reg_mul.predict(X_test)\n",
    "\n",
    "# Calculamos los errores\n",
    "mae_test = mean_absolute_error(y_true=y_test, y_pred=y_predict)\n",
    "mse_test = mean_squared_error(y_true=y_test, y_pred=y_predict)\n",
    "\n",
    "print(\"Error Absoluto Medio (MAE): {error}\".format(error=mae_test))\n",
    "print(\"Error Cuadrático Medio (MSE): {error}\".format(error=mse_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "## 7. Conclusiones: Comparativa de resultados\n",
    "\n",
    "\n",
    "* Podemos observar que los errores cometidos con los datos de entrenamiento y test son muy similares.\n",
    "\n",
    "\n",
    "* El ***error absoluto medio*** nos dice el ***error medio que cometemos en la predicción de las calorias quemadas***; es decir, que al hacer las predicciones nos equivocamos de media en 48 calorias.\n",
    "\n",
    "\n",
    "* Si nos fijamos ***el MAE es practicamente igual*** evaluándolo tanto ***con los datos de entrenamiento como con los de test***, lo que significa que el modelo generado es un ***modelo muy estable*** que generaliza bastante bien.\n",
    "\n",
    "\n",
    "* ***Si los errores cometidos con los datos de entrenamiento y test fuesen muy dispares podria significar que***:\n",
    "\n",
    "    - Tenemos pocos datos de los que aprender.\n",
    "    - Hay mucha varianza en los datos.\n",
    "    - Estamos particionando mal los datos en entrenamiento y test (mucho sesgo en cada partición)\n",
    "    - Estamos entrenando mall nuestro modelo\n",
    "    - Etc."
   ]
  },
  {
   "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
}