semana04/3-3_svm_practica.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SVM para la detección de diabetes\n",
    "\n",
    "En este ejercicio intentamos crear una SVM que permita identificar pacientes con diabetes conociendo únicamente sus características físicas, sin necesidad de realizar un examen específico sobre el tema. Contamos con datos de 768 pacaientes, los cuales están identificados on `0` en caso de no tener diabetes y con `1` en caso de tener un diagnóstico positivo.\n",
    "\n",
    "La tarea será realizada con una SVM de **clasificación**, que será relizada con la clas `SVC` de la librería `sklearn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Manipulación de datos\n",
    "import pandas as pd\n",
    "# Operaciones numéricas\n",
    "import numpy as np\n",
    "# Para medición del tiempo que toma ejecutar los procesos\n",
    "from time import time\n",
    "# Para separar datos de entrenamiento y prueba\n",
    "from sklearn.model_selection import train_test_split\n",
    "# Librería para SVM\n",
    "from sklearn.svm import SVC\n",
    "# Medición de precisión\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix\n",
    "# Generar gráficos\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 768 entries, 0 to 767\n",
      "Data columns (total 9 columns):\n",
      " #   Column                    Non-Null Count  Dtype  \n",
      "---  ------                    --------------  -----  \n",
      " 0   Pregnancies               768 non-null    int64  \n",
      " 1   Glucose                   768 non-null    int64  \n",
      " 2   BloodPressure             768 non-null    int64  \n",
      " 3   SkinThickness             768 non-null    int64  \n",
      " 4   Insulin                   768 non-null    int64  \n",
      " 5   BMI                       768 non-null    float64\n",
      " 6   DiabetesPedigreeFunction  768 non-null    float64\n",
      " 7   Age                       768 non-null    int64  \n",
      " 8   Outcome                   768 non-null    int64  \n",
      "dtypes: float64(2), int64(7)\n",
      "memory usage: 54.1 KB\n"
     ]
    }
   ],
   "source": [
    "# Leemos el set de datos y lo cargamos en la variable df, que es un DataFrame de pandas\n",
    "diabetes_df = pd.read_csv('diabetes.csv')\n",
    "# Mostrar información sobre el set de datos\n",
    "diabetes_df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Siempre es recomendable explorar el set de datos antes de realizar un análisis sobre el mismo. En este caso, simplemente mostraremos los primeros cinco registros para conocer cómo se componen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Pregnancies</th>\n",
       "      <th>Glucose</th>\n",
       "      <th>BloodPressure</th>\n",
       "      <th>SkinThickness</th>\n",
       "      <th>Insulin</th>\n",
       "      <th>BMI</th>\n",
       "      <th>DiabetesPedigreeFunction</th>\n",
       "      <th>Age</th>\n",
       "      <th>Outcome</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6</td>\n",
       "      <td>148</td>\n",
       "      <td>72</td>\n",
       "      <td>35</td>\n",
       "      <td>0</td>\n",
       "      <td>33.6</td>\n",
       "      <td>0.627</td>\n",
       "      <td>50</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>85</td>\n",
       "      <td>66</td>\n",
       "      <td>29</td>\n",
       "      <td>0</td>\n",
       "      <td>26.6</td>\n",
       "      <td>0.351</td>\n",
       "      <td>31</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8</td>\n",
       "      <td>183</td>\n",
       "      <td>64</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>23.3</td>\n",
       "      <td>0.672</td>\n",
       "      <td>32</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>89</td>\n",
       "      <td>66</td>\n",
       "      <td>23</td>\n",
       "      <td>94</td>\n",
       "      <td>28.1</td>\n",
       "      <td>0.167</td>\n",
       "      <td>21</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>137</td>\n",
       "      <td>40</td>\n",
       "      <td>35</td>\n",
       "      <td>168</td>\n",
       "      <td>43.1</td>\n",
       "      <td>2.288</td>\n",
       "      <td>33</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Pregnancies  Glucose  BloodPressure  SkinThickness  Insulin   BMI  \\\n",
       "0            6      148             72             35        0  33.6   \n",
       "1            1       85             66             29        0  26.6   \n",
       "2            8      183             64              0        0  23.3   \n",
       "3            1       89             66             23       94  28.1   \n",
       "4            0      137             40             35      168  43.1   \n",
       "\n",
       "   DiabetesPedigreeFunction  Age  Outcome  \n",
       "0                     0.627   50        1  \n",
       "1                     0.351   31        0  \n",
       "2                     0.672   32        1  \n",
       "3                     0.167   21        0  \n",
       "4                     2.288   33        1  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diabetes_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nuestro objetivo será predecir la columna `Outcome`, que contiene el resultado del diagnóstico. Es importante comprender de qué manera se distribuyen las muestras para identificar posibles fallas y tendencias falsas (sesgos) en nuestro algoritmo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    500\n",
       "1    268\n",
       "Name: Outcome, dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Contar los valores únicos de una columna en un DataFrame\n",
    "diabetes_df['Outcome'].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso, tenemos muchas más muestras de pacientes diagnosticados sin diabetes (`0`). Esto podría representar un problema para las predicciones de nuestra SVM, pues estará sesgada a predecir más resultados de la clase que contiene más muestras."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para empezar el proceso de entrenamiento, es necesario separar las características (`X`) de las etiquetas (`y`). El objetivo de todo el análisis es poder predecir una etiqueta `y`, contando únicamente con las características (`y`). La SVM se encargará de aprender la relación que existe entre `X` y `y`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Pregnancies</th>\n",
       "      <th>Glucose</th>\n",
       "      <th>BloodPressure</th>\n",
       "      <th>SkinThickness</th>\n",
       "      <th>Insulin</th>\n",
       "      <th>BMI</th>\n",
       "      <th>DiabetesPedigreeFunction</th>\n",
       "      <th>Age</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6</td>\n",
       "      <td>148</td>\n",
       "      <td>72</td>\n",
       "      <td>35</td>\n",
       "      <td>0</td>\n",
       "      <td>33.6</td>\n",
       "      <td>0.627</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>85</td>\n",
       "      <td>66</td>\n",
       "      <td>29</td>\n",
       "      <td>0</td>\n",
       "      <td>26.6</td>\n",
       "      <td>0.351</td>\n",
       "      <td>31</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8</td>\n",
       "      <td>183</td>\n",
       "      <td>64</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>23.3</td>\n",
       "      <td>0.672</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>89</td>\n",
       "      <td>66</td>\n",
       "      <td>23</td>\n",
       "      <td>94</td>\n",
       "      <td>28.1</td>\n",
       "      <td>0.167</td>\n",
       "      <td>21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>137</td>\n",
       "      <td>40</td>\n",
       "      <td>35</td>\n",
       "      <td>168</td>\n",
       "      <td>43.1</td>\n",
       "      <td>2.288</td>\n",
       "      <td>33</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Pregnancies  Glucose  BloodPressure  SkinThickness  Insulin   BMI  \\\n",
       "0            6      148             72             35        0  33.6   \n",
       "1            1       85             66             29        0  26.6   \n",
       "2            8      183             64              0        0  23.3   \n",
       "3            1       89             66             23       94  28.1   \n",
       "4            0      137             40             35      168  43.1   \n",
       "\n",
       "   DiabetesPedigreeFunction  Age  \n",
       "0                     0.627   50  \n",
       "1                     0.351   31  \n",
       "2                     0.672   32  \n",
       "3                     0.167   21  \n",
       "4                     2.288   33  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crearemos un nuevo df llamado X (notar mayus) con las columnas de características\n",
    "# Se obtiene generando una lista de columnas del df a utilizar\n",
    "lista_caract = [\n",
    "    'Pregnancies',\n",
    "    'Glucose',\n",
    "    'BloodPressure',\n",
    "    'SkinThickness',\n",
    "    'Insulin',\n",
    "    'BMI',\n",
    "    'DiabetesPedigreeFunction',\n",
    "    'Age'\n",
    "]\n",
    "# Luego tomando esa lista del df original\n",
    "X = diabetes_df[lista_caract]\n",
    "# Mostraremos los primeros cinco registros para conocer cómo se compone X\n",
    "X.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Outcome</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Outcome\n",
       "0        1\n",
       "1        0\n",
       "2        1\n",
       "3        0\n",
       "4        1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Utilizaremos el mismo procedimiento para generar y\n",
    "lista_etiq = ['Outcome']\n",
    "y = diabetes_df[lista_etiq]\n",
    "y.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora que tenemos nuestros objetos de `X` y `y`, procederemos a separarlos en conjuntos de **entrenamiento** (que serviran para aprender) y **prueba** (para validadr que el aprendizaje sea correcto.\n",
    "\n",
    "Este proceso será realizado con la función `train_test_split` que importamos al inicio del documento. Por defecto, esta función tomará 25% (`0.25`) de nuestro conjunto total de datos como prueba y el resto para entrenamiento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Separar en datos de entrenamiento y datos de prueba\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X,\n",
    "    y\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(576, 8)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Mostraremos la cantidad de datos a utilizar para el entrenamiento\n",
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(576, 1)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(192, 8)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Luego, la cantidad de datos a utilizar para validar\n",
    "X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(192, 1)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creación de la SVM\n",
    "\n",
    "Utilizaremos la clase `SVC` (Support Vector Classifier) que importamos al inicio. Como vimos en [la introducción](3-2_svm-intro.ipynb), existen diversos tipos de kernel que podemos utilizar para crear una SVM. En este caso tomaremos un kernel **lineal** (en sklearn `linear`) para que el entrenamiento sea rápido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definició del modelo que llamaremos clf\n",
    "clf = SVC(kernel='linear')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El entrenamiento de un modelo en sklearn es bastante sencillo. Basta con llamar el método `fit` para encontrar las relaciones entre nuestra `X` y `y`. El único inconveniente es que el método `fit` recibe valores de tipo `array`, pero nuestros datos actualmente se encuentran contenidos en objetos de tipo `pandas.DataFrame` (df). Para convertir un df en un array, basta con tomar el atributo `values` del mismo df."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrenamiento terminado en 3.069869041442871 segundos\n"
     ]
    }
   ],
   "source": [
    "# Guardamos el registro del momento en el que empezamos el entrenamiento\n",
    "hora_inicio = time()\n",
    "\n",
    "# Iniciamos el entrenamiento ejecutando el metodo fit\n",
    "# Los valores que enviamos son los valores de X y y\n",
    "#\n",
    "# El .ravel() que final de y.values es un pequeño truco para cambiar su forma\n",
    "# esto permite convertir una matriz de dos dimensiones en una sola dimesión,\n",
    "# con ello, cada elemento de esta nueva matriz corresponde a un registro de X\n",
    "clf.fit(X_train.values, y_train.values.ravel())\n",
    "\n",
    "# Imprimimos el tiempo tomado para el entrenamiento\n",
    "print(\"Entrenamiento terminado en {} segundos\".format(time() - hora_inicio))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una vez terminado el entrenamiento, es necesario medir su precisión. Para ello, intentaremos predecir los datos de nuestra `y` de prueba utilizando nuestra `X` de prueba. A estos datos les llamaremos `y_pred`, pues contendrán nuestra predicción."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicción terminada en 0.0029921531677246094 segundos\n"
     ]
    }
   ],
   "source": [
    "# Otra vez guardaremos registro del tiempo que nos toma crear esta predicción\n",
    "hora_inicio = time()\n",
    "# Iniciamos la predicción con nuestra X de prueba\n",
    "y_pred = clf.predict(X_test)\n",
    "# Mostramos el tiempo tomado para la predicción\n",
    "print(\"Predicción terminada en {} segundos\".format(time() - hora_inicio))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una vez terminada nuestra predicción, podemos comparar su precisión con la función `accuracy_score`. Esto se encargará de mostrarnos el porcentaje de predicciones correctas realizadas por nuestro modelo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8020833333333334"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Evaluamos la precisión \n",
    "accuracy_score(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso, la precisión del modelo fue relativamente aceptable (0.79). Sin embargo, debido a que los datos de aprendizaje fueron muy pocos (cerca de 500) y que estaban muy sesgados hacia la clase más representada (la gente sin diabetes), es posible que no funcione bien en muchos casos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matriz de confusión\n",
    "\n",
    "Una matriz de confusión nos ayuda a tener una mejor idea del rendimiento de nuestro modelo. Se encarga de comparar la cantidad de aciertos de cada clase de nuestros datos de prueba (`y_test` en este caso) y nuestros datos calculados (`y_pred` en este caso)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[119,  12],\n",
       "       [ 26,  35]], dtype=int64)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# La función confusion_matrix recibe las \"respuestas correctas\" y nuestras predicciones\n",
    "# genera una matriz que indica, para cada clase, la cantidad de predicciones correctas e incorrectas\n",
    "conf_diabetes = confusion_matrix(y_test, y_pred)\n",
    "conf_diabetes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Debido a que es poco complicado comprender la matriz únicamente de forma numérica, vamos a crear una función que lo muestre de forma gráfica."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_cm(cm, classes):\n",
    "    \"\"\"Esta función se encarga de generar un gráfico con nuestra matriz de confusión.\n",
    "    cm es la matriz generada por confusion_matrix\n",
    "    classes es una lista que contiene las posibles clases que puede predecir nuestro modelo\n",
    "    \"\"\"\n",
    "    plt.imshow(cm, cmap=plt.cm.Blues)\n",
    "    plt.title('Matriz de confusión')\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "    thresh = cm.max() / 2.\n",
    "    for indice_fila, fila in enumerate(cm):\n",
    "        for indice_columna, columna in enumerate(fila):\n",
    "            if cm[indice_fila, indice_columna] > thresh:\n",
    "                color = \"white\"\n",
    "            else:\n",
    "                color = \"black\"\n",
    "            plt.text(\n",
    "                indice_columna,\n",
    "                indice_fila,\n",
    "                cm[indice_fila, indice_columna],\n",
    "                color=color,\n",
    "                horizontalalignment=\"center\"\n",
    "            )\n",
    "    plt.ylabel(\"Valores reales\")\n",
    "    plt.xlabel(\"Valores calculados\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Generamos el gráfico llamando la función que creamos y enviando los parámetros\n",
    "# cm = nuestra matriz de confusión (conf_diabetes)\n",
    "# classes = las clases a predecir (si tienen diabetes o no)\n",
    "plot_cm(conf_diabetes, ['No diabetes', 'Sí diabetes'])"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}