R Academy · Lección

Ingeniería de características con recipes

Defina pasos de preprocesamiento para normalización, codificación e imputación.

Lección 1 de 413 pasos

Ingeniería de características con recipes es una lección gratuita de R Academy en CoddyKit. Esta es la lección 1 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 una recipe?

En tidymodels, una recipe es un esquema para preprocesar los datos. Registra los pasos necesarios para transformar datos sin procesar en características listas para el modelo, sin aplicarlos inmediatamente.

La función clave es recipe(outcome ~ ., data = train), que define la fórmula y el conjunto de datos de referencia usado para estimar las estadísticas necesarias durante el preprocesamiento.

library(recipes)
library(tidymodels)

# Create a recipe using the training data
rec <- recipe(price ~ ., data = train_data)
print(rec)

step_normalize()

step_normalize(all_numeric_predictors()) centra cada predictor numérico en una media de 0 y lo escala a una desviación estándar de 1. Esto es esencial para algoritmos sensibles a la escala de las características, como la regresión logística, SVM o las redes neuronales.

La media y la desviación estándar se calculan a partir del conjunto de entrenamiento y se aplican de forma coherente a los datos de prueba mediante bake().

rec <- recipe(price ~ ., data = train_data) |>
  step_normalize(all_numeric_predictors())

# Check what steps are recorded
print(rec)

step_dummy()

step_dummy(all_nominal_predictors()) convierte las variables categóricas (factor/character) en columnas numéricas dummy (codificadas mediante one-hot). De forma predeterminada, crea k-1 columnas para un factor de k niveles, evitando la multicolinealidad perfecta.

Use one_hot = TRUE para modelos basados en árboles que se benefician de una codificación one-hot completa.

rec <- recipe(price ~ ., data = train_data) |>
  step_dummy(all_nominal_predictors())

# After prep and bake, factor columns become 0/1 numeric columns
prepped <- prep(rec)
baked <- bake(prepped, new_data = NULL)
names(baked)

step_impute_median()

Los valores ausentes provocan errores en la mayoría de los motores de modelos. step_impute_median(all_numeric_predictors()) reemplaza los valores NA por la mediana calculada a partir del conjunto de entrenamiento. La mediana es más resistente a los valores atípicos que la imputación mediante la media.

Para variables categóricas, use step_impute_mode() para rellenarlas con el valor más frecuente.

rec <- recipe(price ~ ., data = train_data) |>
  step_impute_median(all_numeric_predictors()) |>
  step_impute_mode(all_nominal_predictors())

print(rec)

step_zv() — Eliminar la varianza cero

step_zv(all_predictors()) elimina cualquier predictor que tenga un único valor distinto (varianza cero). Estas columnas no aportan información y pueden provocar errores en algunos motores de modelos.

Para una varianza cercana a cero, use step_nzv(all_predictors()), que también elimina las columnas en las que un valor predomina de forma abrumadora.

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

print(rec)

prep() — Entrenar la recipe

prep(recipe) estima todos los parámetros requeridos por los pasos —por ejemplo, la media y la desviación estándar para la normalización, o las medianas para la imputación— usando los datos de entrenamiento. El resultado es una recipe preparada que conoce todos los parámetros de transformación.

Prepare siempre la recipe únicamente con los datos de entrenamiento para evitar la fuga de datos del conjunto de prueba.

# Build the full recipe
rec <- recipe(price ~ ., data = train_data) |>
  step_impute_median(all_numeric_predictors()) |>
  step_dummy(all_nominal_predictors()) |>
  step_zv(all_predictors()) |>
  step_normalize(all_numeric_predictors())

# Estimate parameters from training data
prepped_rec <- prep(rec)
print(prepped_rec)

bake() — Aplicar a datos nuevos

bake(prepped_recipe, new_data = test_data) aplica todos los pasos de preprocesamiento usando los parámetros ya estimados a cualquier conjunto de datos. Esto garantiza que las transformaciones sean coherentes entre el entrenamiento y la prueba.

Pase new_data = NULL para aplicar la transformación a los datos de entrenamiento utilizados durante prep().

# Apply recipe to test data
baked_test <- bake(prepped_rec, new_data = test_data)
head(baked_test)

# Apply to training data (same as juice())
baked_train <- bake(prepped_rec, new_data = NULL)
dim(baked_train)

juice() — Extraer los datos de entrenamiento procesados

