R Academy · Lección

Especificaciones de modelos con parsnip

Especifique tipos de modelos y motores independientemente del paso de entrenamiento.

Especificaciones de modelos con parsnip es una lección gratuita de R Academy en CoddyKit. Esta es la lección 2 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 parsnip?

parsnip proporciona una interfaz unificada para cientos de motores de modelos. En lugar de aprender la sintaxis específica de cada paquete (glm(), randomForest(), e1071::svm()), escriba una única especificación coherente e indique a parsnip qué motor debe usar internamente.

Esto permite cambiar de motor —por ejemplo, de glm a stan para una regresión logística bayesiana— modificando un solo argumento.

library(parsnip)

# The same interface, different engines
logistic_reg() |> set_engine('glm')    # base R
logistic_reg() |> set_engine('glmnet') # regularized
logistic_reg() |> set_engine('stan')   # Bayesian

logistic_reg() para clasificación

logistic_reg() especifica un modelo de regresión logística para clasificación binaria. Encadene set_engine('glm') para usar el motor GLM integrado de R y set_mode('classification') para declarar explícitamente el tipo de tarea.

El modo ('classification' o 'regression') es obligatorio para los tipos de modelos compatibles con ambos.

log_spec <- logistic_reg() |>
  set_engine('glm') |>
  set_mode('classification')

print(log_spec)
# Logistic Regression Model Specification (classification)
# Computational engine: glm

rand_forest() con tune()

rand_forest() especifica un random forest. Los parámetros como mtry (número de características por división) y trees pueden fijarse o establecerse en tune() como marcadores para buscar hiperparámetros.

Cuando se pasa tune(), tidymodels busca en una cuadrícula de valores durante el ajuste mediante validación cruzada.

rf_spec <- rand_forest(
  mtry  = tune(),
  trees = 500,
  min_n = tune()
) |>
  set_engine('ranger', importance = 'impurity') |>
  set_mode('classification')

print(rf_spec)

linear_reg() para regresión

linear_reg() especifica un modelo de regresión lineal. Usar set_engine('lm') aplica mínimos cuadrados ordinarios, mientras que set_engine('glmnet') habilita la regularización L1/L2 mediante los parámetros penalty y mixture.

# OLS linear regression
lm_spec <- linear_reg() |>
  set_engine('lm')

# Ridge regression (penalty > 0, mixture = 0)
ridge_spec <- linear_reg(penalty = 0.01, mixture = 0) |>
  set_engine('glmnet')

# Lasso (penalty > 0, mixture = 1)
lasso_spec <- linear_reg(penalty = tune(), mixture = 1) |>
  set_engine('glmnet')

boost_tree() — Boosting de gradiente

boost_tree() especifica un modelo de árbol con boosting de gradiente. Puede seleccionar los motores xgboost, lightgbm o C5.0. Entre los parámetros ajustables se incluyen tree_depth, learn_rate y loss_reduction.

xgb_spec <- boost_tree(
  trees      = 500,
  tree_depth = tune(),
  learn_rate = tune(),
  loss_reduction = tune()
) |>
  set_engine('xgboost') |>
  set_mode('classification')

print(xgb_spec)

fit() — Entrenar el modelo

fit(spec, formula, data) entrena la especificación del modelo con datos reales. Internamente, parsnip traduce la especificación a la llamada adecuada del motor. El resultado es un objeto de modelo parsnip ajustado.

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

# Fit the model on training data
lm_fit <- fit(lm_spec, mpg ~ wt + hp + cyl, data = mtcars)

# The fitted object wraps the engine result
print(lm_fit)

# Access the underlying lm object
extract_fit_engine(lm_fit)

fit_xy() — Interfaz de matrices

fit_xy(spec, x, y) es una alternativa a fit(spec, formula, data). Acepta directamente una matriz de predictores x y un vector de respuesta y, lo que resulta útil cuando los datos ya están preprocesados como una matriz numérica, algo habitual con redes neuronales o XGBoost.

x_train <- train_baked |> select(-price)
y_train <- train_baked$price

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

# Matrix-style fit
lm_fit_xy <- fit_xy(lm_spec, x = x_train, y = y_train)

print(lm_fit_xy)

