0Pricing
R Academy · Aula

Fluxos de trabalho: combinando receitas e modelos

Agrupe o pré-processamento e o modelo em um único objeto de fluxo de trabalho.

Fluxos de trabalho: combinando receitas e modelos é uma aula grátis de R Academy no CoddyKit. Esta é a aula 3 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 é um fluxo de trabalho?

Um fluxo de trabalho reúne uma receita e uma especificação de modelo em um único objeto. Isso resolve um problema importante: as etapas de pré-processamento e modelagem devem ser tratadas como uma unidade durante a validação cruzada e o ajuste final; caso contrário, parâmetros como as médias de normalização podem vazar dos subconjuntos de teste.

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() e add_model()

Use add_recipe(rec) para anexar um pré-processador de receita e add_model(spec) para anexar uma especificação de modelo parsnip. O operador de encadeamento torna isso muito legível.

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() em um fluxo de trabalho

Chamar fit(wf, data = train) em um fluxo de trabalho chama automaticamente prep() na receita usando os dados de treinamento e, em seguida, treina o modelo com os atributos pré-processados. Você nunca precisa chamar prep() ou bake() manualmente.

fitted_wf <- fit(wf, data = housing_train)

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

predict() em um fluxo de trabalho ajustado

Quando você chama predict(fitted_wf, new_data = test), o fluxo de trabalho aplica automaticamente bake() aos novos dados usando a receita treinada antes de gerar as previsões. Isso elimina o risco de esquecer de pré-processar os dados de teste.

# 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() — Treinar com todos os dados e avaliar no teste

last_fit(wf, split) recebe seu fluxo de trabalho final e o objeto de divisão inicial entre treinamento e teste. Ele ajusta o fluxo de trabalho na parte de treinamento e o avalia na parte de teste — a etapa padrão de avaliação do modelo final após a conclusão do ajuste.

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) extrai o objeto de modelo parsnip treinado de um fluxo de trabalho ajustado. Você pode usá-lo para inspecionar coeficientes, importância das variáveis ou encaminhá-lo a ferramentas de explicação 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) retorna a receita preparada de um fluxo de trabalho ajustado. Isso é útil para inspecionar quais transformações foram aplicadas ou para recuperar o pré-processamento treinado e aplicá-lo independentemente a dados 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() em fluxos de trabalho

augment(fitted_wf, new_data) retorna o quadro de dados de entrada com colunas de previsão acrescentadas. Para regressão, ele adiciona .pred; para classificação, adiciona .pred_class e colunas de probabilidade para cada classe.

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)

Atualizando um fluxo de trabalho

Você pode atualizar componentes individuais de um fluxo de trabalho com update_recipe() ou update_model() sem reconstruí-lo do zero. Isso é útil durante a experimentação, quando você quer trocar o mecanismo do modelo mantendo a mesma receita.

# 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() versus add_recipe()

Se você não precisar de uma receita, poderá usar add_formula(outcome ~ .) como pré-processador. Isso aplica transformações mínimas, apenas a especificação da fórmula. Use add_recipe() quando precisar de engenharia de atributos; use add_formula() para modelos de referência 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 fluxos de trabalho para comparação

workflow_set() do pacote de conjuntos de fluxos de trabalho cria uma coleção de fluxos de trabalho que combina várias receitas e especificações de modelos. Em seguida, você pode ajustar e avaliar todas as combinações de uma só vez com 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)

Verificação rápida

Qual é a principal vantagem de usar last_fit(workflow, split) em vez de ajustar e fazer previsões manualmente?

Recapitulação dos fluxos de trabalho

Principais conclusões sobre fluxos de trabalho: combinação de receitas e modelos:

  • workflow() |> add_recipe(rec) |> add_model(spec) reúne o pré-processamento e a modelagem.
  • fit(wf, data = train) prepara a receita e treina o modelo em uma única chamada.
  • predict(fitted_wf, new_data) aplica automaticamente bake() aos novos dados antes de fazer previsões.
  • last_fit(wf, split) treina no conjunto de treinamento e avalia no conjunto de teste — use-o para a avaliação final do modelo.
  • extract_fit_parsnip() e extract_recipe() recuperam componentes para inspeção.
  • augment() acrescenta as previsões ao quadro de dados para facilitar o cálculo das métricas.
  • workflow_set() compara simultaneamente várias combinações de receitas e 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)

Perguntas Frequentes

A aula “Fluxos de trabalho: combinando receitas e modelos” é grátis?

Sim — o texto completo de “Fluxos de trabalho: combinando receitas e modelos” é 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 “Fluxos de trabalho: combinando receitas e modelos”?

Agrupe o pré-processamento e o modelo em um único objeto de fluxo de trabalho. 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 3 de 4.

Quanto tempo leva a aula “Fluxos de trabalho: combinando receitas e modelos”?

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

  1. Engenharia de atributos com recipes
  2. Especificações de modelos com parsnip
  3. Fluxos de trabalho: combinando receitas e modelos
  4. Reamostragem e validação cruzada com rsample
← Voltar para R Academy