09-[TALLER]_Modelos_parametricos_vs_Modelos_no_parametricos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://colab.research.google.com/github/UDEA-Esp-Analitica-y-Ciencia-de-Datos/EACD-04-MACHINE-LEARNING-1/blob/master/09-[TALLER]_Modelos_parametricos_vs_Modelos_no_parametricos.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
    "\n",
    "\n",
    "**Recuerda que una vez abierto, da clic en \"Copiar en Drive\", de lo contrario no podras alamancenar tu progreso**\n",
    "\n",
    "Nota: no olvide ir ejecutando las celdas de código de arriba hacia abajo para que no tenga errores de importación de librerías o por falta de definición de variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget --no-cache -O init.py -q https://raw.githubusercontent.com/UDEA-Esp-Analitica-y-Ciencia-de-Datos/EACD-04-MACHINE-LEARNING-1/master/init.py\n",
    "import init; init.init(force_download=False); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Taller - Parte 1\n",
    "\n",
    "**Clasificación**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 1: Contextualización del problema\n",
    "\n",
    "\n",
    "Usaremos el dataset digits para el problema de clasificación. En el repositorio de sklearn se encuentra más información en el siguiente [link](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html) ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lab configuration started\n",
      "installing libraries\n",
      "downloading files\n",
      "lab configured\n"
     ]
    }
   ],
   "source": [
    "#configuración del laboratorio\n",
    "# Ejecuta esta celda!\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "# for local \n",
    "\n",
    "from local.lib.general import configure_lab2\n",
    "configure_lab2()\n",
    "from local.lib.lab2 import *\n",
    "GRADER, x, y = part_1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Número de muestras 1797\n",
      "Número de variables 64\n",
      "Número de clases 10\n"
     ]
    }
   ],
   "source": [
    "print (\"Número de muestras\", x.shape[0])\n",
    "print (\"Número de variables\", x.shape[1])\n",
    "print (\"Número de clases\", len(np.unique(y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x576 with 55 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "real_data = x[:44].reshape((4, 11, -1))\n",
    "fig, ax = plt.subplots(5, 11, subplot_kw=dict(xticks=[], yticks=[]),figsize=(15,8))\n",
    "for j in range(11):\n",
    "    ax[4, j].set_visible(False)\n",
    "    for i in range(4):\n",
    "        im = ax[i, j].imshow(real_data[i, j].reshape((8, 8)),\n",
    "                             cmap=plt.cm.binary, interpolation='nearest')\n",
    "        im.set_clim(0, 16)\n",
    "ax[0, 5].set_title('Selection from the input data')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En un problema de clasificación de más de una clase, tener un desbalance de muestras puede ser perjudicial para el proceso de entrenamiento. Vamos a crear una función para verificar el numero de muestras por clases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ejercicio de código\n",
    "def muestras_por_clases (Y):\n",
    "    \"\"\"Funcion que calcula el numero de muestras por cada clase\n",
    "    Y: vector de numpy con las etiquetas de las muestras del conjunto X\n",
    "    retorna: diccionario [int/float:int/float] \n",
    "        con la estructura:{etiquetaclase1: numero de muestras clase1, etiquetaclase2: numero de muestras clase2}\n",
    "    \"\"\"\n",
    "    dicto = {}\n",
    "    ## Pista se puede asginar keys a diccionario: dict[etiqueta] = valor\n",
    "          \n",
    "\n",
    "    return (dicto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## la funcion que prueba tu implementacion\n",
    "GRADER.run_test(\"ejercicio1.1\", muestras_por_clases)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# con esta linea de codigo puedes ver la dsitribucion de forma grafica\n",
    "fig, ax = plt.subplots()\n",
    "ax.bar(muestras_por_clases(y).keys(), muestras_por_clases(y).values())\n",
    "ax.set_title(\"numero de muestras por clase\")\n",
    "ax.set_xlabel(\"etiqueta de clase\")\n",
    "ax.set_ylabel(\"# muestras por clase\")\n",
    "ax.set_xticks(list(muestras_por_clases(y).keys()))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 2: \n",
    "\n",
    "\n",
    "Los modelos que provaremos en este taller son:\n",
    "\n",
    "- Naïve Bayes\n",
    "- Discriminante Cuadrático\n",
    "- K-NN\n",
    "- Parzen Window\n",
    "\n",
    "De todos ellos el único que no tiene implementación como modelo de clasificación es el último, por lo tanto el objetivo de este punto es programar una clase en python que permita definir clasificadores basados en **Parzen Window**, debe contener un constructor para definir el ancho de la ventana, un método .fit y un método .predict que reciba una matriz de datos (muestras,variables) y retorne la clase asignada a cada muestra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ejercicio de código\n",
    "from sklearn.neighbors import KernelDensity\n",
    "\n",
    "class ParzenWindowClassifier():\n",
    "    \n",
    "    def __init__ (self, bandwidth):\n",
    "        self.bandwidth = bandwidth\n",
    "        \n",
    "        #Se sugiere tener una variable para almacenar el número de clases\n",
    "        self.num_clases = 0\n",
    "        #Se sugiere tener una lista para almacenar la ventanas de Parzen entrenadas para cada clase\n",
    "        self.kernelDensity = []\n",
    "    \n",
    "    def fit(self,X,Y):\n",
    "        \"\"\"Esta funcion es encargada entrenar el modelo, se deben entrenar las distribuciones kernel para cada clase.\n",
    "        \n",
    "            Se sugiere verificar que el conjunto de entrada tenga más de dos clases\n",
    "        \"\"\"\n",
    "        clases = np.unique(Y)\n",
    "        for i in range(clases):\n",
    "            \n",
    "            self.kernelDensity.append(...)\n",
    "        \n",
    "        return self\n",
    "        \n",
    "    def predict(self,X_val):\n",
    "        \"\"\"Esta funcion es encargada de realizar una predicción con base en las \n",
    "        muestras almacenadas y el ancho de banda definido, para cada una de las muestras en X_val.\n",
    "        \"\"\"\n",
    "                        \n",
    "        #Debe retornar un vector que contenga las predicciones para cada una de las muestras en X_val, \n",
    "        #en el mismo orden y la matriz con las probabilidades por clase\n",
    "        return class_est, prob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## la funcion que prueba tu implementacion\n",
    "GRADER.run_test(\"ejercicio1.2\", ParzenWindowClassifier)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 3:\n",
    "\n",
    "En este ejercicio vamos a hacer simulaciones con los diferentes modelos y a seleccionar los hiperparámetros con mejor desempeño. Carguemos los modelos a comparar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis\n",
    "from sklearn.neighbors import KNeighborsClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Dejamos algunas muestras para el proceso de entrenamiento y otras para evaluar qué tan bueno fue el aprendizaje del modelo\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "random.seed(1)\n",
    "Xtrain, Xtest, Ytrain, Ytest = train_test_split(x, y, test_size=0.3, random_state=1)\n",
    "\n",
    "\n",
    "#Normalizamos\n",
    "scaler = StandardScaler().fit(Xtrain)\n",
    "Xtrain = scaler.transform(Xtrain)\n",
    "Xtest = scaler.transform(Xtest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instanciamos y entrenamos los modelos para algunos hiperparámetros por defecto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = []\n",
    "clf.append(GaussianNB().fit(Xtrain,Ytrain))\n",
    "clf.append(QuadraticDiscriminantAnalysis().fit(Xtrain,Ytrain))\n",
    "clf.append(KNeighborsClassifier(n_neighbors=1).fit(Xtrain,Ytrain))\n",
    "clf.append(ParzenWindowClassifier(bandwidth=0.1).fit(Xtrain,Ytrain))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos cómo se comportan para algunas muestras de test. **Ejecute la celda varias veces para observar diferentes resultados**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "ind = np.random.permutation(Xtest.shape[0])[0]\n",
    "print('real class')\n",
    "print(Ytest[ind])\n",
    "\n",
    "for i in range(4):\n",
    "    if i==3:\n",
    "        _,preds = clf[i].predict(Xtest[ind,:].reshape(1,-1))\n",
    "    else:\n",
    "        preds = clf[i].predict_proba(Xtest[ind,:].reshape(1,-1))\n",
    "    y_pos = np.arange(len(np.unique(y)))\n",
    "    performance = preds.flatten()\n",
    "    plt.subplot(121)\n",
    "    plt.imshow(Xtest[ind,:].reshape(8,8), cmap='gray');\n",
    "    plt.subplot(122) \n",
    "    plt.barh(y_pos, performance, align='center', alpha=0.5)\n",
    "    plt.yticks(y_pos, np.unique(y))\n",
    "    plt.xlabel('Probability')\n",
    "    plt.title('Models outputs')\n",
    "    plt.subplots_adjust(wspace = 1)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluemos el desempeño en todo el conjunto de test para diferentes hiperparámetros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ejercicio de código\n",
    "from sklearn.metrics import accuracy_score\n",
    "k = range(1,16)\n",
    "h = np.linspace(0.001,10,15)\n",
    "acc_knn = []\n",
    "acc_pw = []\n",
    "for i in range(len(k)):\n",
    "    clf1 = KNeighborsClassifier(n_neighbors=k[i]).fit(Xtrain,Ytrain)\n",
    "    clf2 = ParzenWindowClassifier(bandwidth=h[i]).fit(Xtrain,Ytrain)\n",
    "    y_pred_knn = \n",
    "    y_pred_pw,_ = \n",
    "    acc_knn.append(accuracy_score(Ytest,y_pred_knn)) \n",
    "    acc_pw.append(accuracy_score(Ytest,y_pred_pw)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Grafiquemos el resultado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,5))\n",
    "plt.subplot(121)\n",
    "plt.plot(k,np.array(acc_knn))\n",
    "plt.title('Desempeño para el k-nn')\n",
    "plt.xlabel('Número de vecinos')\n",
    "plt.ylabel('Exactitud')\n",
    "plt.grid()\n",
    "plt.subplot(122)\n",
    "plt.plot(h,np.array(acc_pw))\n",
    "plt.title('Desempeño para el método kernel')\n",
    "plt.xlabel('Ancho de banda')\n",
    "plt.ylabel('Exactitud')\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'Mejore resultado para k-nn {np.max(np.array(acc_knn))}')\n",
    "print(f'Mejore resultado para PW {np.max(np.array(acc_pw))}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mida el desempeño para los Modelos Naïve Bayes y Discriminante Cuadrático:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ejercicio de código\n",
    "clf = GaussianNB().fit(Xtrain,Ytrain)\n",
    "y_pred_nb = clf.predict(Xtest)\n",
    "\n",
    "clf = QuadraticDiscriminantAnalysis().fit(Xtrain,Ytrain)\n",
    "y_pred_qd = clf.predict(Xtest)\n",
    "\n",
    "print(f'Mejore resultado para Naïve Bayes {accuracy_score(Ytest,y_pred_nb)}')\n",
    "print(f'Mejore resultado para Discriminante Cuadrático {accuracy_score(Ytest,y_pred_qd)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Pregunta Abierta\n",
    "#@markdown  ¿Cuáles tipos de modelos obtuvieron mejores resultados?\n",
    "respuesta_1 = \"\" #@param {type:\"string\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Pregunta Abierta\n",
    "#@markdown  ¿Cuál fue el modelo con peor desempeño? ¿Cuál cree que es la razón para dicho comportamiento?\n",
    "respuesta_2 = \"\" #@param {type:\"string\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Grafique la matriz de confusión normalizada del mejor modelo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ejercicio de código"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "GRADER.check_tests()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Integrantes\n",
    "codigo_integrante_1 ='' #@param {type:\"string\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "Esta linea es de uso exclusivo del los profesores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "GRADER.grade()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Taller - Parte 2\n",
    "\n",
    "**Regresión**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "GRADER, x, y = part_2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 2.1: Contextualización del problema\n",
    "\n",
    "Para el problema de regresion usaremos la base de datos 'The Boston Housing Dataset', cuya descripción [pueden encontrarla aqui](https://www.cs.toronto.edu/~delve/data/boston/bostonDetail.html). La información ya esta cargada dentro del notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"muestra de los 3 primeros renglones de x:\\n\", x[0:3, :])\n",
    "print(\"muestra de los 3 primeros renglones de y:\\n\", y[0:3])\n",
    "print (\"Número de muestras\", x.shape[0])\n",
    "print (\"Número de variables\", x.shape[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En los problemas de regresión, es muy util explorar la distribución de la variable objetivo. Nuestro primer ejercicio consiste en:\n",
    "1. visualizar un histograma de la variable y \n",
    "2. retornar los intervalo de datos mas frecuente.\n",
    "\n",
    "Pistas: \n",
    "1. explorar la documentación de [plt.hist](https://matplotlib.org/3.3.1/api/_as_gen/matplotlib.pyplot.hist.html). Maneje los valores por defecto. ¿como se puede usar la salida del histograma para retorna el intervalo de datos mas frecuente?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ejercicio de código\n",
    "def plot_hist_and_get_freq_int(Y):\n",
    "    \"\"\"función que grafica el histograma de la variable 'Y'\n",
    "        y retorna el intervalo donde ocurren con mas frecuencia los\n",
    "        valores de 'Y'\n",
    "        Y: numpy array con la variable a graficar\n",
    "        retorna: una tupla (int/float, int/float, int/float) \n",
    "            el primer elemento es el limite inferior del intervalo donde ocurren los valores\n",
    "            mas frecuentes\n",
    "            el segundo elemento es el limite superior del intervalo donde ocurren los valores\n",
    "            mas frecuentes\n",
    "            el tercer elemento es la frecuencia del intervalo anterior\n",
    "            va observar un cuarto elemento a retornar, el cual es usado para confirmar que\n",
    "            se realizo la grafica correctamente\n",
    "    \"\"\"\n",
    "    \n",
    "    plt.hist()\n",
    "    lim_inf = \n",
    "    lim_sup = \n",
    "    freqs = \n",
    "    \n",
    "    # el cuarto elemento debe dejarlo\n",
    "    return (lim_inf, lim_sup, freqs, plt.gcf())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## la funcion que prueba tu implementacion\n",
    "#ignora las graficas!!\n",
    "GRADER.run_test(\"ejercicio2.1\", plot_hist_and_get_freq_int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ver el histograma!\n",
    "plot_hist_and_get_freq_int(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Debemos nuevamente partir el conjunto de muestras en entrenamiento y test y normalizar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Xtrain, Xtest, Ytrain, Ytest = train_test_split(x, y, test_size=0.3, random_state=1)\n",
    "\n",
    "#Normalizamos\n",
    "scaler = StandardScaler().fit(Xtrain)\n",
    "Xtrain = scaler.transform(Xtrain)\n",
    "Xtest = scaler.transform(Xtest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 2.2: \n",
    "\n",
    "Los modelos que provaremos en este taller son:\n",
    "\n",
    "- Linearn regression\n",
    "- K-NN\n",
    "- Parzen Window (Nadaraya_Watson estimator)\n",
    "\n",
    "De todos ellos el único que no tiene implementación estándar en sklearn como modelo de regresión es el último, por lo tanto el objetivo de este punto es programar una clase en python que permita definir regresores basados en **Parzen Window**, debe contener un constructor para definir el ancho de la ventana, un método .fit y un método .predict que reciba una matriz de datos (muestras,variables) y retorne la predicción asignada a cada muestra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ejercicio de código\n",
    "from sklearn.metrics.pairwise import pairwise_kernels\n",
    "\n",
    "class ParzenWindowRegressor():\n",
    "    \n",
    "    def __init__ (self, bandwidth):\n",
    "        self.bandwidth = bandwidth\n",
    "\n",
    "        #Training Data\n",
    "        self.X = []\n",
    "        self.Y = []\n",
    "    \n",
    "    def fit(self,x,y):\n",
    "        \"\"\"Esta funcion es encargada entrenar el modelo que para el caso\n",
    "        de la venatan de Parzen consiste en almacenar las muestras de entrenamiento.\n",
    "        \"\"\"\n",
    "          \n",
    "        return self\n",
    "        \n",
    "    def predict(self,X_val):\n",
    "        \"\"\"Esta funcion es encargada de realizar una predicción con base en las \n",
    "        muestras almacenadas y el ancho de banda definido, para cada una de las muestras en X.\n",
    "        \n",
    "        Se sugiere usar el método pairwise_kernels y evitar las divisiones por 0 en el estimador Nadarata-Watson, \n",
    "        reemplazando el valor de predicción directamente por cero.\n",
    "        \"\"\"\n",
    "               \n",
    "\n",
    "        return y_est\n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## la funcion que prueba tu implementacion\n",
    "GRADER.run_test(\"ejercicio2.2\", ParzenWindowRegressor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Carguemos los modelos restantes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsRegressor\n",
    "from sklearn.linear_model import LinearRegression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluemos el desempeño en todo el conjunto de test para diferentes hiperparámetros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ejercicio de código\n",
    "from sklearn.metrics import mean_squared_error\n",
    "k = range(1,16)\n",
    "h = np.linspace(0.001,1,15)\n",
    "mse_knn = []\n",
    "mse_pw = []\n",
    "for i in range(len(k)):\n",
    "    clf1 = KNeighborsRegressor(n_neighbors=k[i]).fit(Xtrain,Ytrain)\n",
    "    clf2 = ParzenWindowRegressor(bandwidth=h[i]).fit(Xtrain,Ytrain)\n",
    "    y_pred_knn = \n",
    "    y_pred_pw = \n",
    "    mse_knn.append(mean_squared_error(Ytest,y_pred_knn)) \n",
    "    mse_pw.append(mean_squared_error(Ytest,y_pred_pw)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Grafiquemos el resultado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,5))\n",
    "plt.subplot(121)\n",
    "plt.plot(k,np.array(mse_knn))\n",
    "plt.title('Desempeño para el k-nn')\n",
    "plt.xlabel('Número de vecinos')\n",
    "plt.ylabel('MSE')\n",
    "plt.grid()\n",
    "plt.subplot(122)\n",
    "plt.plot(h,np.array(mse_pw))\n",
    "plt.title('Desempeño para el método kernel')\n",
    "plt.xlabel('Ancho de banda')\n",
    "plt.ylabel('MSE')\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'Mejore resultado para k-nn {np.min(np.array(mse_knn))}')\n",
    "print(f'Mejore resultado para PW {np.min(np.array(mse_pw))}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mida el desempeño de la regresión lineal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ejercicio de código\n",
    "clf = LinearRegression().fit(Xtrain,Ytrain)\n",
    "y_pred_lr = clf.predict(Xtest)\n",
    "\n",
    "print(f'Mejore resultado para LR {mean_squared_error(Ytest,y_pred_lr)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En términos de error absoluto medio, ¿cuál es el nivel de error del mejor modelo?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ejercicio de código\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Pregunta Abierta\n",
    "#@markdown  Con base en los resultados obtenidos, ¿cuál considera que es el problema de los modelos paramétricos evaluados? \n",
    "respuesta_3 = \"\" #@param {type:\"string\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "GRADER.check_tests()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Integrantes\n",
    "codigo_integrante_1 ='' #@param {type:\"string\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "Esta linea de codigo es de uso exclusivo del los profesores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "GRADER.grade()"
   ]
  }
 ],
 "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.6"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}