Conjuntos de Datos y Divisiones

Las divisiones de entrenamiento, validación y prueba definen lo que tu modelo ha visto durante el entrenamiento frente a lo que debe generalizar. Una división correcta es la base de una evaluación honesta.

Receta

Tarjeta de receta de referencia rápida, lista para copiar y pegar.

from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score
 
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
 
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X_train, y_train, cv=cv, scoring="f1_macro")

Cuándo usar esto:

• Al iniciar cualquier proyecto de aprendizaje supervisado antes de ajustar preprocesadores o modelos.
• Para comparar modelos de forma justa con validación cruzada solo en datos de entrenamiento.
• Para manejar clases desequilibradas con divisiones estratificadas.
• Para prevenir fugas cuando varias filas pertenecen al mismo usuario, sesión o ventana de tiempo.

Ejemplo de Trabajo

"""datasets_splits.py - flujo de trabajo de división sin fugas para clasificación tabular."""
from __future__ import annotations
 
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report
from sklearn.model_selection import StratifiedKFold, cross_val_score, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
 
# Cargar e inspeccionar
data = load_breast_cancer(as_frame=True)
X: pd.DataFrame = data.data
y: pd.Series = data.target
 
# 1) Reservar el conjunto de prueba final (nunca se usa durante la selección del modelo)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
 
# 2) Construir el pipeline - ajustar solo en los pliegues de entrenamiento dentro de CV
pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("clf", RandomForestClassifier(n_estimators=100, random_state=42)),
])
 
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
cv_scores = cross_val_score(pipe, X_train, y_train, cv=cv, scoring="f1")
print(f"CV F1: {cv_scores.mean():.3f} +/- {cv_scores.std():.3f}")
 
# 3) Ajuste final en todos los datos de entrenamiento, evaluar una vez en la prueba
pipe.fit(X_train, y_train)
print(classification_report(y_test, pipe.predict(X_test)))

Lo que esto demuestra:

• Un conjunto de prueba bloqueado evaluado solo después de que se completa la selección del modelo.
• Validación cruzada en datos de entrenamiento para estimaciones de rendimiento estables.
• Preprocesamiento dentro de un pipeline para que cada pliegue de CV ajuste el escalador de forma independiente.
• División estratificada para mantener el equilibrio de clases en los pliegues.

Inmersión Profunda

Cómo Funciona

• Conjunto de entrenamiento ajusta los parámetros del modelo y las estadísticas de preprocesamiento.
• Pliegues de validación/CV ajustan hiperparámetros y comparan arquitecturas sin tocar el conjunto de prueba.
• Conjunto de prueba proporciona una única estimación imparcial de la generalización después de que se toman todas las decisiones.
• Estratificación muestrea cada clase proporcionalmente en cada división, crucial para datos desequilibrados.
• Divisiones por grupos mantienen filas relacionadas (mismo paciente, usuario o día) en una sola partición.

Estrategias de División

Notas de Python

from sklearn.model_selection import TimeSeriesSplit, GroupKFold
 
# Series temporales: siempre entrenar con el pasado, probar con el futuro
tscv = TimeSeriesSplit(n_splits=5)
 
# Grupos: el mismo group_id nunca está en entrenamiento ni en prueba
gkf = GroupKFold(n_splits=5)
for train_idx, val_idx in gkf.split(X, y, groups=group_ids):
    ...

Trampas Comunes

• Preprocesamiento antes de la división - ajustar un escalador en todo el conjunto de datos filtra estadísticas de prueba en el entrenamiento. Solución: dividir primero, o envolver transformaciones en un Pipeline.
• Ajuste en el conjunto de prueba - ejecutar búsqueda en cuadrícula y elegir el mejor modelo usando puntuaciones de prueba infla las métricas. Solución: usar CV en datos de entrenamiento; evaluar al ganador una vez en la prueba.
• Ignorar el desequilibrio de clases - las divisiones aleatorias pueden dejar clases raras fuera de los pliegues de entrenamiento. Solución: usar stratify=y o estrategias de remuestreo.
• Barajar series temporales - las divisiones aleatorias mezclan datos futuros en el entrenamiento para problemas temporales. Solución: usar TimeSeriesSplit o divisiones basadas en corte.
• Entidades duplicadas entre divisiones - múltiples filas por usuario tanto en entrenamiento como en prueba inflan las puntuaciones. Solución: dividir por group_id, no por fila.
• Conjuntos de prueba pequeños - alta varianza en métricas con pocas muestras de prueba. Solución: aumentar el tamaño de la prueba o usar CV repetida e informar intervalos de confianza.

Alternativas

Preguntas Frecuentes

train_test_split(X, y, stratify=y)  # preserva las proporciones de clase en ambas particiones

train, test = train_test_split(df, test_size=0.2, stratify=df["label"])
X_train, y_train = train["features"], train["label"]

Relacionado

• Ingeniería de Características - codificación después de dividir
• Pipelines - preprocesamiento sin fugas dentro de CV
• Evaluación de Modelos - métricas en datos retenidos
• Datos Desequilibrados - divisiones estratificadas y remuestreadas
• Ajuste de Hiperparámetros - búsqueda dentro de pliegues de CV

Versiones de Stack: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, y uv 0.6+.