9_Clasificacion_multiclase.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "! mkdir -p datasets\n",
    "%cd datasets\n",
    "! wget -nc https://raw.githubusercontent.com/pablonoya/zigzag-ml/master/datasets/Iris.csv\n",
    "%cd .."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Clasificación Multiclase\n",
    "Cambiamos el nombre porque ¡tenemos una nueva tarea!, otra vez 😃.   \n",
    "Tenemos **tres estrategias** para predecir a cuál de las especies de iris pertenece un ejemplo, aplicamos una de ellas a medias (¿o a tercias?) en el capítulo anterior, veamos cuál es."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## One vs the Rest\n",
    "La idea es etiquetar **una clase como positiva** y **todas las demás como negativas**, es **una contra el resto**. En el capítulo anterior distinguimos entre **setosa** y **no-setosa**, esto lo hacemos para todas las clases, entrenando un **clasificador binario distinto** para cada caso.\n",
    "\n",
    "Completa el siguiente código para importar los datos 😉."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import pandas ___\n",
    "from sklearn.model_selection import ___\n",
    "import numpy as np\n",
    "\n",
    "np.random.___\n",
    "\n",
    "df = ___.read_csv(\"./datasets/Iris.csv\")\n",
    "y = df[\"___\"]\n",
    "\n",
    "# no necesitamos estas columnas\n",
    "# guardamos las demás en X\n",
    "X = df.drop(columns=['Id', 'Species'])\n",
    "\n",
    "_, _, _, _ = train_test_split(X, y, test_size=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto no es muy complicado de implementar, pero el objeto `LogisticRegression` ya cuenta con la opción de usar dicha estrategia, estableciento su parámetro `multi_class` en `'ovr'`.  \n",
    "El modelo espera que `y` sea un array 1D, por lo que **no es necesario que realicemos el one-hot encoding**.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "model_log = LogisticRegression(multi_class=\"ovr\")\n",
    "model_log.fit(X_train, y_train)\n",
    "\n",
    "# realicemos algunas predicciones\n",
    "X_sample = X_test.sample(5)\n",
    "model_log.predict(X_sample)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "También tenemos la implementación en `OneVsRestClassifier` de `sklearn.multiclass`, este recibe una **instancia del modelo** que usaremos, por supuesto, debe ser uno de **regresión logística**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sklearn.multiclass import OneVsRestClassifier\n",
    "\n",
    "model_ovr = OneVsRestClassifier( LogisticRegression() )\n",
    "model_ovr.fit(X_train, y_train)\n",
    "model_ovr.predict(X_sample)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## One vs One\n",
    "Entrenamos clasificadores por pares, **uno contra uno** distinguimos setosa de versicolor, setosa de virginica, versicolor de virginica, y así hasta entrenar todas las posibles combinaciones, siendo en total:\n",
    "\n",
    "$\\dfrac{K (K-1)}{2} $\n",
    "\n",
    "Donde $K$ es el número de clases.\n",
    "\n",
    "La ventaja es que cada clasificador se entrena **sólo con los datos que contienen los pares de clases a distinguir**, algunos modelos **no escalan bien con el tamaño del dataset**, es decir, rinden peor con un dataset más grande.  \n",
    "En estos casos, **es más rápido entrenar muchos clasificadores en pequeños datasets** en lugar de  **pocos clasificadores en datasets más grandes**. \n",
    "\n",
    "Usaremos `OneVsOneClassifier` también de `sklearn.multiclass` pues `LogisticRegression` no soporta esta estrategia. Completa para ver la predicción 😱."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sklearn.multiclass import OneVsOneClassifier\n",
    "\n",
    "model_ovo = OneVsOneClassifier(LogisticRegression())\n",
    "model_ovo.fit(X_train, y_train)\n",
    "model_ovo.predict(___)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Regresión logística multinomial\n",
    "Es una **generalización** de la regresión logística, que cubre **múltiples clases** directamente, eliminando la necesidad de entrenar varios clasificadores binarios.\n",
    "\n",
    "El parámetro `multiclass` que vimos antes acepta los parámetros `'auto'`, `'ovr'` y `'multinomial'`, **auto** es la opción por defecto, y esta selecciona **ovr** si la variable `y` es **binaria**.\n",
    "\n",
    "Como no es nuestro caso, seleccionará **multinomial**, por lo que sería opcional especificarlo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "model_multi = LogisticRegression(multi_class='___')\n",
    "model_multi.fit(X_train, y_train)\n",
    "\n",
    "model_multi.predict(X_sample)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Regresión Softmax\n",
    "Esta generalización es también conocida como **regresión Softmax**. Dado un ejemplo $x$, esta calcula primero un puntaje $s_k(x)$ para cada clase $k$\n",
    "\n",
    "$$ s_k(x) = x^T\\theta^{(k)} $$\n",
    "\n",
    "Nota que **cada clase** tiene su propio **vector** $\\theta^{(k)}$. Cada uno se guarda en una fila de la matríz $\\theta$ que está repartida en los atributos `coef_` e `intercept_` de nuestro modelo. A diferencia de lo que vimos al implementar el [descenso del gradiente](5_descenso_del_gradiente.ipynb), donde nuestra variable `theta` contenía los coeficientes y el término independiente en una sola matriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    " model_multi.coef_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_multi.intercept_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Una columna por cada feature, una fila por cada clase 😉\n",
    "\n",
    "Luego se aplica la función **softmax** para calcular las probabilidades $\\hat{p}_k$ de que nuestro ejemplo $x$ **pertenezca a una clase $k$** calculando una fórmula usando exponenciales, cada una de estas representan al número $e$ elevado a los puntajes $ s_k(x) $ que antes calculamos.\n",
    "\n",
    "$\\hat{p}_k = \\dfrac{\\exp s_k(x)}{\\sum^K_{j=1}\\exp s_j(x)}$\n",
    "\n",
    "Donde $K$ es el número total de clases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "len(model_multi.classes_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Al final, la predicción toma en cuenta la clase con **la probabilidad más alta como respuesta**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Implementación de sus fórmulas\n",
    "Primero calculemos $s(x)$ como un vector que contega los **puntajes de cada clase**, por lo que tendrá 3 elementos al ser el resultado de una multiplicación de matrices, y no olvidemos sumar los términos independientes 😉."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Operamos con una matriz de numpy\n",
    "# y guardamos la primera fila\n",
    "X_sample1 = X_sample.to_numpy()[0]\n",
    "\n",
    "s = X_sample1 @ model_multi.coef_.T + model_multi.intercept_\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Luego calculamos $p$  como otro vector de tres elementos que contiene las **probabilidades** de que nuestro ejemplo **pertenezca a alguna de las clases**: 0, 1 o 2, que corresponden a: setosa, versicolor o virginica, respectivamente 😄"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "p = np.exp(s) / np.sum(np.exp(s))\n",
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Finalmente obtenemos a qué clase pertenece nuestro ejemplo 😃.  \n",
    "Podemos usar `np.argmax` sobre el **vector que conteniene las probabilidades**, y esto nos retorna el **índice donde se encuentra la probabilidad más alta**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Clase de nuestro primer ejemplo\n",
    "pred = np.argmax(p)\n",
    "pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Es **versicolor**, como nuestros anteriores modelos lo predijeron 😄"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Ejercicios\n",
    "Intenta predecir **todo** `X_sample`, usando esta implementación al final `pred` debería ser un **array de 5 elementos** con cada una de las clases predichas para cada ejemplo 😉.    \n",
    "Además, `s` y `p` deberían ser matrices de 3x5 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reemplaza X_sample1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Alguna estrategia rendirá mejor sobre las otras?\n",
    "Comprúebalo evaluando los 3 modelos sobre precision y recall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importa las métricas, evalúa siempre sobre el test set\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Cada estrategia tiene su momento: **OvR** si el modelo necesitamos algo **estrictamente binario**, **OvO**  si el modelo **no escala bien con la cantidad de datos** y la **regresión softmax** es una regresión logística generalizada 😃.\n",
    "\n",
    "Las primeras dos nos dicen que existen **más tipos de modelos de clasificación**, pero el próximo que veremos usa softmax al final 😂 pero no por ello es menos interesante, es más, te aseguro que su nombre te despierta interés 🧠:\n",
    "\n",
    "Te presento a las [redes neuronales artificiales](10_Redes_neuronales.ipynb) "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}