Métricas de clasificación
Tema: Metodología y Datos · Catálogo de recetas · temario: Syllabus IOAI
📍 Dónde se aprende: módulo 04 de la Ruta de Aprendizaje.
Qué hace
Accuracy, precision, recall, F1 y la matriz de confusión, escritas a mano.
Cuándo usarla
Para validar localmente con la misma métrica que puntúa la tarea. Si la competencia mide F1 y tú optimizas accuracy, estás mejorando otra cosa.
Implementación
Necesita: numpy.
import numpy as np
def _validar_etiquetas(y_true, y_pred, n_clases):
y_true, y_pred = np.asarray(y_true), np.asarray(y_pred)
if (y_true.ndim != 1 or y_pred.ndim != 1 or
y_true.shape != y_pred.shape or y_true.size == 0):
raise ValueError("las etiquetas deben ser vectores 1-D no vacíos de igual longitud")
for y in (y_true, y_pred):
if (y.dtype.kind not in "biuf" or not np.all(np.isfinite(y)) or
np.any(y < 0) or np.any(y >= n_clases) or
np.any(y != np.floor(y))):
raise ValueError("las etiquetas deben ser enteros entre 0 y n_clases - 1")
return y_true.astype(np.int64), y_pred.astype(np.int64)
def matriz_confusion(y_true, y_pred, n_clases):
"""M[i, j] cuenta predicciones j para la clase real i.
Recibe vectores 1-D no vacíos de igual longitud, con etiquetas enteras
entre 0 y n_clases - 1. Rechaza matrices y probabilidades sin convertir.
"""
if (isinstance(n_clases, (bool, np.bool_)) or
not isinstance(n_clases, (int, np.integer)) or n_clases < 1):
raise ValueError("n_clases debe ser un entero positivo")
y_true, y_pred = _validar_etiquetas(y_true, y_pred, n_clases)
M = np.zeros((n_clases, n_clases), dtype=np.int64)
np.add.at(M, (y_true, y_pred), 1)
return M
def metricas_binarias(y_true, y_pred):
"""Accuracy, precision, recall y F1 para vectores 1-D de etiquetas 0/1.
Ambos vectores deben ser no vacíos y de igual longitud. Una columna
(n, 1) se rechaza: conviértela explícitamente con .ravel() si corresponde.
Convención ante el caso degenerado (denominador 0): la métrica vale 0.0.
Es la misma que usa scikit-learn con zero_division=0.
"""
y_true, y_pred = _validar_etiquetas(y_true, y_pred, 2)
vp = int(np.sum((y_pred == 1) & (y_true == 1)))
fp = int(np.sum((y_pred == 1) & (y_true == 0)))
fn = int(np.sum((y_pred == 0) & (y_true == 1)))
accuracy = float(np.mean(y_pred == y_true))
precision = vp / (vp + fp) if (vp + fp) else 0.0
recall = vp / (vp + fn) if (vp + fn) else 0.0
f1 = 2 * precision * recall / (precision + recall) if (precision + recall) else 0.0
return dict(accuracy=accuracy, precision=precision, recall=recall, f1=f1)⚠️ Notas
Con clases desbalanceadas la accuracy engaña sin disimulo: si el 99% es negativo, predecir siempre negativo da 0.99 y un recall de 0. Mira siempre la matriz de confusión antes de creerle a un número.
Ojo con la convención del caso degenerado: acá una métrica con denominador cero vale 0.0, igual que zero_division=0 en scikit-learn. Otras librerías devuelven 1.0 o nan.
🔗 Relacionadas
Verificada
Este código se ejecuta en cada publicación, contra una referencia obviamente correcta, en
herramientas/pruebas/datos.py. Si se rompe, el sitio no se actualiza.
Las otras puertas del vault: Ruta de Aprendizaje · Referencia · IOAI