R Academy · Aula

Especificações de modelos com parsnip

Especifique tipos de modelos e mecanismos independentemente da etapa de treinamento.

Especificações de modelos com parsnip é uma aula grátis de R Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

O que é parsnip?

parsnip fornece uma interface unificada para centenas de mecanismos de modelo. Em vez de aprender a sintaxe específica de cada pacote (glm(), randomForest(), e1071::svm()), você escreve uma única especificação consistente e informa ao parsnip qual mecanismo usar por baixo.

Isso significa que você pode trocar de mecanismo — por exemplo, de glm para stan na regressão logística bayesiana — alterando um único 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 classificação

logistic_reg() especifica um modelo de regressão logística para classificação binária. Encadeie set_engine('glm') para usar o mecanismo GLM integrado ao R e set_mode('classification') para declarar explicitamente o tipo de tarefa.

O modo ('classification' ou 'regression') é obrigatório para tipos de modelo que aceitam ambos.

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

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

rand_forest() com tune()

rand_forest() especifica uma floresta aleatória. Parâmetros como mtry (número de características por divisão) e trees podem ser fixados ou definidos como tune(), que funciona como um marcador para a busca de hiperparâmetros.

Quando você passa tune(), o tidymodels pesquisa uma grade de valores durante o ajuste por validação 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 regressão

linear_reg() especifica um modelo de regressão linear. Usar set_engine('lm') aplica mínimos quadrados ordinários, enquanto set_engine('glmnet') habilita a regularização L1/L2 por meio dos parâmetros de penalidade e mistura.

# 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 por gradiente

boost_tree() especifica um modelo de árvore com boosting por gradiente. Você pode direcioná-lo para o mecanismo xgboost, lightgbm ou C5.0. Entre os parâmetros ajustáveis estão tree_depth, learn_rate e 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() — Treinar o modelo

fit(spec, formula, data) treina a especificação do modelo com dados reais. Internamente, parsnip traduz a especificação na chamada apropriada do mecanismo. O resultado é um 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() — Interface de matriz

fit_xy(spec, x, y) é uma alternativa a fit(spec, formula, data). Ele aceita diretamente uma matriz de preditores x e um vetor de resposta y, o que é útil quando seus dados já foram pré-processados em uma matriz numérica, algo comum em redes neurais ou no 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 o código do mecanismo

translate(spec) mostra exatamente o que parsnip chamará internamente para um determinado mecanismo. Isso é extremamente útil para depurar ou entender como sua especificação parsnip é mapeada para a interface nativa do mecanismo.

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() com parsnip

Todos os modelos parsnip ajustados compartilham a mesma interface predict(). Para classificação, type = 'class' retorna a classe prevista, e type = 'prob' retorna as probabilidades das classes. Essa consistência é uma das principais vantagens do 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() — Previsões vinculadas aos dados

augment(fitted_model, new_data) acrescenta colunas de previsão diretamente ao quadro de dados de entrada. Isso é conveniente para a avaliação: o resultado contém os valores reais e as previsões lado a lado, prontos para o cálculo das 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')])

Comparando especificações de modelos

Um dos principais benefícios do parsnip é a comparação rápida de modelos. Você define várias especificações, ajusta todas aos mesmos dados e compara as métricas. Como a interface é idêntica, trocar de modelo exige apenas alterar a definição da especificação.

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)

Verificação rápida

No parsnip, o que translate(spec) retorna?

Recapitulação do parsnip

Principais conclusões sobre as especificações de modelos com parsnip:

parsnip fornece uma interface unificada: especifique separadamente o tipo de modelo, o mecanismo e o modo.
set_engine() seleciona o pacote subjacente; set_mode() seleciona classificação ou regressão.
Use tune() como marcador para hiperparâmetros que serão pesquisados posteriormente.
fit(spec, formula, data) treina o modelo; fit_xy(spec, x, y) aceita matrizes.
predict(fit, new_data, type) é consistente em todos os mecanismos.
translate(spec) mostra a chamada do mecanismo para depuração.
augment(fit, new_data) acrescenta as previsões ao quadro de dados.

# 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)

Perguntas Frequentes

A aula “Especificações de modelos com parsnip” é grátis?

Sim — o texto completo de “Especificações de modelos com parsnip” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Especificações de modelos com parsnip”?

Especifique tipos de modelos e mecanismos independentemente da etapa de treinamento. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Especificações de modelos com parsnip”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Engenharia de atributos com recipes
Especificações de modelos com parsnip
Fluxos de trabalho: combinando receitas e modelos
Reamostragem e validação cruzada com rsample

← Voltar para R Academy