Evaluación de modelos

Un modelo no vale por lo que aprende, sino por lo que generaliza. Evaluar bien es diseñar un experimento honesto: separar los datos antes de tocar el modelo, elegir una métrica alineada con el coste real y reportar la incertidumbre.

Las tres particiones

La regla es simple: toda decisión que mire los datos de test contamina la estimación. Si ajustas el umbral, imputas valores, seleccionas features o comparas 50 modelos usando test, el número final deja de ser una estimación independiente.

Data leakage: el error más caro

La fuga de información ocurre cuando el modelo accede durante el entrenamiento a información que no tendría en producción. Ejemplos frecuentes:

• Estandarizar o imputar con todo el dataset antes de dividir.
• Incluir una variable que se calcula después del evento que quieres predecir (por ejemplo, «fecha de cancelación» para predecir cancelación).
• Duplicados entre train y test, o el mismo cliente en ambos conjuntos.
• En series temporales, mezclar futuro y pasado.

El tamaño de la partición

70/15/15 o 80/10/10 son valores razonables para datasets medianos. Con pocos datos, la validación cruzada aprovecha mejor la muestra. Con millones de filas, una partición fija grande es suficiente y más rápida. Lo importante no es el porcentaje exacto, sino que cada conjunto sea representativo y suficientemente grande para la métrica.

from sklearn.model_selection import train_test_split

# 1) Separar test desde el inicio y no tocarlo
X_temp, X_test, y_temp, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

# 2) Del resto, separar validación
X_train, X_val, y_train, y_val = train_test_split(
    X_temp, y_temp, test_size=0.25, stratify=y_temp, random_state=42
)

print(X_train.shape, X_val.shape, X_test.shape)

La exactitud resume todo en un número y por eso oculta lo importante. La matriz de confusión separa los cuatro tipos de acierto y error, y a partir de ella se construyen las métricas que sí responden a preguntas de negocio.

Los cuatro cuadrantes

Ejemplo numérico

¿Qué métrica elegir?

Un clasificador no solo devuelve una clase: devuelve una puntuación o probabilidad. Las curvas ROC y precision–recall evalúan la calidad de ese ranking en todos los umbrales posibles, no solo en uno.

Curva ROC

Representa la tasa de verdaderos positivos (recall) frente a la tasa de falsos positivos para todos los umbrales. El área bajo la curva (AUC) tiene una interpretación elegante: es la probabilidad de que un positivo aleatorio reciba una puntuación mayor que un negativo aleatorio.

Curva precision–recall

Con clases muy desbalanceadas, la curva ROC puede verse optimista porque el FPR se calcula sobre un número enorme de negativos. La curva PR se centra en los positivos y es más informativa cuando la clase positiva es rara. Su resumen habitual es el average precision (área bajo PR).

import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import (
    roc_curve, roc_auc_score,
    precision_recall_curve, average_precision_score
)

probs = modelo.predict_proba(X_test)[:, 1]

fpr, tpr, umbrales_roc = roc_curve(y_test, probs)
prec, rec, umbrales_pr = precision_recall_curve(y_test, probs)

print("ROC-AUC:", round(roc_auc_score(y_test, probs), 3))
print("Average precision:", round(average_precision_score(y_test, probs), 3))

fig, ax = plt.subplots(1, 2, figsize=(11, 4))
ax[0].plot(fpr, tpr, label=f"AUC={roc_auc_score(y_test, probs):.3f}")
ax[0].plot([0, 1], [0, 1], "--", color="gray")
ax[0].set(xlabel="FPR", ylabel="TPR", title="ROC")
ax[1].plot(rec, prec)
ax[1].set(xlabel="Recall", ylabel="Precisión", title="Precision–Recall")
plt.show()

# Elegir umbral por F1
f1 = 2 * prec * rec / (prec + rec + 1e-9)
mejor = np.argmax(f1)
print("umbral óptimo por F1:", umbrales_pr[mejor], "F1:", round(f1[mejor], 3))

En regresión, el error se mide en unidades de la salida. La elección entre MAE, RMSE y R² no es estética: cambia qué errores penalizas y cómo interpretas el resultado.

Cuándo usar cada una

Ejemplo de R²

Si la varianza total de $y$ es 100 y el error cuadrático medio del modelo es 25, entonces $R^2=1-25/100=0.75$: el modelo explica el 75% de la varianza. Un $R^2$ negativo en test significa que el modelo predice peor que la media del test, algo posible con sobreajuste o distribuciones distintas.

import numpy as np
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

mae = mean_absolute_error(y_test, y_pred)
rmse = mean_squared_error(y_test, y_pred) ** 0.5
r2 = r2_score(y_test, y_pred)

# MAPE con protección para valores cercanos a cero
mask = np.abs(y_test) > 1e-8
mape = np.mean(np.abs((y_test[mask] - y_pred[mask]) / y_test[mask])) * 100

print(f"MAE={mae:.2f}  RMSE={rmse:.2f}  R2={r2:.3f}  MAPE={mape:.1f}%")

Una sola partición puede darte suerte o mala suerte. La validación cruzada rota el conjunto de validación para que cada ejemplo se use como test una vez, produciendo una estimación más estable y una medida de variabilidad.

K-fold

1. Divide los datos en $k$ particiones de tamaño similar.
2. Entrena con $k-1$ y valida con la restante.
3. Repite $k$ veces, rotando la partición de validación.
4. Reporta la media y la desviación estándar de la métrica.

$k=5$ o $10$ son valores habituales. Con $k=n$ (leave-one-out) el sesgo es mínimo, pero la varianza y el coste son altos.

Variantes según la estructura de los datos

import numpy as np
from sklearn.model_selection import (
    StratifiedKFold, GroupKFold, TimeSeriesSplit, cross_val_score
)
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

