Evaluación de Modelos Scikit-learn

Introducción

Después de entrenar un modelo de aprendizaje automático, es crucial evaluar su rendimiento para comprender qué tan bien generaliza a datos nuevos y no vistos. Scikit-learn, una potente biblioteca de Python para el aprendizaje automático, proporciona un conjunto completo de herramientas para la evaluación de modelos en su módulo sklearn.metrics.

En este laboratorio, aprenderá a evaluar un modelo de clasificación utilizando algunas de las métricas más comunes. Utilizaremos un conjunto predefinido de etiquetas verdaderas y etiquetas predichas para centrarnos únicamente en el proceso de evaluación. Aprenderá a calcular:

• Puntuación de Precisión (Accuracy Score)
• Matriz de Confusión (Confusion Matrix)
• Puntuación de Precisión (Precision Score)
• Puntuación de Recuperación (Recall Score)
• Puntuación F1 (F1 Score)

Al final de este laboratorio, será competente en el uso de estas funciones fundamentales de scikit-learn para evaluar el rendimiento de sus modelos de clasificación.

Calcular la puntuación de exactitud (accuracy_score) usando accuracy_score de sklearn.metrics

En este paso, calcularemos la precisión de las predicciones de nuestro modelo. La precisión es una de las métricas de clasificación más sencillas. Mide la proporción de instancias predichas correctamente sobre el número total de instancias.

La función accuracy_score de sklearn.metrics calcula este valor. Toma como argumentos las etiquetas verdaderas y las etiquetas predichas.

Primero, abra el archivo evaluate.py desde el explorador de archivos de la izquierda. El archivo ya contiene las listas y_true y y_pred. Ahora, agregue el siguiente código al final del archivo para importar la función accuracy_score, calcular la precisión e imprimir el resultado.

from sklearn.metrics import accuracy_score

## Calculate accuracy
accuracy = accuracy_score(y_true, y_pred)

print(f"Accuracy: {accuracy}")

Su archivo evaluate.py completo debería verse ahora así:

## En este laboratorio, utilizaremos un conjunto predefinido de etiquetas verdaderas y predichas
## para comprender diferentes métricas de evaluación.

## y_true representa las etiquetas reales y de referencia para nuestros puntos de datos.
## Para una clasificación binaria, 0 podría significar 'negativo' y 1 podría significar 'positivo'.
y_true = [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]

## y_pred representa las etiquetas predichas por nuestro modelo de clasificación hipotético.
y_pred = [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]

print("Setup complete. True and predicted labels are defined in evaluate.py.")
print(f"True labels:    {y_true}")
print(f"Predicted labels: {y_pred}")

from sklearn.metrics import accuracy_score

## Calculate accuracy
accuracy = accuracy_score(y_true, y_pred)

print(f"Accuracy: {accuracy}")

Ahora, ejecutemos el script. Abra la terminal en su IDE y ejecute el siguiente comando:

python3 evaluate.py

Debería ver la siguiente salida, que incluye la puntuación de precisión. Una precisión de 0.8 significa que el 80% de las predicciones fueron correctas.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8

Generar la matriz de confusión con confusion_matrix de sklearn.metrics

En este paso, generaremos una matriz de confusión. Si bien la precisión proporciona un resumen rápido del rendimiento, puede ser engañosa, especialmente para conjuntos de datos desequilibrados. Una matriz de confusión proporciona un desglose más detallado del rendimiento de un clasificador al mostrar el número de predicciones correctas e incorrectas para cada clase.

La matriz es una tabla con cuatro combinaciones de valores predichos y reales:

• Verdaderos Negativos (TN): El modelo predijo correctamente la clase negativa.
• Falsos Positivos (FP): El modelo predijo incorrectamente la clase positiva.
• Falsos Negativos (FN): El modelo predijo incorrectamente la clase negativa.
• Verdaderos Positivos (TP): El modelo predijo correctamente la clase positiva.

Utilizaremos la función confusion_matrix de sklearn.metrics. Agregue el siguiente código al final de su archivo evaluate.py.

from sklearn.metrics import confusion_matrix

## Generate confusion matrix
cm = confusion_matrix(y_true, y_pred)

print("Confusion Matrix:")
print(cm)

Ahora, ejecute el script nuevamente desde la terminal:

python3 evaluate.py

La salida ahora incluirá la matriz de confusión.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]

Esta matriz nos dice:

• TN = 4 (Arriba a la izquierda)
• FP = 1 (Arriba a la derecha)
• FN = 1 (Abajo a la izquierda)
• TP = 4 (Abajo a la derecha)

Calcular la puntuación de precisión (precision_score) usando precision_score de sklearn.metrics

En este paso, calcularemos la puntuación de precisión. La precisión responde a la pregunta: "¿De todas las instancias que el modelo predijo como positivas, qué proporción fue realmente positiva?" Es una medida de la exactitud de un clasificador.

La precisión se calcula como: Precisión = Verdaderos Positivos / (Verdaderos Positivos + Falsos Positivos)

Una precisión baja indica un alto número de falsos positivos. Utilizaremos la función precision_score de sklearn.metrics.

Agregue el siguiente código al final de su archivo evaluate.py para calcular e imprimir la precisión.

from sklearn.metrics import precision_score

## Calculate precision
precision = precision_score(y_true, y_pred)

print(f"Precision: {precision}")

Ejecute el script desde la terminal:

python3 evaluate.py

Verá la puntuación de precisión añadida a la salida. Basándonos en nuestra matriz de confusión (TP=4, FP=1), la precisión es 4 / (4 + 1) = 0.8.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]
Precision: 0.8

Calcular la puntuación de recall (recall_score) usando recall_score de sklearn.metrics

En este paso, calcularemos la puntuación de recall. El recall, también conocido como sensibilidad o tasa de verdaderos positivos, responde a la pregunta: "¿De todas las instancias positivas reales, qué proporción identificó correctamente el modelo?" Es una medida de la completitud de un clasificador.

El recall se calcula como: Recall = Verdaderos Positivos / (Verdaderos Positivos + Falsos Negativos)

Un recall bajo indica un alto número de falsos negativos. Utilizaremos la función recall_score de sklearn.metrics.

Agregue el siguiente código al final de su archivo evaluate.py.

from sklearn.metrics import recall_score

## Calculate recall
recall = recall_score(y_true, y_pred)

print(f"Recall: {recall}")

Ejecute el script desde la terminal:

python3 evaluate.py

La salida ahora incluirá la puntuación de recall. Basándonos en nuestra matriz de confusión (TP=4, FN=1), el recall es 4 / (4 + 1) = 0.8.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]
Precision: 0.8
Recall: 0.8

Calcular la puntuación F1 (f1_score) usando f1_score de sklearn.metrics

En este paso final, calcularemos la puntuación F1. La puntuación F1 es la media armónica de la precisión y el recall. Busca encontrar un equilibrio entre ambas. Mientras que la precisión se enfoca en minimizar los falsos positivos y el recall en minimizar los falsos negativos, la puntuación F1 proporciona una métrica única que considera ambos.

La puntuación F1 se calcula como: Puntuación F1 = 2 * (Precisión * Recall) / (Precisión + Recall)

Es particularmente útil cuando se necesita un equilibrio entre precisión y recall y cuando existe una distribución de clases desigual. Utilizaremos la función f1_score de sklearn.metrics.

Agregue la última parte del código a su archivo evaluate.py.

from sklearn.metrics import f1_score

## Calculate F1 score
f1 = f1_score(y_true, y_pred)

print(f"F1 Score: {f1}")

Ejecute el script por última vez desde la terminal:

python3 evaluate.py

La salida final mostrará todas las métricas que hemos calculado. Con una precisión y un recall de 0.8, la puntuación F1 también será 0.8.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]
Precision: 0.8
Recall: 0.8
F1 Score: 0.8

Resumen

¡Felicitaciones por completar el laboratorio! Ha aprendido con éxito a evaluar un modelo de clasificación utilizando varias métricas clave de la biblioteca scikit-learn.

En este laboratorio, practicó:

• Calcular la exactitud (accuracy) con accuracy_score para obtener una idea general del rendimiento del modelo.
• Generar una matriz de confusión (confusion matrix) con confusion_matrix para obtener una vista detallada de los verdaderos/falsos positivos y negativos.
• Calcular la precisión (precision) con precision_score para medir la exactitud del modelo.
• Calcular el recall con recall_score para medir la completitud del modelo.
• Calcular la puntuación F1 (F1 score) con f1_score para encontrar un equilibrio entre precisión y recall.

Estas métricas son herramientas fundamentales para cualquier científico de datos o ingeniero de aprendizaje automático. Comprenderlas le permite diagnosticar mejor las fortalezas y debilidades de su modelo y elegir el modelo adecuado para su problema específico.