translate() — Ver el código del motor

translate(spec) muestra exactamente qué llamará parsnip internamente para un motor determinado. Esto resulta muy útil para depurar o comprender cómo se asigna una especificación de parsnip a la interfaz nativa del motor.

rf_spec <- rand_forest(mtry = 3, trees = 500) |>
  set_engine('ranger') |>
  set_mode('classification')

# See what ranger() call will be generated
translate(rf_spec)

# ranger::ranger(formula = ..., data = ...,
#   num.trees = 500, mtry = 3, ...)

predict() con parsnip

Todos los modelos ajustados de parsnip comparten la misma interfaz predict(). En clasificación, type = 'class' devuelve la clase predicha y type = 'prob' devuelve las probabilidades de cada clase. Esta coherencia es una de las principales ventajas de parsnip.

log_fit <- fit(logistic_reg() |> set_engine('glm') |> set_mode('classification'),
               species ~ ., data = train_df)

# Predicted classes
predict(log_fit, new_data = test_df, type = 'class')

# Predicted probabilities
predict(log_fit, new_data = test_df, type = 'prob')

augment() — Predicciones añadidas a los datos

augment(fitted_model, new_data) añade directamente las columnas de predicciones al data frame de entrada. Esto resulta práctico para la evaluación: el resultado contiene los valores reales y las predicciones uno junto al otro, listos para calcular métricas.

log_fit <- fit(
  logistic_reg() |> set_engine('glm') |> set_mode('classification'),
  species ~ ., data = train_df
)

# Get predictions joined to test data
results <- augment(log_fit, new_data = test_df)
head(results[, c('species', '.pred_class', '.pred_setosa')])

Comparación de especificaciones de modelos

Una de las principales ventajas de parsnip es la rapidez para comparar modelos. Puede definir varias especificaciones, ajustarlas todas con los mismos datos y comparar sus métricas. Como la interfaz es idéntica, para cambiar de modelo solo debe modificar la definición de la especificación.

specs <- list(
  lm    = linear_reg() |> set_engine('lm'),
  ridge = linear_reg(penalty = 0.01, mixture = 0) |> set_engine('glmnet'),
  rf    = rand_forest(trees = 200) |> set_engine('ranger') |> set_mode('regression')
)

fits <- lapply(specs, fit, mpg ~ ., data = train_mtcars)

preds <- lapply(fits, predict, new_data = test_mtcars)

rmse_vals <- sapply(preds, function(p) {
  sqrt(mean((p$.pred - test_mtcars$mpg)^2))
})
print(rmse_vals)

Comprobación rápida

En parsnip, ¿qué devuelve translate(spec)?

Resumen de parsnip

Conceptos clave de Especificaciones de modelos con parsnip:

parsnip proporciona una interfaz unificada: permite especificar por separado el tipo de modelo, el motor y el modo.
set_engine() selecciona el paquete subyacente; set_mode() selecciona clasificación o regresión.
Use tune() como marcador de posición para los hiperparámetros que se buscarán posteriormente.
fit(spec, formula, data) entrena el modelo; fit_xy(spec, x, y) acepta matrices.
predict(fit, new_data, type) mantiene una interfaz coherente en todos los motores.
translate(spec) muestra la llamada al motor para facilitar la depuración.
augment(fit, new_data) añade las predicciones al data frame.

# Parsnip model comparison template
spec <- rand_forest(trees = 500, mtry = tune()) |>
  set_engine('ranger', importance = 'impurity') |>
  set_mode('classification')

print(translate(spec))

# When mtry is fixed:
spec_fixed <- rand_forest(trees = 500, mtry = 5) |>
  set_engine('ranger') |>
  set_mode('classification')
fit_fixed <- fit(spec_fixed, label ~ ., data = train_df)

Preguntas frecuentes

¿La lección «Especificaciones de modelos con parsnip» es gratis?

Sí — el texto completo de «Especificaciones de modelos con parsnip» 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 «Especificaciones de modelos con parsnip»?

Especifique tipos de modelos y motores independientemente del paso de entrenamiento. 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 2 de 4.

¿Cuánto tiempo toma la lección «Especificaciones de modelos con parsnip»?

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

← Volver a R Academy