Remuestreo y validación cruzada con rsample
Evalúe modelos con validación cruzada de k particiones, bootstrap y remuestreo anidado.
Remuestreo y validación cruzada con rsample es una lección gratuita de R Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.
¿Por qué remuestrear?
Una sola división entre entrenamiento y prueba proporciona una estimación ruidosa del rendimiento del modelo: puede haber tenido suerte o mala suerte con las observaciones que terminaron en el conjunto de prueba. El remuestreo repite el proceso varias veces para obtener una estimación estable y fiable de cómo generaliza el modelo con datos nuevos.
library(rsample)
# Single split — performance estimate depends heavily
# on which 20% ended up as test data
split <- initial_split(mtcars, prop = 0.8)
train <- training(split)
test <- testing(split)
cat('Train:', nrow(train), '| Test:', nrow(test))initial_split()
initial_split(data, prop, strata) crea una única división aleatoria en conjuntos de entrenamiento y prueba. Use strata para estratificar por una columna, por ejemplo, la variable de respuesta, y garantizar que el equilibrio entre clases se mantenga en ambas particiones.
library(rsample)
# Stratified split by outcome variable
split <- initial_split(ames, prop = 0.8, strata = Sale_Price)
train <- training(split)
test <- testing(split)
cat('Train rows:', nrow(train))
cat('Test rows:', nrow(test))vfold_cv() — Validación cruzada de k pliegues
vfold_cv(data, v = 10) crea 10 pliegues. Los datos se dividen en 10 partes iguales; 9 se usan para entrenar y 1 para validar, alternando los pliegues. Esto proporciona 10 estimaciones de rendimiento que se promedian para obtener una métrica estable.
folds <- vfold_cv(housing_train, v = 10, strata = price)
# Each fold is a split object
print(folds)
# Inspect one fold
fold_1 <- folds$splits[[1]]
train_1 <- analysis(fold_1)
val_1 <- assessment(fold_1)
cat('Fold 1 — Train:', nrow(train_1), '| Val:', nrow(val_1))fit_resamples()
fit_resamples(workflow, resamples, metrics) ajusta el workflow en cada pliegue de entrenamiento y lo evalúa en el pliegue de validación, recopilando las métricas solicitadas. Devuelve un tibble de resultados que puede resumir con collect_metrics().
library(tune)
folds <- vfold_cv(housing_train, v = 10)
res <- fit_resamples(
wf, # your workflow
folds,
metrics = metric_set(rmse, rsq)
)
# Average metric across all 10 folds
collect_metrics(res)collect_metrics()
collect_metrics(resample_result) devuelve un tibble ordenado que resume el rendimiento del modelo en todos los pliegues. La columna mean contiene la métrica promedio y std_err es el error estándar, lo que permite hacerse una idea de la variabilidad de la estimación.
metrics_df <- collect_metrics(res)
print(metrics_df)
# .metric .estimator mean n std_err .config
# rmse standard 24500 10 1200 Preprocessor1_Model1
# rsq standard 0.882 10 0.012 Preprocessor1_Model1
# Pull a single metric
collect_metrics(res) |>
dplyr::filter(.metric == 'rmse') |>
dplyr::pull(mean)bootstraps() — Remuestreo bootstrap
bootstraps(data, times = 25) crea muestras bootstrap: cada muestra es una selección aleatoria con reemplazo del mismo tamaño que el conjunto de datos original. Las observaciones que no se seleccionan forman el conjunto de evaluación out-of-bag (OOB). El bootstrap presenta una mayor varianza que k-fold, pero funciona bien con conjuntos de datos pequeños.
boot_samples <- bootstraps(housing_train, times = 25, strata = price)
print(boot_samples)
# Average proportion of unique rows in each bootstrap
mean(sapply(boot_samples$splits, function(s) {
nrow(analysis(s)) / nrow(housing_train)
}))Validación cruzada de Monte Carlo
mc_cv(data, prop, times) crea times divisiones aleatorias, usando en cada una prop de los datos para el entrenamiento. A diferencia de k-fold, una misma observación puede aparecer varias veces en el conjunto de validación. Esto resulta útil cuando necesita más iteraciones de remuestreo de las que proporciona k-fold.
mc_splits <- mc_cv(housing_train, prop = 0.8, times = 20)
res_mc <- fit_resamples(
wf,
mc_splits,
metrics = metric_set(rmse, rsq)
)
collect_metrics(res_mc)tune_grid() — Búsqueda de hiperparámetros
Cuando el workflow contiene marcadores de posición tune(), use tune_grid(wf, resamples, grid) para buscar en una cuadrícula de valores de hiperparámetros. Cada combinación se evalúa en todos los pliegues y la mejor configuración se selecciona con select_best().
rf_spec <- rand_forest(mtry = tune(), trees = tune()) |>
set_engine('ranger') |>
set_mode('regression')
wf_tune <- workflow() |> add_recipe(rec) |> add_model(rf_spec)
grid <- grid_regular(mtry(range = c(2, 10)), trees(range = c(100, 500)), levels = 3)
tune_res <- tune_grid(wf_tune, resamples = folds, grid = grid)
collect_metrics(tune_res) |> head()select_best() y finalize_workflow()
Después del ajuste, select_best(tune_res, metric) elige la combinación de hiperparámetros con la mejor métrica promedio. finalize_workflow(wf, best_params) crea un workflow nuevo sustituyendo tune() por esos valores.
best_params <- select_best(tune_res, metric = 'rmse')
print(best_params)
# Substitute best values into the workflow
final_wf <- finalize_workflow(wf_tune, best_params)
# Fit on all training data, evaluate on test
final_fit <- last_fit(final_wf, split)
collect_metrics(final_fit)Validación cruzada anidada
Para obtener una evaluación verdaderamente imparcial cuando también ajusta hiperparámetros, use la validación cruzada anidada: un ciclo externo para estimar el rendimiento y un ciclo interno para ajustar el modelo. En rsample, cree un vfold_cv externo y ajuste el modelo dentro de cada pliegue externo usando los pliegues internos.
# Outer folds for unbiased evaluation
outer_folds <- vfold_cv(housing_train, v = 5)
# For each outer fold, tune on the inner training data
res_nested <- tune_grid(
wf_tune,
resamples = outer_folds,
grid = 10, # 10 random configurations
metrics = metric_set(rmse)
)
collect_metrics(res_nested)Comparación de estrategias de remuestreo
Cada estrategia de remuestreo presenta ventajas y desventajas. Elija según el tamaño de su conjunto de datos y su presupuesto computacional:
- k-fold (v=10): bajo sesgo y varianza moderada. Es la opción predeterminada para la mayoría de los problemas.
- Bootstrap: funciona con conjuntos de datos muy pequeños; presenta mayor varianza que k-fold.
- Validación cruzada de Monte Carlo: más flexible; adecuada para ajustar modelos con limitaciones de tiempo.
- k-fold repetido: menor varianza; úselo cuando pueda permitirse un mayor coste computacional.
# Repeated k-fold: 5-fold repeated 3 times = 15 models fitted
repeated_folds <- vfold_cv(housing_train, v = 5, repeats = 3)
res_rep <- fit_resamples(
wf,
repeated_folds,
metrics = metric_set(rmse, rsq)
)
collect_metrics(res_rep)Comprobación rápida
¿Qué devuelve collect_metrics() al aplicarlo a un resultado de fit_resamples()?
Resumen del remuestreo
Conceptos clave del remuestreo y la validación cruzada con rsample:
initial_split(data, prop, strata)crea una división estratificada entre entrenamiento y prueba.vfold_cv(data, v = 10)crea pliegues para la validación cruzada de k pliegues.bootstraps(data, times)crea muestras bootstrap para conjuntos de datos pequeños.fit_resamples(wf, folds, metrics)evalúa un workflow en todos los pliegues.collect_metrics()resume los resultados con la media y el error estándar.tune_grid()busca hiperparámetros;select_best()elige el mejor.finalize_workflow()+last_fit()completan el flujo desde el ajuste de hiperparámetros hasta la puesta en producción.
# Full rsample pipeline
split <- initial_split(data, prop = 0.8, strata = y)
train <- training(split)
folds <- vfold_cv(train, v = 10)
res <- fit_resamples(wf, folds, metrics = metric_set(rmse, rsq))
collect_metrics(res)
# After tuning
best <- select_best(tune_res, metric = 'rmse')
fin_wf <- finalize_workflow(wf_tune, best)
last_fit(fin_wf, split) |> collect_metrics()Preguntas frecuentes
¿La lección «Remuestreo y validación cruzada con rsample» es gratis?
Sí — el texto completo de «Remuestreo y validación cruzada con rsample» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Remuestreo y validación cruzada con rsample»?
Evalúe modelos con validación cruzada de k particiones, bootstrap y remuestreo anidado. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar R Academy?
No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Remuestreo y validación cruzada con rsample»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de R Academy?
Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Ingeniería de características con recipes
- Especificaciones de modelos con parsnip
- Flujos de trabajo: combinación de recipes y modelos
- Remuestreo y validación cruzada con rsample