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