0Pricing
R Academy · Lezione

Workflow: combinare ricette e modelli

Raggruppi preprocessing e modello in un unico oggetto workflow

Workflow: combinare ricette e modelli è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Che cos'è un workflow?

Un workflow raggruppa una recipe e una specifica del modello in un unico oggetto. Questo risolve un problema fondamentale: durante la convalida incrociata e l'addestramento finale, i passaggi di preprocessing e di modellazione devono essere trattati come un'unica unità; in caso contrario, parametri come le medie usate per la normalizzazione possono fuoriuscire dai fold di test.

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

Usi add_recipe(rec) per associare un preprocessore recipe e add_model(spec) per associare una specifica di modello parsnip. L'operatore pipe rende questa sintassi molto leggibile.

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() su un workflow

Chiamando fit(wf, data = train) su un workflow, viene richiamato automaticamente prep() sulla recipe usando i dati di addestramento; quindi il modello viene addestrato sulle feature preprocessate. Non è necessario chiamare manualmente prep() o bake().

fitted_wf <- fit(wf, data = housing_train)

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

predict() su un workflow addestrato

Quando si chiama predict(fitted_wf, new_data = test), il workflow applica automaticamente bake() ai nuovi dati usando la recipe addestrata, prima di generare le predizioni. In questo modo si elimina il rischio di dimenticare il preprocessing dei dati di test.

# 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() — Addestrare su tutti i dati e valutare sul test

last_fit(wf, split) riceve il workflow finale e l'oggetto contenente la suddivisione iniziale tra addestramento e test. Addestra il workflow sulla parte di addestramento e lo valuta sulla parte di test: è il normale passaggio di valutazione del modello finale dopo aver completato il tuning.

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) estrae l'oggetto modello parsnip addestrato da un workflow addestrato. È quindi possibile usarlo per esaminare i coefficienti, l'importanza delle variabili o passarlo a strumenti di interpretazione del modello.

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) restituisce la recipe preparata da un workflow addestrato. È utile per controllare quali trasformazioni sono state applicate o per recuperare il preprocessing addestrato e applicarlo indipendentemente a dati esterni.

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() sui workflow

augment(fitted_wf, new_data) restituisce il data frame di input con le colonne delle predizioni aggiunte. Per la regressione aggiunge .pred; per la classificazione aggiunge .pred_class e le colonne delle probabilità per ogni 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)

Aggiornare un workflow

È possibile aggiornare singoli componenti di un workflow con update_recipe() o update_model(), senza ricostruirlo da zero. È utile durante la sperimentazione, quando si desidera sostituire il motore del modello mantenendo la stessa recipe.

# 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() e add_recipe() a confronto

Se non è necessaria una recipe, è possibile usare add_formula(outcome ~ .) come preprocessore. Questo applica trasformazioni minime, limitandosi alla specifica della formula. Usi add_recipe() quando sono necessarie operazioni di feature engineering; usi add_formula() per creare rapidamente modelli baseline.

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

Workflow set per il confronto

workflow_set() del pacchetto workflowsets crea una raccolta di workflow che combina più recipe e specifiche di modelli. È quindi possibile eseguire il tuning e la valutazione di tutte le combinazioni contemporaneamente 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)

Verifica rapida

Qual è il principale vantaggio di usare last_fit(workflow, split) invece di eseguire manualmente l'addestramento e le predizioni?

Riepilogo dei workflow

Concetti chiave dei workflow: combinare recipe e modelli:

  • workflow() |> add_recipe(rec) |> add_model(spec) raggruppa il preprocessing e la modellazione.
  • fit(wf, data = train) prepara la recipe e addestra il modello con un'unica chiamata.
  • predict(fitted_wf, new_data) applica automaticamente bake() ai nuovi dati prima di generare le predizioni.
  • last_fit(wf, split) addestra sui dati di train e valuta sui dati di test: lo si usa per la valutazione finale del modello.
  • extract_fit_parsnip() e extract_recipe() recuperano i componenti per esaminarli.
  • augment() aggiunge le predizioni al data frame, semplificando il calcolo delle metriche.
  • workflow_set() confronta simultaneamente più combinazioni di recipe e modelli.
# 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)

Domande Frequenti

La lezione «Workflow: combinare ricette e modelli» è gratuita?

Sì — il testo completo di «Workflow: combinare ricette e modelli» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «Workflow: combinare ricette e modelli»?

Raggruppi preprocessing e modello in un unico oggetto workflow Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Workflow: combinare ricette e modelli»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Feature engineering con recipes
  2. Specifiche dei modelli con parsnip
  3. Workflow: combinare ricette e modelli
  4. Ricampionamento e convalida incrociata con rsample
← Torna a R Academy