0Pricing
R Academy · Lección

Flujos de trabajo: combinación de recipes y modelos

Agrupe el preprocesamiento y el modelo en un único objeto de flujo de trabajo.

Flujos de trabajo: combinación de recipes y modelos es una lección gratuita de R Academy en CoddyKit. Esta es la lección 3 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.

¿Qué es un workflow?

Un workflow reúne una receta y una especificación de modelo en un único objeto. Esto resuelve un problema fundamental: los pasos de preprocesamiento y modelado deben tratarse como una sola unidad durante la validación cruzada y el ajuste final; de lo contrario, parámetros como las medias de normalización pueden filtrarse desde los pliegues de prueba.

library(workflows)

# Start an empty workflow
wf <- workflow()
print(wf)

# Workflows have two slots: preprocessor and model
# Both must be filled before fitting

add_recipe() y add_model()

Use add_recipe(rec) para asociar un preprocesador de receta y add_model(spec) para asociar una especificación de modelo de parsnip. El operador pipe hace que esta combinación sea muy legible.

library(recipes)
library(parsnip)
library(workflows)

rec <- recipe(price ~ ., data = train) |>
  step_impute_median(all_numeric_predictors()) |>
  step_dummy(all_nominal_predictors()) |>
  step_normalize(all_numeric_predictors())

spec <- linear_reg() |> set_engine('lm')

wf <- workflow() |>
  add_recipe(rec) |>
  add_model(spec)

print(wf)

fit() en un workflow

Al llamar a fit(wf, data = train) sobre un workflow, se llama automáticamente a prep() en la receta usando los datos de entrenamiento y después se entrena el modelo con las características preprocesadas. Nunca necesita llamar manualmente a prep() ni a bake().

fitted_wf <- fit(wf, data = housing_train)

# The fitted workflow stores both the prepped recipe
# and the trained model
print(fitted_wf)

predict() en un workflow ajustado

Cuando llama a predict(fitted_wf, new_data = test), el workflow aplica automáticamente bake() a los datos nuevos usando la receta entrenada antes de generar las predicciones. Esto elimina el riesgo de olvidar preprocesar los datos de prueba.

# Predictions automatically preprocess the test data
preds <- predict(fitted_wf, new_data = housing_test)
head(preds)

# For classification
preds_prob <- predict(fitted_wf, new_data = test_df, type = 'prob')
preds_class <- predict(fitted_wf, new_data = test_df, type = 'class')

last_fit() — Entrenar con todos los datos y evaluar con los de prueba

last_fit(wf, split) toma su workflow final y el objeto inicial de división entre entrenamiento y prueba. Ajusta el workflow con la parte de entrenamiento y lo evalúa con la parte de prueba: el paso estándar para evaluar el modelo final una vez completado el ajuste de hiperparámetros.

library(rsample)

split <- initial_split(housing_data, prop = 0.8, strata = price)

# Fit on training, evaluate on test
final_res <- last_fit(wf, split)

# View performance on the held-out test set
collect_metrics(final_res)

extract_fit_parsnip()

extract_fit_parsnip(fitted_wf) extrae el objeto de modelo parsnip entrenado de un workflow ajustado. Después puede usarlo para inspeccionar coeficientes, importancia de variables o pasarlo a herramientas de explicación de modelos.

fitted_wf <- fit(wf, data = housing_train)

# Extract the parsnip model
parsnip_fit <- extract_fit_parsnip(fitted_wf)

# Now access the underlying model
tidy(parsnip_fit)      # coefficients for lm
vip::vip(parsnip_fit)  # variable importance plot

extract_recipe()

extract_recipe(fitted_wf) devuelve la receta preparada de un workflow ajustado. Esto resulta útil para inspeccionar qué transformaciones se aplicaron o para recuperar el preprocesamiento entrenado y aplicarlo de forma independiente a datos externos.

fitted_wf <- fit(wf, data = housing_train)

# Get the prepped recipe
prepped_rec <- extract_recipe(fitted_wf)

# Inspect normalization stats
tidy(prepped_rec, number = 3)  # step_normalize details

# Apply recipe to completely new external data
new_baked <- bake(prepped_rec, new_data = brand_new_df)

augment() en workflows

augment(fitted_wf, new_data) devuelve el data frame de entrada con las columnas de predicciones añadidas. En regresión agrega .pred; en clasificación agrega .pred_class y columnas de probabilidad para cada clase.

fitted_wf <- fit(wf, data = housing_train)

