Ricampionamento e convalida incrociata con rsample
Valuti i modelli con CV k-fold, bootstrap e ricampionamento annidato
Ricampionamento e convalida incrociata con rsample è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 4 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.
Perché eseguire il resampling?
Un'unica suddivisione tra addestramento e test fornisce una stima rumorosa delle prestazioni del modello: la scelta delle osservazioni finite nel set di test può essere stata favorevole o sfavorevole. Il resampling ripete il processo più volte per ottenere una stima stabile e affidabile della capacità del modello di generalizzare a nuovi dati.
library(rsample)
# Single split — performance estimate depends heavily
# on which 20% ended up as test data
split <- initial_split(mtcars, prop = 0.8)
train <- training(split)
test <- testing(split)
cat('Train:', nrow(train), '| Test:', nrow(test))initial_split()
initial_split(data, prop, strata) crea una singola suddivisione casuale in set di addestramento e di test. Usi strata per stratificare in base a una colonna, ad esempio la variabile risposta, così da mantenere l'equilibrio tra le classi in entrambe le partizioni.
library(rsample)
# Stratified split by outcome variable
split <- initial_split(ames, prop = 0.8, strata = Sale_Price)
train <- training(split)
test <- testing(split)
cat('Train rows:', nrow(train))
cat('Test rows:', nrow(test))vfold_cv() — Convalida incrociata k-fold
vfold_cv(data, v = 10) crea 10 fold. I dati vengono suddivisi in 10 parti uguali; 9 vengono usate per l'addestramento e 1 per la validazione, alternando tutte le parti. Si ottengono così 10 stime delle prestazioni, che vengono mediate per ottenere una metrica stabile.
folds <- vfold_cv(housing_train, v = 10, strata = price)
# Each fold is a split object
print(folds)
# Inspect one fold
fold_1 <- folds$splits[[1]]
train_1 <- analysis(fold_1)
val_1 <- assessment(fold_1)
cat('Fold 1 — Train:', nrow(train_1), '| Val:', nrow(val_1))fit_resamples()
fit_resamples(workflow, resamples, metrics) addestra il workflow su ogni fold di addestramento e lo valuta sul fold di validazione, raccogliendo le metriche richieste. Restituisce un tibble di risultati che si riassume con collect_metrics().
library(tune)
folds <- vfold_cv(housing_train, v = 10)
res <- fit_resamples(
wf, # your workflow
folds,
metrics = metric_set(rmse, rsq)
)
# Average metric across all 10 folds
collect_metrics(res)collect_metrics()
collect_metrics(resample_result) restituisce un tibble ordinato che riassume le prestazioni del modello su tutti i fold. La colonna mean contiene la media della metrica, mentre std_err contiene l'errore standard, fornendo un'indicazione della variabilità della stima.
metrics_df <- collect_metrics(res)
print(metrics_df)
# .metric .estimator mean n std_err .config
# rmse standard 24500 10 1200 Preprocessor1_Model1
# rsq standard 0.882 10 0.012 Preprocessor1_Model1
# Pull a single metric
collect_metrics(res) |>
dplyr::filter(.metric == 'rmse') |>
dplyr::pull(mean)bootstraps() — Resampling bootstrap
bootstraps(data, times = 25) crea campioni bootstrap: ogni campione è un'estrazione casuale con reinserimento, della stessa dimensione del dataset originale. Le osservazioni non estratte formano il set di valutazione out-of-bag (OOB). Il bootstrap presenta una varianza maggiore rispetto al k-fold, ma funziona bene con dataset di piccole dimensioni.
boot_samples <- bootstraps(housing_train, times = 25, strata = price)
print(boot_samples)
# Average proportion of unique rows in each bootstrap
mean(sapply(boot_samples$splits, function(s) {
nrow(analysis(s)) / nrow(housing_train)
}))Convalida incrociata Monte Carlo
mc_cv(data, prop, times) crea times suddivisioni casuali, usando ogni volta prop dei dati per l'addestramento. A differenza del k-fold, la stessa osservazione può comparire più volte nel set di validazione. È utile quando servono più iterazioni di resampling di quante ne fornisca il k-fold.
mc_splits <- mc_cv(housing_train, prop = 0.8, times = 20)
res_mc <- fit_resamples(
wf,
mc_splits,
metrics = metric_set(rmse, rsq)
)
collect_metrics(res_mc)tune_grid() — Ricerca degli iperparametri
Quando il workflow contiene segnaposto tune(), usi tune_grid(wf, resamples, grid) per cercare in una griglia di valori degli iperparametri. Ogni combinazione viene valutata su tutti i fold e la configurazione migliore viene selezionata con select_best().
rf_spec <- rand_forest(mtry = tune(), trees = tune()) |>
set_engine('ranger') |>
set_mode('regression')
wf_tune <- workflow() |> add_recipe(rec) |> add_model(rf_spec)
grid <- grid_regular(mtry(range = c(2, 10)), trees(range = c(100, 500)), levels = 3)
tune_res <- tune_grid(wf_tune, resamples = folds, grid = grid)
collect_metrics(tune_res) |> head()select_best() e finalize_workflow()
Dopo il tuning, select_best(tune_res, metric) seleziona la combinazione di iperparametri con la metrica media migliore. finalize_workflow(wf, best_params) crea un nuovo workflow sostituendo quei valori ai segnaposto tune().
best_params <- select_best(tune_res, metric = 'rmse')
print(best_params)
# Substitute best values into the workflow
final_wf <- finalize_workflow(wf_tune, best_params)
# Fit on all training data, evaluate on test
final_fit <- last_fit(final_wf, split)
collect_metrics(final_fit)Convalida incrociata annidata
Per una valutazione realmente imparziale quando si esegue anche il tuning degli iperparametri, si usa la convalida incrociata annidata: un ciclo esterno per stimare le prestazioni e uno interno per il tuning. In rsample, si crea un vfold_cv esterno e si esegue il tuning all'interno di ogni fold esterno usando i fold interni.
# Outer folds for unbiased evaluation
outer_folds <- vfold_cv(housing_train, v = 5)
# For each outer fold, tune on the inner training data
res_nested <- tune_grid(
wf_tune,
resamples = outer_folds,
grid = 10, # 10 random configurations
metrics = metric_set(rmse)
)
collect_metrics(res_nested)Confrontare le strategie di resampling
Ogni strategia di resampling presenta vantaggi e compromessi. La scelta dipende dalle dimensioni del dataset e dalle risorse di calcolo disponibili:
- k-fold (v=10): bias ridotto e varianza moderata. È la scelta predefinita per la maggior parte dei problemi.
- Bootstrap: funziona con dataset molto piccoli, ma ha una varianza maggiore rispetto al k-fold.
- CV Monte Carlo: è più flessibile ed è adatta al tuning con vincoli di tempo.
- k-fold ripetuto: ha una varianza inferiore; lo si usa quando si possono sostenere maggiori costi di calcolo.
# Repeated k-fold: 5-fold repeated 3 times = 15 models fitted
repeated_folds <- vfold_cv(housing_train, v = 5, repeats = 3)
res_rep <- fit_resamples(
wf,
repeated_folds,
metrics = metric_set(rmse, rsq)
)
collect_metrics(res_rep)Verifica rapida
Che cosa restituisce collect_metrics() quando viene applicato al risultato di fit_resamples()?
Riepilogo del resampling
Concetti chiave del resampling e della convalida incrociata con rsample:
initial_split(data, prop, strata)crea una suddivisione stratificata tra addestramento e test.vfold_cv(data, v = 10)crea i fold per la convalida incrociata k-fold.bootstraps(data, times)crea campioni bootstrap per dataset di piccole dimensioni.fit_resamples(wf, folds, metrics)valuta un workflow su tutti i fold.collect_metrics()riassume i risultati con la media e l'errore standard.tune_grid()ricerca gli iperparametri;select_best()seleziona il migliore.finalize_workflow()+last_fit()completano il flusso dal tuning alla messa in produzione.
# Full rsample pipeline
split <- initial_split(data, prop = 0.8, strata = y)
train <- training(split)
folds <- vfold_cv(train, v = 10)
res <- fit_resamples(wf, folds, metrics = metric_set(rmse, rsq))
collect_metrics(res)
# After tuning
best <- select_best(tune_res, metric = 'rmse')
fin_wf <- finalize_workflow(wf_tune, best)
last_fit(fin_wf, split) |> collect_metrics()Domande Frequenti
La lezione «Ricampionamento e convalida incrociata con rsample» è gratuita?
Sì — il testo completo di «Ricampionamento e convalida incrociata con rsample» è 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 «Ricampionamento e convalida incrociata con rsample»?
Valuti i modelli con CV k-fold, bootstrap e ricampionamento annidato 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 4 di 4.
Quanto tempo richiede la lezione «Ricampionamento e convalida incrociata con rsample»?
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