Tutorial ScikitLearn: Métricas de clasificación

Matriz de confusión

La matriz de confusión es una herramienta fundamental para evaluar el rendimiento de un modelo de clasificación. Proporciona una representación visual de las predicciones del modelo frente a las etiquetas reales, permitiendo identificar dónde se producen errores específicos.

En un problema de clasificación binaria, la matriz de confusión es una tabla de 2x2 que muestra las siguientes categorías:

• Verdaderos Positivos (TP): Predicciones correctas de la clase positiva.
• Falsos Positivos (FP): Predicciones incorrectas donde la clase negativa se clasifica como positiva.
• Verdaderos Negativos (TN): Predicciones correctas de la clase negativa.
• Falsos Negativos (FN): Predicciones incorrectas donde la clase positiva se clasifica como negativa.

La estructura de la matriz es la siguiente:

Este formato permite evaluar la calidad de las predicciones y determinar qué tipo de errores son más frecuentes.

A continuación, se presenta un ejemplo completo en Python que ilustra cómo generar y visualizar la matriz de confusión utilizando Scikit-Learn:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_wine
from sklearn.ensemble import RandomForestClassifier

# Cargar el conjunto de datos
datos = load_wine()
X = datos.data
y = datos.target

# Dividir en conjunto de entrenamiento y prueba
X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# Crear y entrenar el modelo
modelo = RandomForestClassifier(random_state=42)
modelo.fit(X_entrenamiento, y_entrenamiento)

# Realizar predicciones
y_pred = modelo.predict(X_prueba)

# Generar la matriz de confusión
matriz_confusion = confusion_matrix(y_prueba, y_pred)

# Visualizar la matriz de confusión
etiquetas = datos.target_names
disp = ConfusionMatrixDisplay(confusion_matrix=matriz_confusion, display_labels=etiquetas)
disp.plot(cmap=plt.cm.Blues)
plt.title("Matriz de Confusión")
plt.show()

En este código:

• Se utiliza el conjunto de datos Wine de Scikit-Learn, que es un problema de clasificación multiclase.
• Se divide el conjunto de datos en entrenamiento y prueba con train_test_split.
• Se entrena un RandomForestClassifier con los datos de entrenamiento.
• Se realizan predicciones sobre los datos de prueba.
• Se calcula la matriz de confusión con confusion_matrix.
• Se visualiza la matriz con ConfusionMatrixDisplay.

La visualización resultante muestra de forma clara dónde el modelo acierta y dónde se equivoca, lo que es esencial para entender su rendimiento.

Es importante tener en cuenta que, en clasificación multiclase, la matriz de confusión se generaliza a una matriz NxN, donde N es el número de clases. Cada celda [i, j] representa el número de observaciones de la clase real i que fueron clasificadas como j.

El análisis de la matriz de confusión permite:

• Identificar clases que el modelo confunde con frecuencia.
• Evaluar si hay un desbalance en las predicciones.
• Tomar decisiones sobre ajustes en el modelo o en el preprocesamiento de datos.

Además, es común complementar el análisis con métricas derivadas de la matriz de confusión, como se muestra a continuación:

from sklearn.metrics import classification_report

# Generar un reporte detallado
reporte = classification_report(y_prueba, y_pred, target_names=etiquetas)
print(reporte)

Este reporte proporciona información sobre la precisión, el recall y el f1-score para cada clase, ofreciendo una visión más completa del desempeño del modelo.

La matriz de confusión y las métricas asociadas son herramientas esenciales para evaluar y mejorar los modelos de clasificación en aprendizaje automático.

Precisión, exhaustividad (Recall) y puntaje F1-Score

La precisión, la exhaustividad (también conocida como recall) y el puntaje F1-Score son métricas fundamentales para evaluar el rendimiento de los modelos de clasificación. Estas métricas proporcionan una visión más detallada de la calidad de las predicciones, especialmente en contextos donde las clases están desbalanceadas.

La precisión mide la proporción de verdaderos positivos entre todos los casos predichos como positivos. Indica qué tan exactas son las predicciones positivas del modelo y se calcula como:

$$
\text{Precisión} = \frac{\text{Verdaderos Positivos (TP)}}{\text{Verdaderos Positivos (TP)} + \text{Falsos Positivos (FP)}}
$$

La exhaustividad o recall representa la proporción de verdaderos positivos que el modelo ha identificado correctamente entre todos los casos que realmente son positivos. Mide la capacidad del modelo para encontrar todos los casos positivos y se define como:

$$
\text{Recall} = \frac{\text{Verdaderos Positivos (TP)}}{\text{Verdaderos Positivos (TP)} + \text{Falsos Negativos (FN)}}
$$

El puntaje F1-Score es la media armónica de la precisión y el recall. Es especialmente útil cuando existe un desequilibrio entre las clases y se busca un equilibrio entre precisión y exhaustividad:

$$
\text{F1-Score} = 2 \times \frac{\text{Precisión} \times \text{Recall}}{\text{Precisión} + \text{Recall}}
$$

Estas métricas son esenciales cuando el costo de los falsos positivos y los falsos negativos es diferente. Por ejemplo, en detección de fraudes o diagnósticos médicos, puede ser más crítico minimizar los falsos negativos.

A continuación, se muestra un ejemplo completo en Python que ilustra cómo calcular estas métricas utilizando Scikit-Learn:

from sklearn.metrics import precision_score, recall_score, f1_score, classification_report
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier

# Cargar el conjunto de datos
datos = load_breast_cancer()
X = datos.data
y = datos.target

# Dividir en conjunto de entrenamiento y prueba
X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# Crear y entrenar el modelo con hiperparámetros específicos
modelo = RandomForestClassifier(
    random_state=42,
    min_samples_leaf=2,    
    max_features='sqrt'
)
modelo.fit(X_entrenamiento, y_entrenamiento)

# Realizar predicciones
y_pred = modelo.predict(X_prueba)

# Calcular las métricas
precision = precision_score(y_prueba, y_pred)
recall = recall_score(y_prueba, y_pred)
f1 = f1_score(y_prueba, y_pred)

print(f"Precisión: {precision:.2f}")
print(f"Exhaustividad (Recall): {recall:.2f}")
print(f"Puntaje F1-Score: {f1:.2f}")

# Generar un reporte detallado
reporte = classification_report(y_prueba, y_pred, target_names=datos.target_names)
print(reporte)

En este código:

• Se utiliza el conjunto de datos Breast Cancer de Scikit-Learn, un problema clásico de clasificación binaria.
• Se divide el conjunto en entrenamiento y prueba mediante train_test_split, utilizando la opción stratify para mantener el equilibrio de clases.
• Se entrena un RandomForestClassifier con los datos de entrenamiento.
• Se realizan predicciones sobre el conjunto de prueba.
• Se calculan las métricas de precisión, recall y F1-Score con las funciones correspondientes.
• Se imprime un reporte detallado utilizando classification_report.

Al ejecutar el código, se obtiene una salida similar a:

Precisión: 0.94
Exhaustividad (Recall): 0.96
Puntaje F1-Score: 0.95
              precision    recall  f1-score   support

   malignant       0.94      0.91      0.92        64
      benign       0.94      0.96      0.95       107

    accuracy                           0.94       171
   macro avg       0.94      0.93      0.94       171
weighted avg       0.94      0.94      0.94       171

En este ejemplo, el modelo presenta una alta precisión y exhaustividad en ambas clases, lo que indica un buen rendimiento general.

Es importante destacar que en situaciones de clases desbalanceadas, donde una clase es mucho más frecuente que otra, la precisión y el recall proporcionan una evaluación más completa que la exactitud (accuracy). Por ejemplo:

• Una alta precisión pero bajo recall sugiere que el modelo es bueno identificando casos positivos, pero está pasando por alto muchos casos reales (falsos negativos).
• Un alto recall pero baja precisión indica que el modelo captura la mayoría de los casos positivos, pero tiene muchos falsos positivos.

El puntaje F1-Score equilibra estos dos aspectos y es especialmente útil cuando se busca un compromiso entre precisión y exhaustividad.

