En el módulo 3 entrenamos nuestros primeros modelos y vimos que fit los ajusta a los datos. Pero ahí queda la pregunta que separa al aficionado del profesional: ¿el modelo sirve de verdad, o solo se memorizó las respuestas? Un modelo que acierta el 99% en los datos con los que aprendió puede ser inútil con datos nuevos. Este módulo, que cierra el bloque básico, es sobre medir bien: cómo saber si tu modelo va a funcionar en el mundo real, y qué métrica mirar según el problema.

La tesis del módulo

El accuracy de entrenamiento miente. Cualquier modelo puede memorizar los datos que ya vio; lo que importa es cómo se comporta con datos que nunca vio. Por eso se separan los datos, se vigila el overfitting y se elige la métrica correcta —porque con clases desbalanceadas, el accuracy es la métrica que más engaña.

Train/test split: por qué se parten los datos

Train/test split es dividir tus datos en dos: un set de entrenamiento (train) con el que el modelo aprende, y un set de prueba (test) que el modelo nunca ve durante el entrenamiento y que usas solo al final para evaluar. Es como estudiar con la guía y rendir con una prueba distinta: si te doy las mismas preguntas del ensayo, tu nota no dice nada sobre si aprendiste.

from sklearn.model_selection import train_test_split

# 80% para entrenar, 20% para evaluar. random_state fija el azar
# para que la división sea reproducible.
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

La regla es sagrada: el test se toca una sola vez, al final. Si ajustas el modelo mirando el test, el test deja de ser un examen honesto y se contamina.

Overfitting vs underfitting

Con train y test separados, aparecen los dos males clásicos:

Underfitting (subajuste): el modelo es demasiado simple y no captura ni siquiera el patrón del train. Anda mal en todo. Como estudiar poco: fallas en la guía y en la prueba.
Overfitting (sobreajuste): el modelo es tan flexible que memoriza el train, incluido el ruido. Anda perfecto en train y pésimo en test. Como memorizar las respuestas de la guía sin entender: brillas en el ensayo, te hundes en la prueba real.

El punto justo está en el medio: un modelo que aprende el patrón general sin obsesionarse con cada ejemplo.

 error
   │╲                                    ╱
   │ ╲          test (validación)      ╱
   │  ╲                              ╱
   │   ╲__                        _╱
   │      ╲___              ___╱
   │          ╲________╱          ◄── punto justo
   │              train (baja siempre)
   │      ________________________
   └──────────────────────────────►  complejidad
     underfit      OK        overfit

Este dibujo es el trade-off sesgo-varianza en simple: un modelo muy simple tiene mucho sesgo (se equivoca parejo por no captar el patrón); uno muy complejo tiene mucha varianza (cambia demasiado con cada dato y memoriza ruido). Bajar uno sube el otro; el arte es equilibrarlos.

Ojo: la señal de alarma del overfitting es un accuracy altísimo en train y mucho más bajo en test. Si ves esa brecha, tu modelo memorizó en vez de aprender. Los módulos 6, 7 y 9 dan herramientas para combatirlo.

La matriz de confusión

Para clasificación, casi todas las métricas nacen de una tabla de 2×2 que cruza lo que el modelo predijo contra lo que era verdad. Se llama matriz de confusión:

                    PREDICHO
                 positivo  negativo
              ┌──────────┬──────────┐
     positivo │    TP    │    FN    │
 REAL         ├──────────┼──────────┤
     negativo │    FP    │    TN    │
              └──────────┴──────────┘

 TP: acertó el positivo    FN: se le escapó un positivo
 FP: falsa alarma          TN: acertó el negativo

TP (verdadero positivo): era fraude y dijo fraude. Bien.
TN (verdadero negativo): era normal y dijo normal. Bien.
FP (falso positivo): era normal y gritó fraude. Falsa alarma.
FN (falso negativo): era fraude y dijo normal. El que se escapa.

Los dos tipos de error, FP y FN, no cuestan lo mismo, y de ahí salen las métricas.

Las métricas de clasificación

Accuracy (exactitud): de todo, cuánto acertó. (TP+TN) / total. Intuitiva, pero traicionera (ya viene).
Precision (precisión): de lo que marqué como positivo, cuánto lo era de verdad. TP / (TP+FP). Alta precision = pocas falsas alarmas.
Recall (sensibilidad): de todos los positivos reales, cuántos pesqué. TP / (TP+FN). Alto recall = se me escapan pocos.
F1: el promedio balanceado entre precision y recall. Útil cuando te importan los dos.
ROC-AUC: mide qué tan bien el modelo ordena los casos por probabilidad, a través de todos los umbrales. 0,5 es azar; 1,0 es perfecto.