juice(prepped_recipe) es una función auxiliar equivalente a bake(prepped_recipe, new_data = NULL). Devuelve la versión preprocesada de los datos de entrenamiento utilizados durante prep().

Nota: juice() está ligeramente obsoleta en favor de bake(prep, new_data = NULL), pero la verá en código antiguo de tidymodels.

# juice() extracts the processed training data
train_processed <- juice(prepped_rec)
glimpse(train_processed)

# Equivalent modern approach
train_modern <- bake(prepped_rec, new_data = NULL)
identical(train_processed, train_modern)  # TRUE

Combinar varios pasos

Los pasos se aplican en el orden en que se añaden. Una recipe de producción habitual sigue este orden:

  1. Imputación (corregir primero los NA)
  2. Creación de características (interacciones, polinomios)
  3. Codificación dummy (convertir factores)
  4. Eliminación de la varianza cero
  5. Normalización (escalar al final)

Este orden es importante; por ejemplo, normalizar antes de la codificación dummy produciría resultados incorrectos.

full_rec <- recipe(sale_price ~ ., data = housing_train) |>
  step_impute_median(all_numeric_predictors()) |>
  step_impute_mode(all_nominal_predictors()) |>
  step_log(sale_price, base = 10) |>
  step_other(all_nominal_predictors(), threshold = 0.05) |>
  step_dummy(all_nominal_predictors()) |>
  step_zv(all_predictors()) |>
  step_normalize(all_numeric_predictors())

print(full_rec)

Inspeccionar los resultados de prep

Después de llamar a prep(), puede inspeccionar lo que hizo cada paso mediante tidy(prepped_rec). Cada paso tiene un identificador numérico, y puede examinarlo con tidy(prepped_rec, number = 1) para ver los parámetros estimados.

prepped_rec <- prep(full_rec)

# View all steps and their status
tidy(prepped_rec)

# Inspect normalization parameters (mean, sd per column)
tidy(prepped_rec, number = 5)  # step_normalize is step 5

Recipes en la práctica

Las recipes muestran todo su potencial cuando se combinan con workflows. En lugar de llamar manualmente a prep() y bake(), añada la recipe a un workflow y tidymodels gestionará prep/bake automáticamente durante fit() y predict().

Esto elimina una fuente habitual de errores: que el preprocesamiento se aplique de forma diferente durante el entrenamiento y la inferencia.

library(workflows)

# Recipe + model spec combined in a workflow
wf <- workflow() |>
  add_recipe(full_rec) |>
  add_model(linear_reg() |> set_engine('lm'))

# fit() internally calls prep() + bake() on training data
fitted_wf <- fit(wf, data = housing_train)

# predict() applies bake() to new data automatically
predictions <- predict(fitted_wf, new_data = housing_test)
head(predictions)

Comprobación rápida

¿Qué hace llamar a prep(recipe) en el marco de recipes de tidymodels?

Repaso de las recipes

Conclusiones clave de Ingeniería de características con Recipes:

  • recipe(outcome ~ ., data = train) define el esquema de preprocesamiento.
  • step_normalize(), step_dummy(), step_impute_median() y step_zv() son los pasos más utilizados.
  • prep() estima los parámetros únicamente a partir de los datos de entrenamiento; nunca a partir de los datos de prueba.
  • bake(prepped, new_data) aplica la recipe entrenada a cualquier conjunto de datos.
  • El orden de los pasos es importante: imputar → crear → codificar → eliminar → escalar.
  • En producción, encapsule la recipe en un workflow() para automatizar prep/bake durante fit y predict.
# Full pipeline in 6 lines
rec <- recipe(target ~ ., data = train) |>
  step_impute_median(all_numeric_predictors()) |>
  step_dummy(all_nominal_predictors()) |>
  step_zv(all_predictors()) |>
  step_normalize(all_numeric_predictors())

prepped <- prep(rec)
train_baked <- bake(prepped, new_data = NULL)
test_baked  <- bake(prepped, new_data = test)
Gratis para empezar

Aprende R con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
43
Lecciones
159

Preguntas frecuentes

¿La lección «Ingeniería de características con recipes» es gratis?

Sí — el texto completo de «Ingeniería de características con recipes» 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 «Ingeniería de características con recipes»?

Defina pasos de preprocesamiento para normalización, codificación e imputación. 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 1 de 4.

¿Cuánto tiempo toma la lección «Ingeniería de características con recipes»?

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