modelo = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))

# Clasificación estratificada
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(modelo, X, y, cv=cv, scoring="f1")
print(f"F1 = {scores.mean():.3f} ± {scores.std():.3f}")

# Grupos: todos los registros de un paciente en el mismo fold
# cv = GroupKFold(n_splits=5)
# scores = cross_val_score(modelo, X, y, cv=cv, groups=paciente_id, scoring="roc_auc")

# Serie temporal: siempre entrena con el pasado
# cv = TimeSeriesSplit(n_splits=5)
# scores = cross_val_score(modelo, X, y, cv=cv, scoring="neg_mean_absolute_error")

Los hiperparámetros no se aprenden con gradiente: se eligen mediante búsqueda y validación. La diferencia entre un modelo mediocre y uno bueno a menudo está menos en el algoritmo que en una búsqueda bien diseñada.

Estrategias

from sklearn.model_selection import RandomizedSearchCV, StratifiedKFold
from sklearn.ensemble import RandomForestClassifier
from scipy.stats import loguniform, randint

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

busqueda = RandomizedSearchCV(
    RandomForestClassifier(random_state=42),
    param_distributions={
        "n_estimators": randint(100, 600),
        "max_depth": randint(3, 25),
        "min_samples_leaf": randint(1, 10),
        "max_features": ["sqrt", "log2", None],
        "class_weight": [None, "balanced"]
    },
    n_iter=40,
    scoring="f1",
    cv=cv,
    random_state=42,
    n_jobs=-1,
    verbose=1
)

busqueda.fit(X_train, y_train)
print("mejores parámetros:", busqueda.best_params_)
print("mejor F1 CV:", round(busqueda.best_score_, 3))

# Evaluación final única sobre test
from sklearn.metrics import classification_report
y_pred = busqueda.best_estimator_.predict(X_test)
print(classification_report(y_test, y_pred))

Buenas prácticas

• Define el espacio de búsqueda con conocimiento del algoritmo, no con números arbitrarios.
• Usa la misma semilla y el mismo esquema de validación para comparar modelos.
• Registra cada experimento: parámetros, métrica, tiempo y versión de datos.
• No busques sobre test. El test se evalúa una vez al final.
• Incluye una baseline simple en la comparación.

Un modelo puede ordenar bien y, aun así, dar probabilidades mal calibradas. Si usas la probabilidad para decidir cuánto riesgo asumir, necesitas que un 0.8 signifique realmente 80% de probabilidad.

Qué es calibración

Un clasificador está calibrado si, entre todos los ejemplos a los que asigna probabilidad $p$, la proporción de positivos es aproximadamente $p$. Se visualiza con un reliability diagram y se resume con el expected calibration error.

Métodos de calibración

• Platt scaling: ajusta una regresión logística sobre las puntuaciones del modelo usando un conjunto de calibración.
• Isotonic regression: ajusta una función monótona no paramétrica; flexible pero necesita más datos.
• Temperature scaling: divide los logits por una temperatura; muy usado en redes neuronales.

Umbral por coste

Si un falso positivo cuesta $c_{FP}$ y un falso negativo cuesta $c_{FN}$, el umbral óptimo no es 0.5. Para un clasificador calibrado, se predice positivo cuando el coste esperado de hacerlo es menor:

from sklearn.calibration import CalibratedClassifierCV, calibration_curve
from sklearn.metrics import brier_score_loss
import matplotlib.pyplot as plt

# El conjunto de calibración debe ser independiente del de entrenamiento
calibrado = CalibratedClassifierCV(base_modelo, method="isotonic", cv="prefit")
calibrado.fit(X_val, y_val)

probs = calibrado.predict_proba(X_test)[:, 1]
frac_pos, mean_pred = calibration_curve(y_test, probs, n_bins=10)
plt.plot(mean_pred, frac_pos, marker="o")
plt.plot([0, 1], [0, 1], "--", color="gray")
plt.xlabel("probabilidad predicha")
plt.ylabel("fracción de positivos")
plt.title("Diagrama de calibración")
plt.show()

print("Brier score:", round(brier_score_loss(y_test, probs), 4))

«El modelo A tiene 0.842 y el B 0.839» no es una comparación. La diferencia puede ser ruido de la partición. Comparar bien exige medir variabilidad, considerar el coste y evitar conclusiones que los datos no sostienen.

Qué reportar como mínimo

• Métrica principal y por qué se eligió.
• Baseline y su resultado.
• Media y desviación (o intervalo) entre folds o semillas.
• Tamaño y composición de train/validación/test.
• Hiperparámetros y procedimiento de selección.
• Coste computacional y latencia si es relevante.
• Limitaciones y riesgos conocidos.

Comparaciones pareadas

Cuando evalúas dos modelos sobre los mismos folds, las observaciones no son independientes. Una prueba de diferencias pareadas o un intervalo de confianza bootstrap sobre la diferencia es más informativo que comparar dos medias aisladas.

import numpy as np
from sklearn.model_selection import cross_val_score, RepeatedStratifiedKFold
from scipy import stats

cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=5, random_state=42)
a = cross_val_score(modelo_a, X, y, cv=cv, scoring="f1")
b = cross_val_score(modelo_b, X, y, cv=cv, scoring="f1")

dif = a - b
print(f"A: {a.mean():.3f} ± {a.std():.3f}")
print(f"B: {b.mean():.3f} ± {b.std():.3f}")
print(f"diferencia media: {dif.mean():.3f}")
print("IC 95% bootstrap:", np.percentile(
    [np.mean(np.random.choice(dif, len(dif), replace=True)) for _ in range(5000)],
    [2.5, 97.5]
))
print("t pareada:", stats.ttest_rel(a, b))