Resampling och korsvalidering med rsample
Utvärdera modeller med k-faldig CV, bootstrap och nästad resampling.
Resampling och korsvalidering med rsample är en gratis lektion i R Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för R Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i R Academy innehåller totalt 4 lektioner.
Varför återsampla?
En enda uppdelning i tränings- och testdata ger en osäker uppskattning av modellens prestanda — ni kan ha haft tur eller otur med vilka observationer som hamnade i testmängden. Återsampling upprepar processen flera gånger för att ge en stabil och tillförlitlig uppskattning av hur modellen generaliserar till nya data.
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) skapar en enda slumpmässig uppdelning i tränings- och testmängder. Använd strata för att stratifiera efter en kolumn, till exempel målvariabeln, så att klassbalansen bevaras i båda delarna.
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() — korsvalidering med k foldar
vfold_cv(data, v = 10) skapar 10 foldar. Data delas upp i 10 lika stora delar; 9 används för träning och 1 för validering, och delarna roteras så att alla foldar används. Detta ger 10 prestandaestimat som genomsnittbildas till ett stabilt mått.
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) tränar arbetsflödet på varje träningsfold och utvärderar det på valideringsfolden, samtidigt som de begärda måtten samlas in. Det returnerar en tibble med resultat som ni sammanfattar med 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) returnerar en städad tibble som sammanfattar modellens prestanda över alla foldar. Kolumnen mean innehåller det genomsnittliga måttet och std_err standardfelet, vilket ger en uppfattning om variationen i uppskattningen.
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() — bootstrap-återsampling
bootstraps(data, times = 25) skapar bootstrap-urval: varje urval är ett slumpmässigt urval med återläggning och har samma storlek som det ursprungliga datasetet. Observationer som inte valdes ut bildar bedömningsmängden out-of-bag (OOB). Bootstrap har högre varians än k-fold men fungerar bra med små dataset.
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)
}))Monte Carlo-korsvalidering
mc_cv(data, prop, times) skapar times slumpmässiga uppdelningar, där prop av data används för träning i varje uppdelning. Till skillnad från k-fold kan samma observation förekomma i valideringsmängden flera gånger. Detta är användbart när ni behöver fler återsamplingsiterationer än k-fold ger.
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() — sökning efter hyperparametrar
När arbetsflödet innehåller platshållare med tune() använder ni tune_grid(wf, resamples, grid) för att söka igenom ett rutnät av hyperparametervärden. Varje kombination utvärderas på alla foldar och den bästa konfigurationen väljs med 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() och finalize_workflow()
Efter justeringen väljer select_best(tune_res, metric) den hyperparameterkombination som har det bästa genomsnittliga måttet. finalize_workflow(wf, best_params) skapar ett nytt arbetsflöde där dessa värden ersätter 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)Nästlad korsvalidering
För en helt opartisk utvärdering när ni även justerar hyperparametrar använder ni nästlad korsvalidering: en yttre loop för prestandaskattning och en inre loop för justering. I rsample skapar ni en yttre vfold_cv och justerar modellen inom varje yttre fold med hjälp av de inre foldarna.
# 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)Jämföra återsamplingsstrategier
Varje återsamplingsstrategi har sina avvägningar. Välj utifrån datasetets storlek och er beräkningsbudget:
- k-fold (v=10): låg bias och måttlig varians. Standardvalet för de flesta problem.
- Bootstrap: fungerar med mycket små datamängder men har högre varians än k-fold.
- Monte Carlo CV: mer flexibelt och lämpligt för tidsbegränsad justering.
- Upprepad k-fold: lägre varians; använd när ni har råd med mer beräkning.
# 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)Snabb kontroll
Vad returnerar collect_metrics() när det tillämpas på resultatet från fit_resamples()?
Sammanfattning av återsampling
Viktiga slutsatser från Återsampling och korsvalidering med rsample:
initial_split(data, prop, strata)skapar en stratifierad uppdelning i tränings- och testdata.vfold_cv(data, v = 10)skapar foldar för k-fold-korsvalidering.bootstraps(data, times)skapar bootstrap-urval för små dataset.fit_resamples(wf, folds, metrics)utvärderar ett arbetsflöde över alla foldar.collect_metrics()sammanfattar resultaten med medelvärde och standardfel.tune_grid()söker efter hyperparametrar ochselect_best()väljer den bästa kombinationen.finalize_workflow()tillsammans medlast_fit()slutför arbetsflödet från justering till driftsättning.
# 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()
Lär dig R med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 43
- Lektioner
- 159
Vanliga frågor
Är lektionen ”Resampling och korsvalidering med rsample” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen R Academy, inklusive ”Resampling och korsvalidering med rsample”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i R Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Resampling och korsvalidering med rsample”?
Utvärdera modeller med k-faldig CV, bootstrap och nästad resampling. Ni övar på R Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig R Academy?
Du behöver inga förkunskaper. Utbildningen i R Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Resampling och korsvalidering med rsample”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här R Academy-lektionen?
Ja. Varje R Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Feature engineering med recipes
- Modellspecifikationer med parsnip
- Workflows: kombinera recipes och modeller
- Resampling och korsvalidering med rsample