# Append predictions to the test data frame
results <- augment(fitted_wf, new_data = housing_test)

# Now compute metrics directly
library(yardstick)
results |>
  metrics(truth = price, estimate = .pred)

Actualizar un workflow

Puede actualizar componentes individuales de un workflow con update_recipe() o update_model() sin reconstruirlo desde cero. Esto resulta práctico durante la experimentación, cuando desea cambiar el motor del modelo y conservar la misma receta.

# Original workflow with lm
wf_lm <- workflow() |>
  add_recipe(rec) |>
  add_model(linear_reg() |> set_engine('lm'))

# Swap model to random forest, keep same recipe
wf_rf <- update_model(
  wf_lm,
  rand_forest(trees = 300) |>
    set_engine('ranger') |>
    set_mode('regression')
)

fit_rf <- fit(wf_rf, data = housing_train)

add_formula() frente a add_recipe()

Si no necesita una receta, puede usar add_formula(outcome ~ .) como preprocesador. Esto aplica transformaciones mínimas, únicamente la especificación de la fórmula. Use add_recipe() cuando necesite ingeniería de características; use add_formula() para modelos base rápidos.

# Simple baseline — no recipe needed
baseline_wf <- workflow() |>
  add_formula(price ~ sqft + bedrooms + bathrooms) |>
  add_model(linear_reg() |> set_engine('lm'))

baseline_fit <- fit(baseline_wf, data = housing_train)
baseline_preds <- predict(baseline_fit, new_data = housing_test)

# Compare RMSE to recipe-based model
yardstick::rmse_vec(housing_test$price, baseline_preds$.pred)

Conjuntos de workflows para comparar

workflow_set(), del paquete workflowsets, crea una colección de workflows que combina varias recetas y especificaciones de modelos. Después puede ajustar y evaluar todas las combinaciones a la vez con workflow_map().

library(workflowsets)

all_workflows <- workflow_set(
  preproc = list(basic = basic_rec, full = full_rec),
  models  = list(
    lm  = linear_reg() |> set_engine('lm'),
    rf  = rand_forest(trees = 200) |> set_engine('ranger') |> set_mode('regression')
  )
)

# Fit all 4 combinations on resamples
results <- workflow_map(all_workflows, 'fit_resamples', resamples = cv_folds)
autoplot(results)

Comprobación rápida

¿Cuál es la principal ventaja de usar last_fit(workflow, split) en lugar de ajustar y predecir manualmente?

Resumen de workflows

Conceptos clave de Workflows: combinación de recetas y modelos:

  • workflow() |> add_recipe(rec) |> add_model(spec) reúne el preprocesamiento y el modelado.
  • fit(wf, data = train) prepara la receta y entrena el modelo en una sola llamada.
  • predict(fitted_wf, new_data) aplica automáticamente bake() a los datos nuevos antes de predecir.
  • last_fit(wf, split) entrena con los datos de entrenamiento y evalúa con los de prueba; úselo para la evaluación final del modelo.
  • extract_fit_parsnip() y extract_recipe() recuperan componentes para inspeccionarlos.
  • augment() añade las predicciones al data frame para facilitar el cálculo de métricas.
  • workflow_set() compara simultáneamente varias combinaciones de recetas y modelos.
# Canonical tidymodels workflow pattern
split    <- initial_split(data, prop = 0.8)
train    <- training(split)
test     <- testing(split)

rec  <- recipe(y ~ ., data = train) |> step_normalize(all_numeric_predictors())
spec <- rand_forest(trees = 300) |> set_engine('ranger') |> set_mode('regression')

wf   <- workflow() |> add_recipe(rec) |> add_model(spec)

final_res <- last_fit(wf, split)
collect_metrics(final_res)

Preguntas frecuentes

¿La lección «Flujos de trabajo: combinación de recipes y modelos» es gratis?

Sí — el texto completo de «Flujos de trabajo: combinación de recipes y modelos» 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 «Flujos de trabajo: combinación de recipes y modelos»?

Agrupe el preprocesamiento y el modelo en un único objeto de flujo de trabajo. 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 3 de 4.

¿Cuánto tiempo toma la lección «Flujos de trabajo: combinación de recipes y modelos»?

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

  1. Ingeniería de características con recipes
  2. Especificaciones de modelos con parsnip
  3. Flujos de trabajo: combinación de recipes y modelos
  4. Remuestreo y validación cruzada con rsample
← Volver a R Academy