Además, Scikit-Learn permite calcular estas métricas para problemas de clasificación multiclase utilizando el parámetro average en las funciones de métricas. Por ejemplo:

# Cálculo de métricas en clasificación multiclase
precision_micro = precision_score(y_prueba, y_pred, average='micro')
recall_micro = recall_score(y_prueba, y_pred, average='micro')
f1_micro = f1_score(y_prueba, y_pred, average='micro')

Las opciones comunes para average son:

• 'micro': Calcula las métricas globalmente considerando todas las clases.
• 'macro': Calcula la métrica por clase y luego obtiene la media no ponderada.
• 'weighted': Similar a 'macro', pero pondera por el soporte (número de muestras) de cada clase.

Comprender la diferencia entre estas opciones es crucial para una evaluación adecuada del modelo, especialmente en conjuntos de datos con clases desbalanceadas.

Curva ROC y área bajo la curva (AUC)

La Curva ROC (Receiver Operating Characteristic) es una herramienta esencial para evaluar el rendimiento de un modelo de clasificación binaria. Representa gráficamente la relación entre la tasa de verdaderos positivos (TPR) y la tasa de falsos positivos (FPR) a diferentes umbrales de decisión. La Área Bajo la Curva (AUC) cuantifica el desempeño global del modelo; un AUC más cercano a 1 indica un modelo con mejor capacidad discriminativa.

En la construcción de la curva ROC, se calculan los siguientes parámetros:

1.   Tasa de Verdaderos Positivos (TPR): También conocida como sensibilidad o recall, se define como:

$$
\text{TPR} = \frac{\text{Verdaderos Positivos (TP)}}{\text{Verdaderos Positivos (TP)} + \text{Falsos Negativos (FN)}}
$$

2.   Tasa de Falsos Positivos (FPR): Calculada como:

$$
\text{FPR} = \frac{\text{Falsos Positivos (FP)}}{\text{Falsos Positivos (FP)} + \text{Verdaderos Negativos (TN)}}
$$

Al variar el umbral de clasificación, se obtienen diferentes pares (FPR, TPR) que trazan la curva ROC. Esta curva permite visualizar el compromiso entre la sensibilidad y la especificidad del modelo.

A continuación, se presenta un ejemplo completo en Python que ilustra cómo calcular y visualizar la curva ROC y el AUC utilizando Scikit-Learn:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import roc_curve, auc
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier

# Cargar el conjunto de datos
datos = load_breast_cancer()
X = datos.data
y = datos.target

# Dividir en conjunto de entrenamiento y prueba
X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# Crear y entrenar el modelo
modelo = RandomForestClassifier(random_state=42)
modelo.fit(X_entrenamiento, y_entrenamiento)

# Obtener las probabilidades de clase positiva
y_prob = modelo.predict_proba(X_prueba)[:, 1]

# Calcular la curva ROC
fpr, tpr, thresholds = roc_curve(y_prueba, y_prob)
roc_auc = auc(fpr, tpr)

