Validación cruzada y selección de modelos

💡En simple: lee esto primero

Validación cruzada = turnarse para que cada parte de los datos sirva una vez de «examen», y así elegir bien la configuración del modelo.

Imagínalo así

Divides tus ejercicios de práctica en 5 grupos. Estudias con 4 y te tomas un mini-examen con el 5.º; repites cambiando cuál grupo es el examen. Tu nota real es el promedio de los 5 mini-exámenes.

Lo que tienes que llevarte

• Sirve para elegir cosas que el modelo no aprende solo: λ, el grado del polinomio, la profundidad del árbol…
• El conjunto de test no se toca hasta el final; si lo usas para decidir, tu nota final sale inflada.
• Data leakage (fuga): cuando información del examen se «cuela» en el estudio, p. ej. escalar los datos usando también el test.

Palabras raras de esta página

K-fold

partir los datos en K grupos y rotar cuál es el de prueba.

hiperparámetro

una configuración que eliges tú (no la aprende el modelo).

regla de 1 SE

entre modelos casi igual de buenos, quedarse con el más simple.

fuga de datos

hacer trampa sin querer: el modelo «ve» algo del examen antes de tiempo.

Más abajo viene la versión completa, con fórmulas. Si una palabra aparece subrayada con puntos, pasa el mouse (o tócala) para ver qué significa.

Todavía hay que elegir λ (o el grado)

Todo modelo tiene hiperparámetros: settings que eliges, no que se aprenden (λ de ridge/lasso, el grado, C y γ del SVM, el α de poda). Una sola partición train/validación es ruidosa: el «mejor λ» depende de qué puntos cayeron en validación, y con pocos datos cada punto separado es precioso.

K-fold, paso a paso

1. Parte los datos (de entrenamiento) en $K$ bloques iguales (típico $K=5$ o $10$).
2. Para cada $k$: entrena con los $K-1$ bloques restantes y valida en el bloque $k$.
3. Promedia los $K$ errores ⇒ un score para ese valor del hiperparámetro.
4. Repite sobre una grilla de valores (λ en escala log) y quédate con el mínimo.
5. Re-entrena con todos los datos de entrenamiento usando el valor elegido y evalúa una vez en el test.

$$\text{CV}(\lambda) = \frac1K\sum_{k=1}^K \text{Error}_k(\lambda),\qquad \lambda^\star = \arg\min_\lambda \text{CV}(\lambda)$$

Cada punto se usa para validar exactamente una vez: una estimación más honesta y de menor varianza del error de generalización.

Validación cruzada K-fold

Cada bloque se turna como validación; se entrena con los K−1 restantes y se promedian los K errores. El test set no participa: queda aparte y se usa una sola vez al final.

K (número de folds) 5

fold 1

fold 2

fold 3

fold 4

fold 5

test
(guardado)

entrenavalida (se rota)

---

Una sola partición es una lotería

Ridge con polinomio de grado 9 sobre 30 puntos. Las curvas finas son 8 particiones 50/50 al azar; la gruesa es el promedio 5-fold (la banda es ±1 error estándar).

Nuevos datos

una partición 50/50 (marca: su «mejor λ»)media 5-fold ± 1 SEregla de 1 SE

λ con mínimo CV10^-2.2

λ por regla 1-SE10^-1.6

Las marcas de las particiones individuales se esparcen varios órdenes de magnitud: el «mejor λ» depende de qué puntos cayeron en validación. Promediar folds da una curva suave y estable. Regla de 1 SE: entre los λ cuyo error está a menos de un error estándar del mínimo, toma el más fuerte (modelo más simple, gratis).

Pregunta del banco

«En K-fold, cada uno de los K bloques que se dejan fuera es un test set sobre el que se reporta el resultado final» → Falso. Son folds de validación: se usan para elegir el modelo. El test set queda fuera de toda la selección y se usa una sola vez al final.

La curva de CV y la regla de 1 SE

La curva CV vs λ tiene otra vez forma de U: poca penalización sobreajusta (izquierda), demasiada subajusta (derecha). Se grafica con ±1 error estándar entre folds.

Regla de 1 SE: entre todos los λ cuyo error CV está a menos de un SE del mínimo, elige el más fuerte (el modelo más simple). Las diferencias menores a un SE son ruido: obtienes un modelo más simple, estable e interpretable gratis. La misma regla se usa para podar árboles.

Data leakage: el pecado capital

Hay fuga cuando información de evaluación influye en el entrenamiento, y los scores salen optimistas. Formas típicas:

• Elegir hiperparámetros mirando el test.
• Estandarizar (o imputar, o seleccionar features) usando todo el dataset antes de partir. El escalador se ajusta solo con los folds de entrenamiento y luego se aplica a validación/test (en scikit-learn: Pipeline + GridSearchCV).
• Series de tiempo partidas al azar (hay que respetar el orden temporal).

Maldición del ganador

Si comparas muchos modelos en el mismo conjunto de validación, el ganador parece mejor de lo que es (incluso con datos de puro ruido). Por eso el test, visto una sola vez, da la nota honesta. Para evaluar el propio procedimiento de selección existe la CV anidada.

La maldición del ganador (y por qué el test se usa una vez)