Por qué el accuracy engaña

Imagina detección de fraude, donde solo el 1% de las transacciones son fraude. Un modelo tramposo que dice “nunca hay fraude” acierta el 99% de las veces. ¡99% de accuracy! Y es completamente inútil: no pesca ni un solo fraude. Su recall es 0.

Por eso, con clases desbalanceadas (una clase mucho más rara que la otra), el accuracy miente. Ahí mandan precision, recall y F1, que sí miran los positivos raros.

Métrica	Qué responde	Cuándo la eliges
Accuracy	¿Cuánto acerté en total?	Clases balanceadas, errores simétricos
Precision	De lo que marqué, ¿cuánto era?	Falsa alarma cuesta caro (marcar spam)
Recall	De los positivos, ¿cuántos pesqué?	Escaparse cuesta caro (cáncer, fraude)
F1	¿Balance precision/recall?	Clases desbalanceadas, ambos importan
ROC-AUC	¿Ordena bien por probabilidad?	Comparar modelos, umbral flexible

Ojo: precision y recall tiran para lados opuestos. Bajar el umbral para pescar más positivos sube el recall pero mete falsas alarmas (baja precision). El umbral correcto depende de qué error duele más en tu negocio, no de una fórmula.

Las métricas de regresión

Cuando predices un número (módulo 3), la matriz de confusión no aplica. Ahí mides cuánto te alejaste del valor real:

MAE (Mean Absolute Error): el error promedio en las mismas unidades del dato. Si predices precios en pesos, el MAE está en pesos. Fácil de explicar.
RMSE (Root Mean Squared Error): parecido, pero castiga más los errores grandes (los eleva al cuadrado). Úsalo cuando un error grande es mucho peor que varios chicos.
R² (coeficiente de determinación): qué fracción de la variación de los datos explica el modelo. 1 es perfecto; 0 es no explicar nada mejor que predecir el promedio.

Todo en código

scikit-learn trae cada métrica lista. El patrón es siempre metrica(y_real, y_predicho):

from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    roc_auc_score, confusion_matrix, classification_report,
    mean_absolute_error, mean_squared_error, r2_score,
)
import numpy as np

# --- Clasificación ---
pred = modelo.predict(X_test)
proba = modelo.predict_proba(X_test)[:, 1]   # prob de la clase positiva

print(accuracy_score(y_test, pred))
print(precision_score(y_test, pred))
print(recall_score(y_test, pred))
print(f1_score(y_test, pred))
print(roc_auc_score(y_test, proba))          # ROC-AUC usa la probabilidad
print(confusion_matrix(y_test, pred))        # la matriz TP/FP/FN/TN
print(classification_report(y_test, pred))   # todo junto, resumido

# --- Regresión ---
pred_reg = modelo_reg.predict(X_test)
print(mean_absolute_error(y_test, pred_reg))            # MAE
print(np.sqrt(mean_squared_error(y_test, pred_reg)))    # RMSE
print(r2_score(y_test, pred_reg))                       # R²

Dos detalles: roc_auc_score recibe la probabilidad (predict_proba), no la etiqueta, porque mide el ordenamiento. Y classification_report es el atajo perfecto: imprime precision, recall y F1 por clase de una sola vez.

Errores comunes

Reportar el accuracy de entrenamiento. Es casi siempre optimista y no dice nada sobre datos nuevos. Reporta métricas del test.
Usar accuracy con clases desbalanceadas. Con fraude al 1%, “nunca hay fraude” da 99% de accuracy y es inútil. Mira recall y F1.
Tocar el test más de una vez. En cuanto ajustas el modelo mirando el test, dejó de ser un examen honesto. Para eso está la validación (módulo 9).
Confundir precision con recall. Precision es de lo que marqué; recall es de lo que existía. Elegir mal optimiza el error equivocado.
Elegir la métrica sin pensar en el costo del error. ¿Duele más una falsa alarma o un caso que se escapa? Esa pregunta de negocio decide la métrica, no la costumbre.

La frase para llevarse

“El accuracy de entrenamiento miente; lo que importa es el test. Y con clases desbalanceadas, el accuracy es justamente la métrica que más engaña —ahí mandan precision y recall.”

Qué viene

Con esto cierras el bloque básico: ya sabes qué es ML, cómo mirar los datos, cómo entrenar los modelos base y —lo más importante— cómo evaluarlos sin engañarte. El módulo 5 abre el bloque intermedio con los árboles de decisión: modelos que aprenden reglas del tipo “si… entonces…”, más flexibles que la regresión y la base de los dos algoritmos que más ganan competencias, el random forest y el gradient boosting.

Machine Learning — Módulo 4: evaluar un modelo — las métricas que importan