# Visualizar la curva ROC
plt.figure()
plt.plot(fpr, tpr, color='darkorange',
         label='Curva ROC (AUC = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('Tasa de Falsos Positivos (FPR)')
plt.ylabel('Tasa de Verdaderos Positivos (TPR)')
plt.title('Curva ROC')
plt.legend(loc="lower right")
plt.show()

En este código:

• Se utiliza el conjunto de datos Breast Cancer de Scikit-Learn, un problema clásico de clasificación binaria.
• Se divide el conjunto en entrenamiento y prueba utilizando train_test_split con estratificación para mantener el equilibrio de clases.
• Se entrena un RandomForestClassifier con los datos de entrenamiento.
• Se obtienen las probabilidades predichas para la clase positiva mediante predict_proba.
• Se calcula la curva ROC utilizando roc_curve, que devuelve los valores de FPR, TPR y los umbrales correspondientes.
• Se calcula el AUC con la función auc.
• Se visualiza la curva ROC utilizando Matplotlib, mostrando el AUC en la leyenda.

La curva ROC generada permite evaluar la capacidad del modelo para distinguir entre las clases positiva y negativa a diferentes umbrales. Un modelo perfecto tendría una TPR de 1 y una FPR de 0, es decir, una curva que pasa por el punto superior izquierdo del gráfico.

Es importante destacar que el AUC es una métrica independiente del umbral, lo que proporciona una evaluación del rendimiento del modelo en general. Un AUC de 0.5 indica que el modelo no tiene capacidad discriminativa (equivalente a una clasificación aleatoria), mientras que un AUC de 1.0 representa una clasificación perfecta.

En casos donde se trabaja con problemas desbalanceados, la curva ROC y el AUC pueden no reflejar completamente el rendimiento del modelo. En tales situaciones, es recomendable considerar también otras métricas como la curva Precisión-Recall.

Para modelos de clasificación multiclase, Scikit-Learn permite extender el cálculo del AUC utilizando estrategias de binarización. A continuación, se muestra un ejemplo para un problema multiclase:

from sklearn.datasets import load_wine
from sklearn.preprocessing import label_binarize
from sklearn.multiclass import OneVsRestClassifier

# Cargar el conjunto de datos
datos = load_wine()
X = datos.data
y = datos.target

# Binarizar las etiquetas
y_bin = label_binarize(y, classes=np.unique(y))
n_clases = y_bin.shape[1]

# Dividir en conjunto de entrenamiento y prueba
X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(
    X, y_bin, test_size=0.3, random_state=42
)

# Crear y entrenar el modelo en esquema One vs Rest
modelo = OneVsRestClassifier(RandomForestClassifier(random_state=42))
modelo.fit(X_entrenamiento, y_entrenamiento)

# Obtener las probabilidades predictivas
y_score = modelo.predict_proba(X_prueba)

# Calcular la curva ROC y el AUC para cada clase
fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(n_clases):
    fpr[i], tpr[i], _ = roc_curve(y_prueba[:, i], y_score[:, i])
    roc_auc[i] = auc(fpr[i], tpr[i])

# Visualizar la curva ROC para la clase 0
plt.figure()
plt.plot(fpr[0], tpr[0], color='darkorange',
         label='Curva ROC clase 0 (AUC = %0.2f)' % roc_auc[0])
plt.plot([0, 1], [0, 1], color='navy', linestyle='--')
plt.xlabel('Tasa de Falsos Positivos (FPR)')
plt.ylabel('Tasa de Verdaderos Positivos (TPR)')
plt.title('Curva ROC para la clase 0')
plt.legend(loc="lower right")
plt.show()

En este ejemplo:

• Se trabaja con el conjunto de datos Wine, que tiene tres clases.
• Las etiquetas se binarizan utilizando label_binarize para adaptarlas al formato requerido.
• Se emplea un clasificador OneVsRestClassifier para manejar la clasificación multiclase.
• Se calculan las curvas ROC y los AUC para cada clase por separado.
• Se visualiza la curva ROC para una de las clases.

La interpretación de las curvas ROC en problemas multiclase requiere analizar cada clase individualmente o considerar promedios.

Adicionalmente, es posible comparar el rendimiento de diferentes modelos o ajustar los umbrales de decisión para optimizar ciertas métricas. La comprensión profunda de la curva ROC y el AUC es crucial para la evaluación y mejora de modelos de clasificación en aprendizaje automático.

Curva Precisión-Recall

La Curva Precisión-Recall es una herramienta fundamental para evaluar el rendimiento de modelos de clasificación, especialmente en contextos con datos desbalanceados. Esta curva ilustra la relación entre la precisión y la exhaustividad (recall) del modelo a través de diferentes umbrales de decisión, permitiendo analizar la eficacia del modelo para identificar correctamente las clases positivas.

La precisión indica la proporción de verdaderos positivos entre todos los ejemplos predichos como positivos por el modelo, y se calcula mediante:

$$
\text{Precisión} = \frac{\text{Verdaderos Positivos (VP)}}{\text{Verdaderos Positivos (VP)} + \text{Falsos Positivos (FP)}}
$$

Por otro lado, la exhaustividad o recall representa la proporción de verdaderos positivos detectados sobre el total de positivos reales, y se define como:

$$
\text{Exhaustividad} = \frac{\text{Verdaderos Positivos (VP)}}{\text{Verdaderos Positivos (VP)} + \text{Falsos Negativos (FN)}}
$$

Al variar el umbral de probabilidad utilizado para decidir si una instancia pertenece a la clase positiva, obtenemos diferentes valores de precisión y recall. Al representar estos pares en un gráfico, se genera la Curva Precisión-Recall, la cual es especialmente útil en problemas donde la clase positiva es mucho menos frecuente que la negativa.

Mientras que la Curva ROC visualiza la relación entre la tasa de verdaderos positivos y la tasa de falsos positivos, la Curva Precisión-Recall se enfoca en la calidad de las predicciones positivas. En escenarios con alta desproporción entre clases, la precisión proporciona información más relevante que puede pasar desapercibida en una curva ROC.

A continuación, se presenta un ejemplo completo en Python que demuestra cómo calcular y visualizar la Curva Precisión-Recall utilizando Scikit-Learn:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import precision_recall_curve, average_precision_score
from sklearn.model_selection import train_test_split

# Cargar el conjunto de datos
datos = load_breast_cancer()
X = datos.data
y = datos.target

# Dividir los datos en conjuntos de entrenamiento y prueba
X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# Entrenar el modelo
modelo = RandomForestClassifier(random_state=42)
modelo.fit(X_entrenamiento, y_entrenamiento)

# Obtener las probabilidades de predicción para la clase positiva
probabilidades = modelo.predict_proba(X_prueba)[:, 1]

# Calcular la curva Precisión-Recall
precision, recall, umbrales = precision_recall_curve(y_prueba, probabilidades)

# Calcular el Área Bajo la Curva Precisión-Recall
ap_score = average_precision_score(y_prueba, probabilidades)

# Visualizar la curva Precisión-Recall
plt.figure()
plt.step(recall, precision, where='post', color='b', alpha=0.7)
plt.fill_between(recall, precision, step='post', alpha=0.3, color='b')

plt.xlabel('Exhaustividad (Recall)')
plt.ylabel('Precisión')
plt.title(f'Curva Precisión-Recall (AP = {ap_score:.2f})')
plt.ylim([0.0, 1.05])
plt.xlim([0.0, 1.0])
plt.grid(True)
plt.show()

En este código:

• Se utiliza el conjunto de datos Breast Cancer de Scikit-Learn, un problema clásico de clasificación binaria con datos desbalanceados.
• Se divide el conjunto de datos en entrenamiento y prueba utilizando train_test_split, manteniendo la proporción de clases con stratify=y.
• Se entrena un modelo de RandomForestClassifier sin necesidad de preprocesamiento adicional.
• Se obtienen las probabilidades de predicción de la clase positiva usando predict_proba.
• Se calcula la Curva Precisión-Recall con precision_recall_curve, obteniendo los valores de precisión, recall y los umbrales correspondientes.
• Se calcula el Área Bajo la Curva Precisión-Recall con average_precision_score, que resume el rendimiento del modelo en un solo valor.
• Se visualiza la curva utilizando Matplotlib, añadiendo etiquetas y una leyenda que muestra el valor del AP (Average Precision).

La gráfica resultante muestra cómo varía la precisión del modelo a medida que incrementa la exhaustividad. Un modelo ideal tendría alta precisión en todos los niveles de recall, acercándose a la esquina superior derecha del gráfico.

Es importante destacar que en problemas con datos desbalanceados, la Curva Precisión-Recall proporciona una evaluación más informativa del rendimiento del modelo que la Curva ROC. Esto se debe a que la precisión tiene en cuenta la proporción de falsos positivos, que puede ser significativa cuando la clase negativa domina el conjunto de datos.

Además, el Área Bajo la Curva Precisión-Recall (AP) es una métrica que resume la capacidad del modelo para lograr un equilibrio entre precisión y recall. Un AP cercano a 1 indica que el modelo mantiene una alta precisión a lo largo de diferentes niveles de exhaustividad.

En escenarios donde se necesita priorizar la detección de la clase positiva sin aumentar excesivamente los falsos positivos, la Curva Precisión-Recall es una herramienta esencial para seleccionar el umbral óptimo y evaluar el compromiso entre precisión y recall.

Por ejemplo, si en un contexto médico es crucial detectar todos los casos positivos (alto recall), podemos observar en la curva cómo afecta esto a la precisión y ajustar el umbral de decisión en consecuencia.

Finalmente, es posible comparar diferentes modelos o configuraciones utilizando la Curva Precisión-Recall y el valor de AP para determinar cuál ofrece el mejor rendimiento según las necesidades específicas del problema.

Implementación de métricas de clasificación en Scikit-Learn

La evaluación de modelos de clasificación es un paso crucial en el proceso de aprendizaje automático. Scikit-Learn ofrece una variedad de funciones para calcular métricas de rendimiento que ayudan a comprender y mejorar los modelos. A continuación, se explora cómo implementar estas métricas de manera efectiva.

La forma más sencilla de evaluar un modelo de clasificación es utilizando la exactitud (accuracy), que mide la proporción de predicciones correctas sobre el total de casos.

from sklearn.metrics import accuracy_score

# Ejemplo de etiquetas verdaderas y predichas
y_verdadero = [0, 1, 2, 2, 1]
y_predicho = [0, 2, 1, 2, 1]

# Calcular la exactitud
exactitud = accuracy_score(y_verdadero, y_predicho)
print(f"Exactitud: {exactitud:.2f}")

Sin embargo, en conjuntos de datos desbalanceados, la exactitud puede ser engañosa. Por ello, es importante utilizar métricas como la precisión, exhaustividad y puntaje F1-Score, que ofrecen una visión más detallada del rendimiento.

Para problemas de clasificación binaria o multiclase, Scikit-Learn permite ajustar el cálculo de estas métricas mediante el parámetro average.

from sklearn.metrics import precision_score, recall_score, f1_score

# Calcular métricas con promedio 'macro'
precision = precision_score(y_verdadero, y_predicho, average='macro')
recall = recall_score(y_verdadero, y_predicho, average='macro')
f1 = f1_score(y_verdadero, y_predicho, average='macro')

print(f"Precisión (macro): {precision:.2f}")
print(f"Exhaustividad (macro): {recall:.2f}")
print(f"Puntaje F1-Score (macro): {f1:.2f}")

Las opciones para el parámetro average incluyen:

• 'macro': Promedio no ponderado de las métricas por clase.
• 'weighted': Promedio ponderado por el número de muestras en cada clase.
• 'micro': Calcula métricas globales considerando todas las instancias.
• 'samples': Útil para problemas multietiqueta.

Es esencial seleccionar el método de promedio que mejor se adapte al problema, especialmente en casos de clases desbalanceadas.

Para obtener un informe completo del rendimiento del modelo, se puede utilizar classification_report, que resume las principales métricas por clase.

from sklearn.metrics import classification_report

# Generar el reporte de clasificación
reporte = classification_report(y_verdadero, y_predicho)
print(reporte)

Este reporte es de gran ayuda para identificar clases en las que el modelo necesita mejora.

En situaciones donde se desea visualizar el desempeño del modelo, la matriz de confusión es una herramienta eficaz. Scikit-Learn proporciona funciones para generar y visualizar esta matriz.

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
import matplotlib.pyplot as plt

# Calcular la matriz de confusión
matriz = confusion_matrix(y_verdadero, y_predicho)

# Visualizar la matriz de confusión
disp = ConfusionMatrixDisplay(confusion_matrix=matriz)
disp.plot(cmap=plt.cm.Blues)
plt.show()

La matriz de confusión ayuda a entender en qué clases el modelo está cometiendo más errores.

Para evaluar modelos durante la validación cruzada, se pueden utilizar las métricas como funciones de scoring.

from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier

# Cargar el conjunto de datos
datos = load_iris()
X = datos.data
y = datos.target

# Crear el modelo
modelo = DecisionTreeClassifier()

# Evaluar con validación cruzada utilizando precisión como métrica
scores = cross_val_score(modelo, X, y, cv=5, scoring='precision_macro')

print(f"Puntajes de precisión en validación cruzada: {scores}")
print(f"Precisión media: {scores.mean():.2f}")

Al ajustar el parámetro scoring, es posible evaluar el modelo según diferentes métricas, lo cual es particularmente útil para optimizar hiperparámetros.

En el caso de problemas con clases desbalanceadas, se pueden aplicar estrategias como ajustar los pesos de las clases o utilizar métricas específicas. Por ejemplo, para dar más importancia a la clase minoritaria:

from sklearn.utils.class_weight import compute_class_weight

# Calcular pesos de las clases
clases = np.unique(y)
pesos = compute_class_weight(class_weight='balanced', classes=clases, y=y)

# Crear el modelo con pesos de clases
modelo = DecisionTreeClassifier(class_weight=dict(zip(clases, pesos)))

Asignar pesos a las clases puede mejorar significativamente el rendimiento en la clase minoritaria.

Además de las métricas estándar, es posible definir métricas personalizadas para necesidades específicas. Scikit-Learn permite crear funciones de scoring propias utilizando make_scorer.

from sklearn.metrics import make_scorer

# Definir una métrica personalizada
def mi_metrica(y_verdadero, y_predicho):
    # Por ejemplo, calcular la tasa de falsos positivos
    fp = ((y_verdadero == 0) & (y_predicho == 1)).sum()
    total_negativos = (y_verdadero == 0).sum()
    return fp / total_negativos if total_negativos > 0 else 0

# Crear el scorer personalizado
mi_scorer = make_scorer(mi_metrica, greater_is_better=False)

# Evaluar el modelo con la métrica personalizada
scores = cross_val_score(modelo, X, y, cv=5, scoring=mi_scorer)

print(f"Puntajes de la métrica personalizada: {scores}")

Este enfoque permite adaptar la evaluación del modelo a criterios específicos del dominio.

En escenarios donde se necesita optimizar múltiples métricas, se puede utilizar GridSearchCV con varias métricas simultáneamente.

from sklearn.model_selection import GridSearchCV

# Definir la rejilla de parámetros
param_grid = {'max_depth': [2, 4, 6, 8]}

# Configurar GridSearchCV con varias métricas
grid_search = GridSearchCV(
    modelo, param_grid, scoring=['precision_macro', 'recall_macro'], refit='precision_macro', cv=5, return_train_score=True
)

grid_search.fit(X, y)

print(f"Mejor parámetro: {grid_search.best_params_}")
print(f"Mejor precisión: {grid_search.best_score_:.2f}")

Al establecer refit con la métrica principal, GridSearchCV ajustará el modelo final optimizando dicha métrica.

Para una evaluación más completa, se pueden calcular métricas adicionales como el Kappa de Cohen o la Métrica de Jaccard.

from sklearn.metrics import cohen_kappa_score, jaccard_score

# Calcular Kappa de Cohen
kappa = cohen_kappa_score(y_verdadero, y_predicho)
print(f"Kappa de Cohen: {kappa:.2f}")

# Calcular Métrica de Jaccard (para problemas binarios)
jaccard = jaccard_score(y_verdadero, y_predicho, average='macro')
print(f"Métrica de Jaccard: {jaccard:.2f}")

Estas métricas ofrecen perspectivas adicionales sobre la fiabilidad y la consistencia del modelo.

Finalmente, para problemas multietiqueta, Scikit-Learn proporciona soporte para calcular métricas adaptadas a este tipo de datos.

from sklearn.metrics import hamming_loss

# Ejemplo de datos multietiqueta
y_verdadero = [[1, 0, 1], [0, 1, 1], [1, 1, 0]]
y_predicho = [[1, 0, 0], [0, 1, 1], [1, 0, 0]]

# Calcular Hamming Loss
hamming = hamming_loss(y_verdadero, y_predicho)
print(f"Hamming Loss: {hamming:.2f}")

El Hamming Loss mide la fracción de etiquetas incorrectamente predichas, ofreciendo una medida adecuada para evaluar modelos multietiqueta.

Scikit-Learn ofrece una suite completa de herramientas para la implementación de métricas de clasificación, permitiendo ajustar la evaluación del modelo a las necesidades específicas y garantizando un análisis profundo de su rendimiento.