Las etiquetas son puro ruido: ningún modelo puede superar 50% de verdad. Aun así, si pruebas muchos modelos y te quedas con el mejor en validación, su score de validación sale inflado. En el test nuevo vuelve a ~50%.

modelos (o hiperparámetros) probados 100tamaño del conjunto de validación 50Repetir experimento

accuracy de validación de cada modeloel «ganador» en validaciónel ganador en un test nuevo

mejor accuracy en validación66.0%

ese modelo en test nuevo51.6%

optimismo (sesgo de selección)+14.4 pts

Con 100 intentos y 50 puntos de validación, el mejor «acierta» 66% por pura suerte. Más intentos o menos datos de validación ⇒ más optimismo. Por eso: (1) el score que usaste para elegir no es una estimación honesta; (2) el test se reserva y se usa una sola vez; (3) K-fold reduce el ruido de la validación, y la CV anidada mide el procedimiento completo de selección.

🏆

Caso de uso · competencias de datosEl «primer lugar» que se cae en el ranking final

En competencias tipo Kaggle hay un leaderboard público (una parte del test) y uno privado (el resto, revelado al final). Equipos que envían cientos de variantes y se quedan con la que mejor puntúa en el público suelen caer muchos puestos en el privado: hicieron selección de modelos sobre el test público, exactamente la maldición del ganador del simulador de arriba. Los que eligen con una validación cruzada local sólida y miran poco el leaderboard suelen subir.

Otra fuga clásica: series de tiempo partidas al azar. Si el modelo de demanda entrena con datos de marzo y valida con febrero, «ve el futuro». Se usa una partición temporal (TimeSeriesSplit): siempre entrenar con el pasado y validar con lo que viene después.

Todo junto: el barrido de complejidad

Barriendo el grado de 0 a 18: el RMSE de entrenamiento no deja de bajar mientras el de validación traza la U; se elige el mínimo de validación (grado 8 en la slide). Es el trade-off sesgo–varianza resuelto con datos.

Ejercicio

Tienes 1000 ejemplos. Reservas 200 para test. Con los 800 restantes haces 5-fold CV para 10 valores de λ. ¿Cuántos modelos entrenas en total y con cuántos puntos cada uno?

Ver solución

• CV: $5 \text{ folds} \times 10 \text{ valores} = 50$ modelos, cada uno con $800\cdot\tfrac45 = 640$ puntos (validando en 160).
• Luego 1 modelo final con los 800 puntos y el λ elegido, evaluado una vez en los 200 de test.
• Total: 51 entrenamientos.

Autoevaluación

0/4 correctas · 0 respondidas Reiniciar

1. En K-fold, ¿cuántas veces se usa cada punto como validación?

a) 0b) 1c) $K-1$d) $K$

2. ¿Cuándo se ajusta el StandardScaler correctamente?

a) con todo el dataset antes de partirb) solo con los folds de entrenamiento, y se aplica a validaciónc) solo con el testd) no importa

3. La regla de 1 SE elige…

a) el λ con menor error de entrenamientob) el λ más fuerte dentro de 1 SE del mínimo de CVc) el λ más débild) el promedio de λ

4. ¿Por qué no basta una sola partición train/validación?

a) porque es más lentab) porque el mejor λ depende de qué puntos cayeron en validación (alta varianza)c) porque no permite testd) porque sobreajusta el test

En código: CV sin fugas

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import Ridge
from sklearn.model_selection import GridSearchCV, KFold, cross_val_score
import numpy as np

# el escalador vive DENTRO del pipeline: en cada fold se ajusta solo con train
pipe = make_pipeline(PolynomialFeatures(9), StandardScaler(), Ridge())
grid = GridSearchCV(pipe, {'ridge__alpha': np.logspace(-6, 2, 30)},
                    cv=KFold(5, shuffle=True, random_state=0),
                    scoring='neg_root_mean_squared_error')
grid.fit(X_tr, y_tr)                         # el test no aparece aquí
print(grid.best_params_, -grid.best_score_)
print('test:', -grid.score(X_test, y_test))  # una sola vez, al final

# CV anidada: estima qué tan bueno es TODO el procedimiento de selección
outer = cross_val_score(grid, X_tr, y_tr, cv=5)

↔ Conexiones con otros temas

C y γ del SVMSe eligen juntos con una grilla log y CV, nunca con accuracy de entrenamiento.α de podaLa ruta de poda da una lista corta de subárboles; CV elige uno (y la regla 1 SE).Train/val/testCV reemplaza el bloque de validación fijo por K bloques rotativos.La UCV es el instrumento que encuentra el fondo de la curva en U.

Para profundizar

interactivoMLU-Explain · Cross-ValidationK-fold, leave-one-out y por qué rotar el bloque de validación.docsscikit-learn · Cross-validationKFold, cross_val_score, GridSearchCV y el diagrama de partición.interactivoMLU-Explain · Train/Test/ValidationPara qué sirve cada partición y cómo se filtra información.

Fuente ·ML_Course_regularization_and_model_selection.pdf (slides 27–34) · ML_Course/session-03c-model-selection-cv.ipynb · ML_Course/session-01d-train-val-test.ipynb