R Academy · Lezione

Feature engineering con recipes

Definisca passaggi di preprocessing per normalizzazione, codifica e imputazione

Feature engineering con recipes è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 1 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'è una recipe?

In tidymodels, una recipe è un modello di riferimento per il preprocessing dei dati. Registra i passaggi necessari per trasformare i dati grezzi in feature pronte per il modello, senza applicarli immediatamente.

La funzione principale è recipe(outcome ~ ., data = train), che definisce la formula e il dataset di riferimento usato per stimare le eventuali statistiche necessarie durante il preprocessing.

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 ogni predittore numerico sulla media 0 e lo scala alla deviazione standard 1. È essenziale per gli algoritmi sensibili alla scala delle feature, come la regressione logistica, le SVM o le reti neurali.

La media e la deviazione standard vengono calcolate sul training set e applicate in modo coerente ai dati di test tramite 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()) converte le variabili categoriche (factor/character) in colonne numeriche dummy (con codifica one-hot). Per impostazione predefinita crea k-1 colonne per un factor con k livelli, evitando la multicollinearità perfetta.

Usi one_hot = TRUE per i modelli basati su alberi che traggono vantaggio dalla codifica 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()

I valori mancanti fanno fallire la maggior parte dei motori di modellazione. step_impute_median(all_numeric_predictors()) sostituisce i valori NA con la mediana calcolata sul training set. Rispetto all'imputazione con la media, la mediana è più robusta rispetto ai valori anomali.

Per le variabili categoriche, usi step_impute_mode() per inserire il valore più frequente.

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

print(rec)

step_zv() — Rimozione della varianza nulla

step_zv(all_predictors()) rimuove ogni predittore che ha un solo valore univoco (varianza nulla). Tali colonne non contengono informazioni e possono causare errori in alcuni motori di modellazione.

Per la varianza quasi nulla, usi step_nzv(all_predictors()), che rimuove anche le colonne in cui un valore prevale in modo schiacciante.

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() — Addestramento della recipe

prep(recipe) stima tutti i parametri richiesti dai passaggi, ad esempio la media/deviazione standard per la normalizzazione e le mediane per l'imputazione, usando i dati di training. Il risultato è una recipe prepped che conosce tutti i parametri di trasformazione.

Esegua sempre prep solo sui dati di training, per evitare la fuga di dati dal test set.

# 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() — Applicazione a nuovi dati

bake(prepped_recipe, new_data = test_data) applica tutti i passaggi di preprocessing, usando i parametri già stimati, a qualsiasi dataset. In questo modo le trasformazioni sono coerenti tra training e test.

Passi new_data = NULL per applicare i passaggi ai dati di training usati 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() — Estrazione dei dati di training elaborati

juice(prepped_recipe) è una funzione di comodità equivalente a bake(prepped_recipe, new_data = NULL). Restituisce la versione preprocessata dei dati di training usati durante prep().

Nota: juice() è leggermente deprecata a favore di bake(prep, new_data = NULL), ma la troverà nel codice tidymodels più datato.

# 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

Combinazione di più passaggi

I passaggi vengono applicati nell'ordine in cui vengono aggiunti. Una recipe tipica per la produzione segue questo ordine:

Imputazione (correggere prima gli NA)
Creazione delle feature (interazioni, polinomi)
Codifica dummy (conversione dei factor)
Rimozione della varianza nulla
Normalizzazione (scalatura alla fine)

L'ordine è importante: per esempio, normalizzare prima della codifica dummy produrrebbe risultati errati.

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)

Ispezione dei risultati di prep

Dopo aver chiamato prep(), può esaminare l'operato di ogni passaggio usando tidy(prepped_rec). Ogni passaggio ha un id numerico e può esaminarlo più in dettaglio con tidy(prepped_rec, number = 1) per visualizzare i parametri stimati.

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

Le recipe nella pratica

Le recipe danno il meglio quando vengono combinate con i workflow. Invece di chiamare manualmente prep() e bake(), aggiunga la recipe a un workflow: tidymodels gestirà automaticamente prep/bake durante fit() e predict().

In questo modo elimina una causa comune di bug, in cui il preprocessing viene applicato in modo diverso durante il training e durante l'inferenza.

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)

Controllo rapido

Che cosa fa la chiamata a prep(recipe) nel framework delle recipe di tidymodels?

Riepilogo delle recipe

Punti chiave del feature engineering con le recipe:

recipe(outcome ~ ., data = train) definisce il modello di riferimento per il preprocessing.
step_normalize(), step_dummy(), step_impute_median(), step_zv() sono i passaggi più usati.
prep() stima i parametri solo dai dati di training, mai dai dati di test.
bake(prepped, new_data) applica la recipe addestrata a qualsiasi dataset.
L'ordine dei passaggi è importante: imputare → creare → codificare → rimuovere → scalare.
In produzione, racchiuda la recipe in un workflow() per automatizzare prep/bake durante fit e 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)

Domande Frequenti

La lezione «Feature engineering con recipes» è gratuita?

Sì — il testo completo di «Feature engineering con recipes» è 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 «Feature engineering con recipes»?

Definisca passaggi di preprocessing per normalizzazione, codifica e imputazione 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 1 di 4.

Quanto tempo richiede la lezione «Feature engineering con recipes»?

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

Feature engineering con recipes
Specifiche dei modelli con parsnip
Workflow: combinare ricette e modelli
Ricampionamento e convalida incrociata con rsample

← Torna a R Academy