2.0. Clasificación/6. Clasificación (MIA UAI).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clasificación\n",
    "\n",
    "En esta clase vamos a aprender que es _clasificar_ en el área de _Machine Learning_ y las diferencias de esta tarea respecto a otros posibles escenarios. Además, vamos a aprender cómo medir el desempeño de un modelo clasificador. Los contenidos de esta clase son:\n",
    "\n",
    "- Posibles escenarios en el área de _Machine Learning_\n",
    "- Clasificación binaria\n",
    "- Medidas de desempeño\n",
    "- Clasificación multiclase"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Escenarios en el área de _Machine Learning_\n",
    "\n",
    "Hasta ahora hemos tenido una noción de cómo funcionan los modelos supervisados. Tenemos datos que corresponden a un determinado dominio y estos datos tienen una cantidad determinada de _features_. Podemos definir una _feature_ como una medida de una propiedad para una instancia. En general las _features_ son números en el dominio de los reales. Para explicar mejor este concepto vamos a retomar el ejemplo de la primera clase: un clasificador de números 7.\n",
    "\n",
    "Recordemos el _dataset_. Son números escritos a mano. Si lo vemos como imagen, los datos son los siguientes:\n",
    "\n",
    "<img src=\"fig/mnist.png\" style=\"width: 400px;\"/>\n",
    "\n",
    "Tenemos un conjunto de varios números escritos a mano, cada uno de $28\\times28$ pixeles. Si nos paramos en un número en particular, por ejemplo un 7, lo que tenemos es lo siguiente:\n",
    "\n",
    "<img src=\"fig/mnist7.png\" style=\"width: 200px;\"/>\n",
    "\n",
    "Si pensamos en términos de _features_, cada pixel es una feature con un valor asociado que representa un número en la escala de grises (0 es blanco, 1 es negro, los valores entre ellos son grises). \n",
    "\n",
    "Vamos a decir que cada uno de los números del dataset es una observación, y como en general no nos gusta trabajar con objetos de dos dimensiones, vamos a \"estirar\" cada uno de los números a una lista de 784 elementos (recordemos que $28\\times28=784$). Entonces, si vamos a entrenar con un dataset de 100 números, decimos que hay 100 observaciones, cada una con 784 features. Podemos pensar entonces en nuestro _dataset_ como una matrix $X$ de 100 filas y 784 columnas, donde las columnas son las features y las filas son las observaciones.\n",
    "\n",
    "Recordemos que cada observación viene etiquetada con su respuesta, en una lista $y$ de 100 elementos. Por ejemplo:\n",
    "\n",
    "- Si estamos clasificando una imagen como \"es un 7\" o \"no es un 7\", tenemos una lista de 100 elementos, que en la posición $i$ tiene el valor `True` si la $i$-ésima observación es un 7 y un `False` en caso contrario.\n",
    "- Si queremos clasificar una imagen como uno de los posibles 9 dígitos, entonces en la posición $i$ tenemos el número que representa dicha observación. Podemos pensar esto como 10 posibles etiquetas.\n",
    "\n",
    "Ahora bien, sabemos que existen otras tareas, como por ejemplo hacer una regresión. Esto es, predecir un valor numérico en vez de una clase. Ahora vamos a definir cada una de estas tareas en el área de _Machine Learning_.\n",
    "\n",
    "### Posibles escenarios\n",
    "\n",
    "Primero vamos a introducir un poco de notación. Consideremos que queremos aprender un dataset que contiene $n$ _features_. Decimos que a cada _feature_ le corresponde un dominio $\\mathcal{F}_i$. Entonces, todo posible _input_ de nuestro modelo pertenecerá al conjunto $\\mathcal{X} = \\mathcal{F}_1 \\times \\dots \\times \\mathcal{F}_n$ conocido como _Input Space_ (espacio de _input_). Así, podemos afirmar que todas nuestras observaciones pertenecen a $\\mathcal{X}$, y las instancias desconocidas que vamos a querer predecir, también. **Ojo**, es importante notar que cada fila de algún supuesto dataset $X$ pertenece a $\\mathcal{X}$.\n",
    "\n",
    "En el ejemplo anterior, todas las features tenían un dominio $\\mathcal{F}_i$ que correspondía al conjunto de los reales en el intervalo $[0,1]$, y nuestro _Input Space_ serían todas las listas de largo 784 en donde en cada posición había un número real entre 0 y 1. Nosotros además sabemos que nuestros _inputs_ los podemos representar como imágenes.\n",
    "\n",
    "Ahora bien, nuestro espacio de _output_ (_Output Space_) corresponde a las posibles respuestas que podemos obtener con nuestro modelo. Por ejemplo en clasificación, si en nuestro dataset tenemos la lista $y$ de etiquetas, llamaremos $\\mathcal{C}$ al conjunto de todas las etiquetas. Así, sabemos que la respuesta para una instancia desconocida para el modelo, es alguna de las etiquetas en $\\mathcal{C}$.\n",
    "\n",
    "Ahora, como esta notación puede ser un poco confusa, recapitulemos los conceptos:\n",
    "\n",
    "- Tenemos un dataset que es una matriz $X$. Cada fila es una observación y cada columna es una _feature_.\n",
    "- Tenemos la etiqueta para cada observación en una lista $y$. El número de filas de $X$ es igual al largo de $y$.\n",
    "- El conjunto de las posibles clases se llama $\\mathcal{C}$. En clasificación este es el _Ouput Space_, pero veremos que para otras tareas no lo es.\n",
    "- Cada instancia de nuestro problema (sea una observación o una instancia desconocida) viene de un _Input Space_ llamado $\\mathcal{X}$.\n",
    "\n",
    "Como ya tenemos la notación, ahora vamos por los posibles escenarios a los que nos enfrentaremos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La siguiente tabla resume los posibles escenarios (o tipos de problemas) que veremos a lo largo de este curso y corresponden a los problemas más típicos del área.\n",
    "\n",
    "| Tarea | _Output Space_ | Problema de aprendizaje |\n",
    "|---|---|---|\n",
    "| Clasificación | Una clase perteneciente a $\\mathcal{C}$ | Encontrar una función $\\hat{c}: \\mathcal{X} \\rightarrow \\mathcal{C}$ que para una instancia desconocida, nos prediga su clase. |\n",
    "| _Scoring_ | Un vector $\\mathbb{R}^{|\\mathcal{C}|}$, es decir, su dimensión es el número de clases | Aprender una función que para una instancia desconocida, nos entregue un puntaje para cada una de sus clases. | \n",
    "| Estimar probabilidad | Un vector $[0,1]^{\\mathcal{C}}$ en que la suma de sus elementos es 1 | Aprender una función que para una instancia desconocida, nos entregue una probabilidad asociada a cada clase |\n",
    "| Regresión | $\\mathbb{R}$ | Aprender una aproximación $f: \\mathcal{X} \\rightarrow \\mathbb{R}$ que para una instancia desconocida, nos prediga un número asociado.\n",
    "\n",
    "Ojo que para la Regresión, la etiqueta proviene de $\\mathbb{R}$ y no de $\\mathcal{C}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clasificación binaria\n",
    "\n",
    "En el problema de clasificación binaria, nuestro espacio de output son dos clases, generalmente conocidas como positiva ($\\oplus$) y negativa ($\\ominus$). Entonces, vamos a retormar el ejemplo de la clase introductoria. Vamos a hacer un programa que clasifique una imagen del _dataset_ mnist en \"es un 7\" (clase $\\oplus$) o en \"no es un 7\" (clase $\\ominus$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['data', 'target', 'frame', 'categories', 'feature_names', 'target_names', 'DESCR', 'details', 'url'])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.datasets import fetch_openml\n",
    "\n",
    "mnist = fetch_openml('mnist_784', version=1)\n",
    "mnist.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = mnist['data'], mnist['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SGDClassifier()"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "\n",
    "y = y.astype(np.uint8)\n",
    "X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]\n",
    "\n",
    "# Generamos arreglos que sean True en las posiciones donde hay un 7\n",
    "y_train_7 = (y_train == 7)\n",
    "y_test_7 = (y_test == 7)\n",
    "\n",
    "# Modelo que vamos a entrenar\n",
    "sgd_clf = SGDClassifier()\n",
    "sgd_clf.fit(X_train, y_train_7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí tenemos entrenado nuestro clasificador. Este está almacenado en la variable `sgd_clf`. Ahora bien, ¿qué tan bueno es nuestro clasificador? Usemos la técnica que aprendimos recientemente para medir el desempeño: cross-validation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.96795, 0.97155, 0.97555])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "cross_val_score(sgd_clf, X_train, y_train_7, cv=3, scoring='accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arriba estamos calculando cross-validation dividiendo el dataset en 3 partes. Cuando hicimos una regresión anteriormente, el valor era en base del error medio cuadrado. Ahora que estamos haciendo clasificación, esto no hace mucho sentido, por lo que lo que calculamos es el porcentaje de respuestas correctas. El valor es muy alto, ¡deberíamos estar felices!, pero ¿esta es realmente una buena medida para entender nuestro modelo? Vamos a discutir esto en la siguiente sección."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Medidas de desempeño\n",
    "\n",
    "Vamos a hacer un ejercicio bastante sencillo. Vamos a hacer un clasificador que siempre nos diga que **no estamos viendo un 7** y vamos a medir su desempeño."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.base import BaseEstimator\n",
    "\n",
    "class Never7Classifier(BaseEstimator):\n",
    "    def fit(self, X, y=None):\n",
    "        pass\n",
    "    def predict(self, X):\n",
    "        return np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo anterior estamos definiendo nuestro propio modelo, que contesta `False` siempre. Vemos además que es muy fácil hacer nuestros propios clasificadores. \n",
    "\n",
    "Ahora bien, antes de continuar, ¿puedes adivinar el desempeño que va a tener este clasificador?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.89535, 0.8984 , 0.893  ])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n7_clf = Never7Classifier()\n",
    "cross_val_score(n7_clf, X_train, y_train_7, cv=3, scoring='accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así es, cerca de 90% para un muy mal clasificador. Esto no nos sorprende, porque cerca del 10% de los elementos del dataset son un 7. Esto nos muestra por qué _Accuracy_ no es una buena medida de desempeño, especialmente cuando algunas clases aparecen poco: un clasificador que nunca prediga esas clases se debería comportar siempre relativamente bien. Por lo mismo, vamos a medir el desempeño de una mucho mejor forma: la matriz de confusión (_Confusion Matrix_).\n",
    "\n",
    "### Matriz de confusión\n",
    "\n",
    "En una matriz de confusión tenemos una fila que representa la clase que estamos analizando y una columna para cada clase predicha para las instancias de la fila. Veamos cómo se ve en nuestro ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import cross_val_predict\n",
    "\n",
    "# cross_val_predict nos retorna la clase predicha para cada instancia\n",
    "# en vez de agrupar todo en un puntaje\n",
    "y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_7, cv=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos ahora por la matriz de confusión."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[53110,   625],\n",
       "       [  700,  5565]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "confusion_matrix(y_train_7, y_train_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recordemos que la clase 0 significa \"no es 7\", y la clase 1 significa \"es un 7\". Así que la fila 0 nos dice que 53090 instancias que tenían la clase 0, fueron clasificadas como clase 0, mientras que 645 instancias de clase 0 fueron clasificadas como clase 1. Mientras tanto, la fila 1 nos dice que 752 instancias que eran de la clase 1 fueron clasificadas como clase 0 y 5513 instancias de clase 1 fueron clasificadas correctamente. Vamos ahora cómo se comporta nuestro clasificador que siempre responde falso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[53735,     0],\n",
       "       [ 6265,     0]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_pred = cross_val_predict(n7_clf, X_train, y_train_7, cv=3)\n",
    "confusion_matrix(y_train_7, y_train_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como es de esperar, acerto en todos las instancias que no son 7, y se equivocó en todas las que son 7. Así, un clasificador perfecto tiene números  solamente en la diagonal, y en todos los demás casilleros hay 0s. Gracias a la matriz de confusión, tenemos una medida objetiva de que este modelo es malo, a pesar de su buen _accuracy_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _Precision_ y _Recall_\n",
    "\n",
    "Si bien la matriz de confusión nos entrega varios valores (si tenemos más clases son muchas más filas y columnas!) a veces queremos algo más concreto. Dos medidas bastante famosas son _Precision_ y _Recall_. Vamos a presentarlas a continuación.\n",
    "\n",
    "\n",
    "$$\n",
    "\\text{precision} = \\frac{TP}{TP + FP}\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\text{recall} = \\frac{TP}{TP + FN}\n",
    "$$\n",
    "\n",
    "En donde $TP$ son los verdaderos positivos (_True Possitive_), $FP$ son los falsos positivos (_False Possitives_) y $FN$ los falsos negativos (_False Negatives_).\n",
    "\n",
    "¿Por qué necesitamos dos valores? La respuesta la podemos entender con el siguiente ejemplo: supón que tenemos un modelo que solamente clasifica un elemento de forma correcta, pero está muy seguro de lo que hace. Así, los falsos positivos serán 0 y la precisión será $1/1$, que equivale al 100%. Así podemos entender la precisión como **cuando digo que algo es de una clase, qué porcentaje de las veces estoy en lo correcto** y el _recall_ como **de los positivos que existen, cuantos estoy detectando**. Veamos esta medida en nuestro clasificador de 7s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.904883011190234"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import precision_score, recall_score\n",
    "\n",
    "y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_7, cv=3)\n",
    "precision_score(y_train_7, y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.851875498802873"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_7, y_train_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así, vemos que nuestro clasificador no está \"realmente seguro\" cuando dice que algo es un 7, mientras que sí detecta la mayoría de los 7. También existe otro puntaje en el que no vamos a hacer énfasis, pero es el $F_1$ _score_, que es la media armónica entre _Precision_ y _Recall_:\n",
    "\n",
    "$$\n",
    "F_1 = 2 \\times \\frac{\\text{precision} \\times \\text{recall}}{\\text{precision} + \\text{recall}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que es una medida que beneficia a modelos con precisión y _recall_ similares. Pero a veces queremos modelos que beneficien la precisión o el _recall_. Pensemos en los siguientes casos:\n",
    "\n",
    "- Queremos hacer un modelo que nos diga si ciertos medicamentos son seguros para la salud. Aquí nos interesa estar realmente seguros de si un medicamento es clasificado como seguro (positivo), a pesar de que podamos tener muchos falsos negativos. Aquí queremos altra precisión, a un costo de bajo _recall_.\n",
    "- Queremos hacer un modelo que recomiende canciones a alguien. Quizás no nos importa equivocarnos a cambio de que todas las posibles canciones que le gustan a la persona sean recomendadas. Aquí tendremos varios falsos positivos, por lo que habrá una baja precisión, pero tendremos un alto _recall_, porque el objetivo era tener pocos falsos negativos.\n",
    "\n",
    "Así, es el momento de discutir en profundidad el _trade-off_ entre precisión y _recall_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _Trade-off_ entre precisión y _recall_\n",
    "\n",
    "Primero, vamos a tomar una imagen de nuestro dataset, porque vamos a hacer una prueba con ella."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "0",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m~/.local/share/virtualenvs/eduardo-BbA8MaND/lib/python3.9/site-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m   3360\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3361\u001b[0;31m                 \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3362\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/share/virtualenvs/eduardo-BbA8MaND/lib/python3.9/site-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;32m~/.local/share/virtualenvs/eduardo-BbA8MaND/lib/python3.9/site-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;31mKeyError\u001b[0m: 0",
      "\nThe above exception was the direct cause of the following exception:\n",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/k_/5bn7s8bj3q50cjmfsm__qhlr0000gn/T/ipykernel_14205/4282172194.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpyplot\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0msome_digit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX_test\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0msome_digit_image\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msome_digit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m28\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m28\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/share/virtualenvs/eduardo-BbA8MaND/lib/python3.9/site-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m   3453\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnlevels\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3454\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3455\u001b[0;31m             \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3456\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3457\u001b[0m                 \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/share/virtualenvs/eduardo-BbA8MaND/lib/python3.9/site-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m   3361\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3362\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3363\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3364\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3365\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mis_scalar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0misna\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhasnans\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyError\u001b[0m: 0"
     ]
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "some_digit = X_test[0]\n",
    "some_digit_image = some_digit.reshape(28, 28)\n",
    "\n",
    "plt.imshow(some_digit_image, cmap='binary')\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tenemos una imagen que es un 7. Ahora vamos a entender cómo clasifica por debajo nuestro modelo `sgd_clf`. En realidad, lo que hacemos es tener una función de decisión que nos da un puntaje, y si el puntaje es mayor que 0, entonces se clasifica como positiva, y negativa en caso contrario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_scores = sgd_clf.decision_function([some_digit])\n",
    "y_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora vamos a ver cómo varía nuestra decisión a medida que cambiamos el treeshold, originalmente en 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ipywidgets as widgets\n",
    "from IPython.display import display\n",
    "\n",
    "# Para hacerlo más elegante, lo haremos con un widget\n",
    "threshold = widgets.IntSlider(min=0, max=10000)\n",
    "display(threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_some_digit_pred = (y_scores > threshold.value)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vemos, al superar el 6705, ahora estamos prediciendo que nuestra imagen no es un 7. Por ende, estamos reduciendo el _recall_ cuando aumentamos el threshold, ya que generamos falsos negativos. Ahora lo que haremos será generar una curva que nos muestra la precisión y el _recall_ a medida que variamos el threshold."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ahora retornamos nuestra función de decisión que asigna el puntaje\n",
    "y_scores = cross_val_predict(sgd_clf, X_train, y_train_7, cv=3, method='decision_function')\n",
    "\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "\n",
    "# Thresholds tiene un casillero menos que precisions y recalls\n",
    "precisions, recalls, thresholds = precision_recall_curve(y_train_7, y_scores)\n",
    "\n",
    "def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):\n",
    "    plt.plot(thresholds, precisions[:-1], 'b--', label='Precision')\n",
    "    plt.plot(thresholds, recalls[:-1], 'g-', label='Recall')\n",
    "    plt.legend(loc=\"center right\", fontsize=16) # Not shown in the book"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_precision_recall_vs_threshold(precisions, recalls, thresholds)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así podemos entender cómo cambia la evaluación a medida que cambia el threshold. Es un buen ejercicio entender cómo es esta curva para otros de los dígitos. ¿Se comportarán todos iguales?\n",
    "\n",
    "Además, esta curva nos permite saber cuál es el valor del threshold para obtener determinada precisión o _recall_. Por ejemplo, si queremos una precisión del 90%, nos gustaría tener el mínimo valor del threshold para lograr esto. Esto lo podemos hacer con la función `np.argmax`, a la que le pasamos una lista con una condición y nos entrega el primer índice que cumple esa condición."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.argmax(precisions >= 0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así, en la posición 48832, se comienza a cumplir el criterio, ahora vamos a buscar al arreglo de thresholds el valor en esta posición."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thresholds[np.argmax(precisions >= 0.9)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así, el threshold que buscamos es 1074. Ahora para predecir con precisión >= 90% podemos hacer lo siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "thresholds_90 = thresholds[np.argmax(precisions >= 0.9)]\n",
    "y_train_pred_90 = y_scores >= thresholds_90"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9000985869208018"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_score(y_train_7, y_train_pred_90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8743814844373503"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_7, y_train_pred_90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo que acabamos de hacer es muy importante: podemos ajustar nuestros modelos según nuestras necesidades. Distintos problemas requieren poner atención a ciertas partes por sobre otras. Ahora vamos a medir una última medida de desempeño, que es la curva ROC."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La curva ROC\n",
    "\n",
    "La curva ROC (por sus siglas en inglés, _receiver operating characteristic_) es una herramientra utilizada para medir el desempeño de clasificadores binarios. Esta curva grafica la tasa de verdaderos positivos (que vendría a ser el _recall_) en función de la tasa de falsos positivos ($FPR$ de _False Positive rate_). Esto vendría a ser:\n",
    "\n",
    "$$\n",
    "FPR = \\frac{FP}{TN + FP}\n",
    "$$\n",
    "\n",
    "Y recordemos que:\n",
    "\n",
    "$$\n",
    "\\text{recall} = TPR = \\frac{TP}{TP + FN}\n",
    "$$\n",
    "\n",
    "Donde $FP$ son los falsos positivos y $TN$ vendrían a ser los falsos negativos. Intuitivamente, si el _recall_ incrementa, el costo es tener más falsos positivos. Si lo pensamos de una nueva forma tenemos que:\n",
    "\n",
    "- La tasa de verdaderos positivos es el porcentaje de las instancias realmente positivas en las que yo digo (correctamente) que son positivas.\n",
    "- La tasa de falsos positivos es el porcentaje de las instancias realmente negativas en las que yo digo (incorrectamente) que son positivas.\n",
    "\n",
    "Vamos ahora a graficar la curva."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAELCAYAAAAybErdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAAsSElEQVR4nO3deXxU9b3/8dcnCQmLyO7CvktCQNQAIooiyOKG1IsXF6o2ShGt/qrW4oZKEUXBDVldcS9arfTKLe21tSoVEVEoi0AMhFUICGEJZJl8f3/MJMYESIDMnJmc9/PxyCNzlpn5HJb5zHf7HHPOISIiUlqc1wGIiEj0UXIQEZFylBxERKQcJQcRESlHyUFERMpJ8DqAqtC4cWPXunVrr8MQEYkpX3/99Q7nXJNDHasWyaF169YsXrzY6zBERGKKmWUd7pi6lUREpBwlBxERKUfJQUREylFyEBGRcpQcRESknIgmBzN72cy2m9nywxw3M3vOzDLMbJmZnRnJ+EREJCjSLYdXgUFHOD4Y6BD6GQlMj0BMIiJSRkTXOTjnPjWz1kc4ZQjwmgvWEV9oZvXN7FTn3NbIRCjRIFDkKAgUhX4c+/MKKXIO56DIOYocuNDv0vuLfwecIye3gPg4K3mNzbsPUDcpAUfwPMdPz3EAzuGCv3ClHxPcpmTbldof3C4qcmTu2E+z+rV+2ufKnO/Kvy8/iyH4e2vOQeIMTqxZo+TPo3RR/bIl9ssW3C99uPyxIzy3zMmuzI6fve7RnHuE+MoeLf+6pY9V3XWXfs7SjbtJPvXEQx6PdoV5B8jbt5v+PVL57UUdq/z1o20RXDNgY6ntTaF95ZKDmY0k2LqgZcuWEQnOj5xzBIochaGfQMCxL7+QgsIiCouK+CEnL/T7IAAFRY6sHftJTIijsMixdONumtWvRUGRI1BURGHAkZG9j9qJ8STGx1EQcKzauoc6SQkkxBk79+d7fMXiN4vW/+h1CEftQNZSfvzrFOKS6tB60jtheY9oSw6V5pybBcwCSEtL0x2LDuNAfoADBQHyC4vYl1fIxl257DlQQGHAsXFXLobxn805JMQZH3+3jRYNawe/bRc6tu89SFGE/mRzDhT8bDs+zqhVI56EeGN3bgGJ8XGcWr8mcWaYQZwZcQZGqe04QseNPQcKMINWDWtTIz6OGvFxfJ+9jy7N6mGh58XFAaHnG5Ts/2nb4JD7g8cs+HQMozBQxO4DBbRsWDsYV+i5xfEWPy+u5DWDzy8+t/Rr5hwooEHtRJISfur1DT2t3OPQFfx8u8zxnx8rc+4Rnnek1y37FuXf0w577Ofvefh4yr1nBfFxxPgO/T4OKAwUcUJSbHwU7t2Tw5THHmLunDdo3qoN9z32FBf1Oy0s7xVtfyKbgRaltpuH9kmIc45te/LIKwxQEChiV24B2/fkkZtfSG5+gK05B1myYReL1h3bt6HM7P3l9plBjfg4EuKMhDgjNz9AYZGjbZM6FAYceYUBujSrz5bdB+javB61ExPYuT+PjifXpXZiPPvzCmnRsDbxcUZCXPB1CgJFNKmbRGJCXOjD26hXK5GaNeKok5hAXNwRPuFEfCgQCNCly3msXr2ae+65h4cffphatWqF7f2iLTnMBW4zs3eAnkCOX8Ybftyfz4otOWRs38e+g4V8t20v67L344D9eYVs+DGXujUT2Huw8Jhev0ndJBLj42hSN4nc/EJaNqxDk7qJ/Lg/n+RTT6TIQadT6lK/dg2a1a9V8m27bs0EataIr9qLFZFK27lzJw0bNiQ+Pp5HH32UFi1akJaWFvb3jWhyMLO3gQuAxma2CXgIqAHgnJsBzAMuBjKAXODGSMYXCRt/zGXRuh/57oc9bNl9kP9btQ2AvMKiCp9bnBhqJ8bT6IREasTHkRgfx7Y9B2lavxadTjmRU+ol0eSEJGrWiKdz03p0bnqivoWLxCDnHG+++SZ33HEHjz/+ODfffDNDhw6N2PtHerbS1RUcd8CtEQon7HLzC/k6axefrd3Bzn35LMzcyebdB474nJYNa9OuSR36dGzCCUkJtG1ShxNr1qBGfBz1a9egdmICiQlauyhSnW3cuJFRo0Yxb948zj77bHr37h3xGKKtWynmbd97kJc/X8/32fv4dE12uRZBUkIcnZueSMBByqknclarBrRuVJvUZvXUfSMivP322/z6178mEAjwzDPPcNtttxEfH/nPBiWHKrBl9wH++NVG/rRkE5t2/bxl0KJhLdo3OYGE+Dh+1bsNZ7SsryQgIofVoEEDevbsyaxZs2jTpo1ncdjhFojEkrS0NOfFzX5ycgt45C8reP+b8hOqzm7bkIcu6xyzC2xEJDIKCwt5+umnyc/P5/777weC4w1lp9+Gg5l97Zw75Oi2Wg7H6LO12dz+9jfsyg3Oz+/SrB4tGtZi1Pnt6Nq8vrfBiUhMWLp0Kenp6Xz99ddcddVVJUkhEomhIkoOR8E5x7tfb+L1L7L4z+YcADqcdALTrzuT9ifV9Tg6EYkVeXl5jB8/nscff5yGDRvy7rvvcuWVV0ZFUiim5FBJn67J5ra3lrCn1DqDC05rwgu/TKNGvGYPiUjlrV27lokTJ3LNNdfw1FNP0ahRI69DKkfJoRKe+ttqnvtHRsn2kG5NGTO4E6fWC9/qRBGpXvbt28eHH37ItddeS2pqKt999x1t27b1OqzDUnKowPj/WcmLn68DoFuL+kwa1lVdSCJyVP7+978zcuRIsrKyOPPMM0lOTo7qxAC6E9wRfbRsa0liGNmnLX++tbcSg4hU2q5du0hPT2fAgAEkJibyr3/9i+TkZK/DqhS1HA5jw85c7njnGwCGd2/BfRfHxl+oiESHQCBA7969WbNmDffeey9jx46lZs2aXodVaUoOh/G795ZSWOTo1bYRj/2ii9fhiEiM2LFjR0mhvAkTJtCyZUvOPDP27nisbqVD+DJzJ1+GSl4/OaxrVE0vE5Ho5Jzjtddeo2PHjrz44osAXHHFFTGZGEDJoZyDBQHu+dMyAK7t2ZLmDWp7HJGIRLusrCwGDx7M9ddfT3JyMn369PE6pOOm5FDGO4s2kLUzl1aNanPPoE5ehyMiUe6NN94gNTWVzz//nClTpvDZZ5/RqVPsf3ZozKGU/MIipv/rewDu6NeBerVqVPAMEfG7Jk2a0Lt3b2bOnEmrVq28DqfKKDmU8nXWLrbtyaNZ/Vpc2rWp1+GISBQqKChg8uTJFBQU8OCDDzJw4EAGDBhQ7cYm1a1UytylWwC4KOVk3VBHRMr55ptv6NmzJ/feey8rV66kuKp1dUsMoOTwMwsydgAwKPUUjyMRkWhy8OBB7rvvPrp3786WLVv405/+xNtvv10tk0IxJYeQzOx9bPgxl7pJCZzVqoHX4YhIFMnIyGDSpEn88pe/ZNWqVfziF7/wOqSw05hDyHc/7AWgR5uGqrIqIuzbt48PPviAESNGkJqayurVqz29M1uk6VMwZHUoObQ/6QSPIxERr82fP5/OnTtz/fXXs2rVKgBfJQZQcijxddYuAFKa6raeIn61c+dOrr/+egYNGkTt2rX57LPPYqZQXlVTtxIQKHJ8HhqM7t2+scfRiIgXigvlZWRkcP/99/PAAw/EVKG8qqbkQHAwGuCEpAQan5DkcTQiEknZ2dk0atSI+Ph4Jk6cSKtWrejWrZvXYXlO3UrA+p25ANRJivc4EhGJFOccr7zyCh07duSFF14AYMiQIUoMIUoOwLY9BwE4sabKZYj4wfr16xk4cCC/+tWv6NKlC3379vU6pKij5ABs+DHYcmjVqI7HkYhIuL3++uukpqbyxRdfMG3aND755BM6duzodVhRR2MOBAvuATSorZaDSHV38skn06dPH2bMmEHLli29DidqKTkAK7fuASC1WT2PIxGRqlZQUMATTzxBIBBg7NixDBgwgAEDBngdVtRTtxKwZfcBAE6spVwpUp0sWbKE7t2788ADD7B69eqSQnlSMSUHYNOuYHJo2VBjDiLVwYEDBxgzZgw9evRg27ZtfPDBB7z55pvVulBeVYt4cjCzQWa22swyzGzMIY63NLN/mtk3ZrbMzC4Od0yN6iQCcGo9/y54EalOMjMzeeqpp7jhhhtYuXIlV1xxhdchxZyIJgcziwemAoOBFOBqM0spc9oDwBzn3BnAcGBaOGMKFDl25eYDaAGcSAzbs2cPr776KgCdO3dm7dq1vPjiizRooCrLxyLSLYceQIZzLtM5lw+8Awwpc44Digsc1QO2hDOgXbn5FDk4sWaCbvAjEqPmzZtHamoq6enpJYXyqtMtO70Q6U/DZsDGUtubQvtKexi4zsw2AfOA3xzqhcxspJktNrPF2dnZxxzQjn15ADSpq1aDSKzZsWMHI0aM4JJLLqFu3bosWLDAt4Xyqlo0flW+GnjVOdccuBh43czKxemcm+WcS3POpTVp0uSY32zvwUIA6tdOPObXEJHIKy6U98477zB27FiWLFnC2Wef7XVY1Uak525uBlqU2m4e2ldaOjAIwDn3hZnVBBoD28MR0IH8AAA1a0RjnhSRsrZt20aTJk2Ij49n0qRJtGrViq5du3odVrUT6U/Er4AOZtbGzBIJDjjPLXPOBqAfgJklAzWBY+83qsAPobpKNRNUdE8kmjnneOmllzjttNOYNWsWAJdddpkSQ5hENDk45wqB24D5wCqCs5JWmNk4M7s8dNpdwM1mthR4G7jBhXHlSlJoELq4vpKIRJ/MzEz69+/PTTfdRLdu3ejfv7/XIVV7EV8S7JybR3CgufS+saUerwR6Ryqe4rpKXZvXj9RbishRmD17NqNHjyY+Pp4ZM2Zw8803ExenbuBw8329iNzQmIOmsYpEp6ZNm3LhhRcyffp0mjdv7nU4vuH75LA5VFdJq+pFokN+fj6PP/44RUVFPPzww1x00UVcdNFFXoflO77/ulw3KZgfD4ZaECLina+++oqzzjqLhx56iMzMTBXK85Dvk0NuQTAptDvpBI8jEfGv3Nxc7r77bs4++2x27drF3Llzee2111Qoz0NKDnnBRXC1amgqq4hX1q1bx5QpU7j55ptZsWIFl112mdch+Z7vxxzyA8HZSklaBCcSUTk5Obz//vvceOONdO7cmYyMDFq0aFHxEyUifP+JmBeaypoY7/s/CpGI+eijj+jcuTM33XQT3333HYASQ5Tx/Sdi8TqHJHUriYRddnY21157LZdeeikNGjTgiy++oFOnTl6HJYfg+26lgwWh5KB1DiJhFQgEOPfcc1m3bh2PPPIIY8aMITFRBS+jle+TQ15hceE9tRxEwuGHH37gpJNOIj4+nsmTJ9O6dWtSU1O9Dksq4Puvy3tCJbs15iBStYqKipg5cyYdO3Zk5syZAFx66aVKDDHC95+I32/fB0BCvOZTi1SVjIwM+vXrx6hRo+jevTsDBw70OiQ5Sr5PDs0b1AJUslukqrzyyit06dKFJUuW8MILL/B///d/tG3b1uuw5Cj5fsyheLZSrUQlB5Gq0LJlSwYOHMjUqVNp1qzsXYAlVvg+OWTu2A9otpLIscrLy+Oxxx6jqKiIcePG0a9fP/r16+d1WHKcfP+JWCM01lBDA9IiR+3LL7/krLPO4pFHHmHDhg0qlFeN+P4TsU6oKqtaDiKVt3//fu6880569epFTk4O//M//8Orr76qQnnViO8/EQOB4DedeM1WEqm0rKwspk2bxqhRo1ixYgWXXHKJ1yFJFfP9mENhUTA51NBtB0WOaPfu3bz33nvcdNNNpKSkkJGRoTuzVWO+/0QMhJJDfJxaDiKH8+GHH5KSksKoUaNKCuUpMVRvvk8OhUXBqawJSg4i5Wzfvp3hw4dzxRVX0KRJExYuXKhCeT7h626loiJHkQvePzpOyUHkZwKBAL1792bDhg2MHz+ee+65hxo1angdlkSIr5OD7uUgUt6WLVs45ZRTiI+P59lnn6V169akpKR4HZZEmK8/FYvvAqfkIBIslDd9+nQ6derEjBkzALj44ouVGHzK15+KhaHkoKJ74ndr1qyhb9++jB49mp49ezJ48GCvQxKP+Ts5hGYqJajlID720ksvcfrpp7Ns2TJefvll/va3v9GmTRuvwxKP+XrMoSDUcqihwWjxsdatWzN48GCmTp3Kqaee6nU4EiV8nRyKbxEq4id5eXn84Q9/AGD8+PEqlCeH5PP+lGC30pacgx7HIRIZ//73v+nWrRuPPvooW7duVaE8OSxfJ4eCUF2l006u63EkIuG1b98+7rjjDs4991xyc3P561//yksvvaRCeXJYEU8OZjbIzFabWYaZjTnMOVeZ2UozW2Fmb4UrFpXOEL/YsGEDM2fO5NZbb2X58uW6badUKKJjDmYWD0wFLgI2AV+Z2Vzn3MpS53QA7gV6O+d2mdlJ4YqnpOieprJKNbRr1y7effddRo4cSUpKCpmZmTRt2tTrsCRGRLrl0APIcM5lOufygXeAIWXOuRmY6pzbBeCc2x6uYIrXOajlINXNBx98QEpKCqNHj2b16tUASgxyVCKdHJoBG0ttbwrtK60j0NHMFpjZQjMbdKgXMrORZrbYzBZnZ2cfUzB7DxYCkKBy3VJN/PDDDwwbNoxf/OIXnHLKKSxatIjTTjvN67AkBkXjVNYEoANwAdAc+NTMujjndpc+yTk3C5gFkJaWdkxTLopXRq/etvfYoxWJEoFAgPPOO4+NGzcyYcIE7r77bhXKk2MW6eSwGWhRart5aF9pm4AvnXMFwDozW0MwWXxV1cEUz+Lr0qxeVb+0SMRs2rSJpk2bEh8fz3PPPUebNm1UVluOW6T7U74COphZGzNLBIYDc8uc82eCrQbMrDHBbqbMcAQTCGUHleuWWFRUVMSUKVPo1KkT06dPB2Dw4MFKDFIlIpocnHOFwG3AfGAVMMc5t8LMxpnZ5aHT5gM7zWwl8E/gd865neGIp6h4Kqtyg8SY7777jj59+nD77bdz7rnncumll3odklQzER9zcM7NA+aV2Te21GMH3Bn6CatQbtBsJYkpL774Irfddhu1a9dm9uzZjBgxQovZpMpVSXIwsyTnXF5VvFYkFS+C038siSXt2rXjsssu4/nnn+fkk0/2Ohyppo4rOZhZTeAW4G7KT0mNesV1ZeKVHCSKHTx4kHHjxgEwYcIE+vbtS9++fT2OSqq7I445mFlLM7vHzJ43s/9nZvVC+xPN7C5gPTA59Dvm/DQg7XEgIoexYMECunXrxmOPPUZ2drYK5UnEHLblYGa9gY+AE0vt/nVo4Ph9oDOwBPhVaBwh5hR3K8Wp5SBRZu/evdx3331MnTqVVq1aMX/+fAYMGOB1WOIjR/rO/BCwEzgXqE0wGWwD/g20BW50zqXFamKAn9Y5aEBaos2mTZt48cUX+c1vfsN//vMfJQaJuCONOXQHbnfO/Tu0vcrMRgPLgTucc7PDHl2YbdsTvI+DUoNEg507dzJnzhxuueUWkpOTyczM1J3ZxDNHajnUA9aW2Ve8vSg84URWgzqJAKzbsd/jSMTPnHO89957pKSkcPvtt5cUylNiEC9VNBQbKLNdfF/N/DDEEnmhbqWOutmPeGTr1q1ceeWVDBs2jBYtWrB48WIVypOoUNFU1kfMbEep7eIemD+Y2Y+l9jvn3PVVG1r4FTkNSIt3igvlbd68mSeeeILf/va3JCREYy1M8aMj/UvcACQfYn8WwcHp0mJyfl3xCmlNZZVI2rhxI82aNSM+Pp6pU6fSpk0bOnbs6HVYIj9z2I9F51xr51ybSv60jWTQVaWoZM64Wg4SfoFAgOeee+5nhfIGDhyoxCBRyddt2OLUoJmsEm6rVq0iPT2dL774gsGDB3PZZZd5HZLIEVW0QvoGM/vWzPaZ2SYzmxwqtV0tOI05SATMmjWLbt26sWbNGl5//XU++ugjWrZs6XVYIkd02ORgZtcALxNcAPcRsAX4f8CEiEQWAUUlK6Q9DkSqtQ4dOjB06FBWrlzJddddp0KPEhOO1K10B/ABcJVzLgBgZg8BY8zs98X7YlnxgLT+s0pVOnDgAA8//DBmxuOPP65CeRKTjtSt1BF4oUwSmAYkAdWiTVwyHK3cIFXk008/5fTTT+eJJ54gJydHhfIkZlW0QvrHMvuKtxuEJ5zI0piDVJU9e/YwevRozj//fAKBAB9//DHTp09Xq1RiVkUz/OPMrOQHiD/U/tCxmFM8lVX/feV4bdmyhVdffZU777yTZcuWceGFF3odkshxqWgq64LD7P+yzLarxGtFHVeyCE7pQY7ejh07mDNnDqNHj6ZTp06sW7dOd2aTauNIH+jjiNGVz5X104C0t3FIbHHOMWfOHH7zm9+we/du+vfvT8eOHZUYpFo5bHJwzj0cwTg8odpKcrS2bNnCLbfcwty5c0lLS+Pjjz/WCmeplo50J7hMYKhzbmkE44moDTtzAY05SOUEAgH69OnD5s2bmTRpEnfccYcK5Um1daR/2a0JTluttprWrwXAhh9zPY5EollWVhbNmzcnPj6eadOm0bZtW9q3b+91WCJhFZOzjKqKCw2ptG1cx+NIJBoFAgGeeuopkpOTSwrlDRgwQIlBfKGiNnG1HpB2WgUnh7F8+XLS09NZtGgRl156KVdccYXXIYlE1NHe7OdwYvJmPyrYLYcyY8YMbr/9durVq8dbb73F8OHDtZhNfKei5NANyKvE68RmC6N4EZz+3wvBKapmRnJyMsOGDeOZZ56hSZMmXocl4omKksMVzrlFEYnEAz+1HJQd/Cw3N5exY8cSHx/PxIkTOf/88zn//PO9DkvEU/4ekNYiON/75JNP6Nq1K5MnT2bfvn0qlCcS4u/kgGor+VVOTg6//vWvS0pp/+Mf/2Dq1KkaWxAJ8XdyUG0l39q6dStvvPEGd999N8uWLdP9FkTKOGxycM7FhWO8wcwGmdlqM8swszFHOO9KM3NmllbVMRQrUg+Cr2RnZzNlyhQAOnXqxPr163nyySepXbu2x5GJRJ+IthzMLB6YCgwGUoCrzSzlEOfVJXgnurLVX6tUSbeSGg7VmnOOt956i+TkZO666y7WrFkDoJlIIkcQ6W6lHkCGcy7TOZcPvAMMOcR5fwAmAgfDGk3xgLRGHaqtjRs3ctlll3HttdfSvn17vvnmGxXKE6mESCeHZsDGUtubQvtKmNmZQAvn3EdHeiEzG2lmi81scXZ29jEFowXS1VthYSEXXHAB//znP3n66adZsGABnTt39joskZgQVSUlQ3eUewq4oaJznXOzgFkAaWlpxzR64HQnuGpp/fr1tGjRgoSEBGbOnEnbtm1p27at12GJxJRItxw2Ay1KbTcP7StWF0gFPjGz9cDZwNxwDUprnUP1UlhYyKRJk0hOTmbatGkA9O/fX4lB5BhEuuXwFdDBzNoQTArDgWuKDzrncoDGxdtm9glwt3NucTiC0Qrp6mPZsmWkp6ezePFihgwZwpVXXul1SCIxLaItB+dcIXAbMB9YBcxxzq0ws3FmdnkkYwnGE/ytlkNsmzZtGmeddRZZWVn88Y9/5IMPPqBp06ZehyUS0yI+5uCcmwfMK7Nv7GHOvSCcsRSVFN5TdohFxYXyUlNTGT58OE8//TSNGzeu+IkiUqGoGpD2ilJDbNm/fz8PPPAACQkJPPnkk/Tp04c+ffp4HZZIteLz8hlaBBdrPv74Y7p06cIzzzxDXl6eCuWJhIm/k0Pot3JD9Nu9ezc33XQT/fv3JyEhgU8//ZTnnntOXYIiYeLv5FAyIK0PmGi3bds23nnnHX7/+9+zdOlSzjvvPK9DEqnWfD3moNpK0a04Idxxxx2cdtpprF+/XgPOIhGilgPqVoo2zjneeOMNUlJSuOeee1i7di2AEoNIBPk6Oazdvi/4QE2HqLFhwwYuueQSRowYwWmnnca3335Lhw4dvA5LxHd8nRzaNakDQPbePI8jEfipUF7xYPNnn31GcnKy12GJ+JKvxxyKnXJiTa9D8LXMzExatWpFQkICL7zwAu3ataN169ZehyXia75uOWiKvLcKCwuZOHEiKSkpTJ06FYB+/fopMYhEAbUc0JCDF7799lvS09NZsmQJQ4cOZdiwYV6HJCKlqOUgEff888/TvXt3Nm/ezHvvvcf777/Pqaee6nVYIlKKr5NDMTUcIqO41EXXrl259tprWblypUpri0QpdStJ2O3bt4/777+fGjVqMGnSJBXKE4kBvm45ONSvFG5/+9vfSE1NZcqUKRQUFKhQnkiM8HVyKKYB6aq3a9cubrzxRgYOHEjNmjX59NNPefbZZ1XHSiRG+Do56Ets+Gzfvp333nuPe++9l2+//ZZzzz3X65BE5ChozAHdQ7qq/PDDD7z99tv89re/LSmU16hRI6/DEpFj4O+Wg9cBVBPOOWbPnk1KSgr33ntvSaE8JQaR2OXr5FBCDYdjtn79egYNGsQNN9xASkqKCuWJVBPqVpJjVlhYSN++fdmxYwdTp05l1KhRxMXp+4ZIdeDr5KAB6WOTkZFBmzZtSEhI4OWXX6Zt27a0atXK67BEpArpax7qVaqsgoICJkyYQOfOnUsK5fXt21eJQaQa8nfLQUPSlbZkyRLS09P59ttvGTZsGP/93//tdUgiEkZqOYAWZlXgueeeo0ePHvzwww+8//77zJkzh5NPPtnrsEQkjJQc5LCKS12cccYZ/PKXv2TlypUMHTrU46hEJBJ83a2kXqVD27t3L/feey9JSUlMnjyZ8847j/POO8/rsEQkgtRyQAPSpf31r38lNTWVadOm4ZxToTwRn/J1ctDH3k927tzJ9ddfz+DBg6lTpw4LFizgqaee0niMiE/5OjkU0+dfMDl88MEHPPjgg3zzzTf06tXL65BExEMRTw5mNsjMVptZhpmNOcTxO81spZktM7OPzSxsk+j93mWydetWJk2ahHOOjh07kpWVxbhx40hKSvI6NBHxWESTg5nFA1OBwUAKcLWZpZQ57RsgzTnXFXgPeCL8cYX7HaKLc46XX36Z5ORkHnzwQTIyMgBo0KCBx5GJSLSIdMuhB5DhnMt0zuUD7wBDSp/gnPuncy43tLkQaB7hGKu1devWMWDAANLT0zn99NNZunSpCuWJSDmRnsraDNhYansT0PMI56cD/3uoA2Y2EhgJ0LJly2MKxm+dSoWFhVx44YXs3LmT6dOnM3LkSBXKE5FDitp1DmZ2HZAGnH+o4865WcAsgLS0tOP6nK/uN/tZu3Ytbdu2JSEhgVdeeYV27drRokULr8MSkSgW6a+Nm4HSn0rNQ/t+xsz6A/cDlzvn8sIVTHUfjy4oKGD8+PGkpqby/PPPA3DBBRcoMYhIhSLdcvgK6GBmbQgmheHANaVPMLMzgJnAIOfc9kgEVR0HpBcvXkx6ejrLli1j+PDhXH311V6HJCIxJKItB+dcIXAbMB9YBcxxzq0ws3FmdnnotCeBE4B3zexbM5sbyRirg2effZaePXuyY8cOPvzwQ95++21OOukkr8MSkRgS8TEH59w8YF6ZfWNLPe4fsVgi9UYR4pzDzEhLSyM9PZ0nnniC+vXrex2WiMSgqB2Qlsrbs2cPv//976lZsyZPP/00vXv3pnfv3l6HJSIxzNfzGKvDCul58+bRuXNnZs2aRUJCQrW4JhHxnq+TQ7FYLC63Y8cOrrvuOi655BLq1avHv//9b5588smYvBYRiT6+Tg6x/B17165d/OUvf+Ghhx5iyZIl9Ox5pLWEIiJHR2MOxM79HDZv3sybb77J7373Ozp06EBWVpYGnEUkLHzdcogVzjleeOEFUlJSePjhh/n+++8BlBhEJGz8nRxioF/p+++/p1+/fowcOZIzzzyTZcuW0b59e6/DEpFqTt1KRO8K6cLCQvr168ePP/7IzJkzuemmm1QoT0QiwtfJwUVp02H16tW0a9eOhIQEZs+eTbt27WjeXJXLRSRy9DWU6KnKmp+fzyOPPEKXLl2YOnUqAOeff74Sg4hEnK9bDtFk0aJFpKens3z5cq655hquvfZar0MSER/zdcshWhYTP/PMM/Tq1atk7cKbb75J48aNvQ5LRHzM18mhmFcD0sWlLnr06MHNN9/MihUruPTSS70JRkSkFF93K3nVcsjJyeGee+6hVq1aPPPMM5xzzjmcc8453gQjInIIajkQ2RXSf/nLX0hJSeHFF18kKSlJhfJEJCr5OjlEciprdnY211xzDZdffjmNGjVi4cKFTJw4UYXyRCQq+To5FIvE53NOTg7z5s3jkUceYfHixXTv3j38byoicox8PeYQbhs3buSNN95gzJgxtG/fnqysLOrVq+d1WCIiFfJ1yyFc3f1FRUXMmDGDzp07M378+JJCeUoMIhIrfJ0cflJ1/Upr167lwgsv5JZbbqFHjx785z//UaE8EYk5vu5WquqGQ2FhIRdddBG7d+/mpZde4sYbb9SAs4jEJF8nh2LH+/m9atUqOnToQEJCAq+//jrt2rWjadOmVROciIgHfN2tdLxjDnl5eTz00EN07dqV559/HoDzzjtPiUFEYp5aDhzbiMPChQtJT09n5cqVjBgxghEjRlR5XCIiXvF1y+FYTZ48mXPOOYe9e/cyb948XnvtNRo1auR1WCIiVcbnyeHo+pWKiooA6NWrF6NGjWL58uUMHjw4HIGJiHhK3UpQ4Yyi3bt3c9ddd1G7dm2mTJmiQnkiUu35uuVQmQHpP//5z6SkpDB79mzq1q2rQnki4gu+Tg7FDtVu2L59O1dddRVDhw7l5JNPZtGiRUyYMEHrFkTEF5QcDmPPnj38/e9/59FHH2XRokWceeaZXockIhIxvh5zKNtBtGHDBl5//XXuu+8+2rdvz4YNG6hbt64nsYmIeCniLQczG2Rmq80sw8zGHOJ4kpn9MXT8SzNrHe6YnCti2rRpdO7cmQkTJpQUylNiEBG/imhyMLN4YCowGEgBrjazlDKnpQO7nHPtgaeBieGKxzlHwc5N3HX9L7j11lvp1asXK1asUKE8EfG9SLccegAZzrlM51w+8A4wpMw5Q4DZocfvAf0sTKPARYFCts0Zy7q1q3jllVeYP38+rVu3DsdbiYjElEgnh2bAxlLbm0L7DnmOc64QyAHKLT82s5FmttjMFmdnZx9TMPXq1KLdsDG8Nu9zbrjhBs1EEhEJidkBaefcLGAWQFpa2jEtPnju6jPg6jOqNC4Rkeog0i2HzUCLUtvNQ/sOeY6ZJQD1gJ0RiU5ERIDIJ4evgA5m1sbMEoHhwNwy58wFrg89/i/gH07LkkVEIiqi3UrOuUIzuw2YD8QDLzvnVpjZOGCxc24u8BLwupllAD8STCAiIhJBER9zcM7NA+aV2Te21OODwLBIxyUiIj9R+QwRESlHyUFERMpRchARkXKUHEREpByrDrNEzSwbyDrGpzcGdlRhOLFA1+wPumZ/OJ5rbuWca3KoA9UiORwPM1vsnEvzOo5I0jX7g67ZH8J1zepWEhGRcpQcRESkHCWHUPE+n9E1+4Ou2R/Ccs2+H3MQEZHy1HIQEZFylBxERKQc3yQHMxtkZqvNLMPMxhzieJKZ/TF0/Esza+1BmFWqEtd8p5mtNLNlZvaxmbXyIs6qVNE1lzrvSjNzZhbz0x4rc81mdlXo73qFmb0V6RirWiX+bbc0s3+a2Tehf98XexFnVTGzl81su5ktP8xxM7PnQn8ey8zszON+U+dctf8hWB78e6AtkAgsBVLKnDMamBF6PBz4o9dxR+Ca+wK1Q49v8cM1h86rC3wKLATSvI47An/PHYBvgAah7ZO8jjsC1zwLuCX0OAVY73Xcx3nNfYAzgeWHOX4x8L+AAWcDXx7ve/ql5dADyHDOZTrn8oF3gCFlzhkCzA49fg/oZ7F9U+kKr9k590/nXG5ocyHBO/PFssr8PQP8AZgIHIxkcGFSmWu+GZjqnNsF4JzbHuEYq1plrtkBJ4Ye1wO2RDC+Kuec+5Tg/W0OZwjwmgtaCNQ3s1OP5z39khyaARtLbW8K7TvkOc65QiAHaBSR6MKjMtdcWjrBbx6xrMJrDjW3WzjnPopkYGFUmb/njkBHM1tgZgvNbFDEoguPylzzw8B1ZraJ4P1jfhOZ0DxztP/fKxTxm/1I9DGz64A04HyvYwknM4sDngJu8DiUSEsg2LV0AcHW4adm1sU5t9vLoMLsauBV59xkM+tF8O6Sqc65Iq8DixV+aTlsBlqU2m4e2nfIc8wsgWBTdGdEoguPylwzZtYfuB+43DmXF6HYwqWia64LpAKfmNl6gn2zc2N8ULoyf8+bgLnOuQLn3DpgDcFkEasqc83pwBwA59wXQE2CBeqqq0r9fz8afkkOXwEdzKyNmSUSHHCeW+acucD1ocf/BfzDhUZ6YlSF12xmZwAzCSaGWO+Hhgqu2TmX45xr7Jxr7ZxrTXCc5XLn3GJvwq0Slfm3/WeCrQbMrDHBbqbMCMZY1SpzzRuAfgBmlkwwOWRHNMrImgv8MjRr6Wwgxzm39Xhe0BfdSs65QjO7DZhPcKbDy865FWY2DljsnJsLvESw6ZlBcOBnuHcRH79KXvOTwAnAu6Gx9w3Oucs9C/o4VfKaq5VKXvN8YICZrQQCwO+cczHbKq7kNd8FvGBmvyU4OH1DLH/ZM7O3CSb4xqFxlIeAGgDOuRkEx1UuBjKAXODG437PGP7zEhGRMPFLt5KIiBwFJQcRESlHyUFERMpRchARkXKUHEREpBwlB5FKMrMbQpVcD/XT38xal9mXb2ZrzOxpM2tQ6nUeLnNeXqhi6u9Cq7hFPOeLdQ4iVWwYwVXHpa0EGoYeP0ZwUVIS0Bt4ADjDzPqWmWt/LsF1Bw0JlvR4AigCJoctcpFKUnIQOXrfOucyyu40s+LkkBmqjAnwLzOrQbAQ3BnAklJP+TJU5BEz+yvQlWAFVSUH8ZyasCLh91Xod/vDnRAqCLcUaBmRiEQqoJaDyNGLDxVnLOacc4EjnN8m9Ht3Ba/bmuBNbEQ8p+QgcvS+K7O9gOD4QbG4UPJI5Kcxh63AZ2WeFx+qadUAuAk4i2DRRxHPKTmIHL2h/HxAem+Z4zNDP8U+B251zh0oc17ZO9Hd45z7c5VEKHKclBxEjt7yQw1IlzIe+BDII1jpNucw551NcHZSM+BB4HEz+8o590lVBityLJQcRKpeViXvEfF1aLbSV2b2OcHuqilmdrruWCZe02wlkSjgnNsBjCN4p7orPQ5HRMlBJIrMJDiW8YCFRqpFvKLkIBIlQvfw/gPBxXBXeBuN+J3uBCciIuWo5SAiIuUoOYiISDlKDiIiUo6Sg4iIlKPkICIi5Sg5iIhIOUoOIiJSjpKDiIiU8/8B1/nEERuYDfMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import roc_curve\n",
    "\n",
    "fpr, tpr, thresholds = roc_curve(y_train_7, y_scores)\n",
    "\n",
    "def plot_roc_curve(fpr, tpr, label=None):\n",
    "    plt.plot(fpr, tpr, linewidth=2, label=label)\n",
    "    plt.plot([0, 1], [0, 1], 'k--')\n",
    "    plt.xlabel('FPR', fontsize=16)\n",
    "    plt.ylabel('TPR', fontsize=16) \n",
    "    \n",
    "plot_roc_curve(fpr, tpr)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí por debajo lo que está variando es el treshold, entonces para cada treshold, vamos viendo los puntos $(FPR, TPR)$. Una buena forma de entender esto es que nos interesa tener un clasificador que para una baja tasa de falsos positivos, tenga una alta tasa de verdaderos positivos. Así, si el área bajo la curva es cercana a uno, tendremos un buen clasificador. Podemos calcular esto rápido con `scikit_learn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9890355488875642"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "# AUC = Area under the curve\n",
    "roc_auc_score(y_train_7, y_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así, vemos que tenemos un buen clasificador."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clasificación multiclase\n",
    "\n",
    "Supongamos que ahora no queremos saber si algo es o no es un 7, sino que queremos saber qué número es. Con lo que sabemos hasta ahora, ¿cómo lo podemos hacer?\n",
    "\n",
    "Una opción es crear un clasificador de 0s, de 1s, ..., de 8s y de 9s. Luego para clasificar, nos quedamos con el número representado por el clasificador que como output entregue el mayor puntaje. Esta estrategia se llama _one-versus-the-rest_ (OvR).\n",
    "\n",
    "La otra opción es entrenar un clasificador binario para cada par de dígitos. Esto sería, un comparador de 0s con 1s, de 1s con 2s, y así sucesivamente. Luego nos quedamos con el dígito que haya ganado la mayor cantidad de \"duelos\". Esta estrategia, si tenemos $N$ clases, implica entrenar $N \\times (N - 1) / 2$. Esto para MNIST implica entrenar ¡45 clasificadores! aunque a su vez, cada clasificador se entrena con el subconjunto de imágenes que se enfrentan.\n",
    "\n",
    "Igual es importante saber que hay modelos que son multiclase de forma nativa y la estrategia anterior es solo para los modelos que no la soportan nativamente. En general, preferimos OvR cuando cuando el modelo escala bien respecto al tamaño del conjunto de entrenamiento, mientras que el OvO se utiliza cuando el entrenamiento no funciona bien para muchos datos.\n",
    "\n",
    "La librería `Scikit Learn` entiende cuando uno quiere hacer una clasificación multiclase y por debajo toma la mejor decisión. Vamos a ver un ejemplo con el _dataset_ MNIST. En este caso usaremos un modelo llamado `Support Vector Machine` para clasificar. Este modelo lo veremos más adelante en el curso, pero no te preocupes, la interfaz `fit` y `predict` no cambia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVC()"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.svm import SVC\n",
    "\n",
    "# Ojo, esto puede demorarse un poco\n",
    "svm_clf = SVC()\n",
    "svm_clf.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7], dtype=uint8)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svm_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos examinar su función de decisión."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3.80895496, -0.30212376,  6.19343167,  8.29375992,  1.71167996,\n",
       "         4.76436748,  0.69153837,  9.31783975,  2.75699419,  7.28292338]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_digit_scores = svm_clf.decision_function([some_digit])\n",
    "some_digit_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y finalmente, veremos las posibles clases de nuestro modelo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svm_clf.classes_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos entrenar un `SGDClassifier`, podemos hacerlo de la misma forma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7], dtype=uint8)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd_clf.fit(X_train, y_train)\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora vamos a evaluar nuestro modelo con _cross-validation_. Es un buen ejercicio que te detengas y pienses que significa hacer _cross-validation_ en este caso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.86945, 0.87705, 0.87715])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cross_val_score(sgd_clf, X_train, y_train, cv=3, scoring='accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estos son muy buenos puntajes, porque en este caso un clasificador _random_ tendría cerca del 10% de _accuracy_. Sin embargo, es una buena idea revisar la matriz de confusión para este escenario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5507,    0,   73,   29,   13,   53,   98,   19,  121,   10],\n",
       "       [   2, 6218,   92,   44,    8,   26,   17,   15,  293,   27],\n",
       "       [  21,   60, 5094,  132,   48,   28,  126,   92,  345,   12],\n",
       "       [  16,   29,  267, 4988,   11,  251,   44,  115,  333,   77],\n",
       "       [   5,   26,   53,   27, 5047,   16,   70,   37,  154,  407],\n",
       "       [  48,   27,   71,  228,   99, 4142,  207,   55,  464,   80],\n",
       "       [  25,   23,   40,   10,   25,   98, 5632,    2,   62,    1],\n",
       "       [  19,   16,   72,   26,   74,   12,    4, 5747,   79,  216],\n",
       "       [  16,   90,  100,  128,   40,  164,   59,   47, 5109,   98],\n",
       "       [  18,   26,   49,   66,  368,   34,    5,  586,  373, 4424]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_pred = cross_val_predict(sgd_clf, X_train, y_train, cv=3)\n",
    "conf_mx = confusion_matrix(y_train, y_train_pred)\n",
    "conf_mx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora bien, dado que tenemos muchos números, lo mejor es ver esto como una imagen. En esta imagen en escala de grises veremos para cada fila el número de instancias que son del número representado por esa clasificadas en cada columna. Mientras más instancias caen en un determinado casillero, más blanco el casillero. El casillero con el menor valor se lleva el color negro, y el de mayor valor el color blanco."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.matshow(conf_mx, cmap=plt.cm.gray)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora nos queremos concentrar en los errores, así que vamos a hacer lo siguiente:\n",
    "\n",
    "- Primero, vamos a setear en 0 la diagonal para que no nos entregue ruido.\n",
    "- Segundo, vamos a normalizar cada fila. Esto es sumar los valores de cada fila, y dividir todos los elementos de esa fila por el valor. Esto se hace porque una clase muy grande se puede ver mal en comparación a otras, pero si lo miramos como _ratio_, puede no ser así."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "row_sums = conf_mx.sum(axis=1, keepdims=True)\n",
    "norm_conf_mx = conf_mx / row_sums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.fill_diagonal(norm_conf_mx, 0)\n",
    "plt.matshow(norm_conf_mx, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí podemos ver que la principal fuente de errores es el número 8. El hecho de que esta columna esté más clara es que muchas instancias de otros números caen clasificadas erróneamentes ahí, principalmente instancias del número 5."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Palabras al cierre\n",
    "\n",
    "Hemos aprendido que significa clasificar en el contexto de _Machine Learning_. Además, aprendimos cómo medir el desempeño de un modelo clasificador. Durante el resto del curso nos vamos a detener en los modelos más clásicos de clasificación, como SVM o Random Forest, para entender cómo funcionan por debajo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}