Resampling og kryssvalidering med rsample
Evaluer modeller med k-fold-CV, bootstrap og nestet resampling.
Resampling og kryssvalidering med rsample er en gratis leksjon i R Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i R Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i R Academy inneholder totalt 4 leksjoner.
Hvorfor resample?
Et enkelt trenings-/testskille gir et usikkert estimat av modellens ytelse – De kan ha vært heldig eller uheldig med hvilke observasjoner som havnet i testsettet. Resampling gjentar prosessen flere ganger for å få et stabilt og pålitelig estimat av hvordan modellen generaliserer til nye 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) oppretter et enkelt tilfeldig skille i trenings- og testsett. Bruk strata til å stratifisere etter en kolonne, for eksempel målvariabelen, slik at klassebalansen opprettholdes i begge delene.
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() — K-fold-kryssvalidering
vfold_cv(data, v = 10) oppretter 10 fold. Dataene deles i 10 like deler. 9 brukes til trening og 1 til validering, og dette roteres gjennom alle foldene. Resultatet er 10 ytelsesestimater som gjennomsnittberegnes for å gi en stabil metrikk.
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) tilpasser arbeidsflyten på hver treningsfold og evaluerer den på valideringsfolden, samtidig som de etterspurte metrikkene samles inn. Den returnerer en tibble med resultater som De oppsummerer 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) returnerer en ryddig tibble som oppsummerer modellens ytelse på tvers av alle foldene. Kolonnen mean er den gjennomsnittlige metrikken, og std_err er standardfeilen. Dette gir Dem et inntrykk av variasjonen i estimatet.
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-resampling
bootstraps(data, times = 25) oppretter bootstrap-utvalg: hvert utvalg er et tilfeldig trekk med tilbakelegging og har samme størrelse som det opprinnelige datasettet. Observasjoner som ikke trekkes ut, danner vurderingssettet out-of-bag (OOB). Bootstrap har høyere varians enn k-fold, men fungerer godt med små datasett.
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-kryssvalidering
mc_cv(data, prop, times) oppretter times tilfeldige skiller, der prop av dataene brukes til trening i hvert skille. I motsetning til k-fold kan den samme observasjonen forekomme i valideringssettet flere ganger. Dette er nyttig når De trenger flere resampling-iterasjoner enn k-fold gir.
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øk etter hyperparametere
Når arbeidsflyten inneholder tune()-plassholdere, bruker De tune_grid(wf, resamples, grid) til å søke gjennom et rutenett av hyperparameterverdier. Hver kombinasjon evalueres på alle foldene, og den beste konfigurasjonen velges 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() og finalize_workflow()
Etter tuning velger select_best(tune_res, metric) hyperparameterkombinasjonen med den beste gjennomsnittlige metrikken. finalize_workflow(wf, best_params) oppretter en ny arbeidsflyt der disse verdiene settes inn i stedet for 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)Nested kryssvalidering
For en virkelig objektiv evaluering når De også tuner hyperparametere, kan De bruke nested cross validation: en ytre løkke for estimering av ytelse og en indre løkke for tuning. I rsample oppretter De en ytre vfold_cv og tuner innenfor hver ytre fold ved hjelp av de indre foldene.
# 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)Sammenligning av resampling-strategier
Hver resampling-strategi har sine avveininger. Velg basert på størrelsen på datasettet og tilgjengelige beregningsressurser:
- k-fold (v=10): Lav skjevhet, moderat varians. Standardvalget for de fleste problemer.
- Bootstrap: Fungerer med svært lite data, men har høyere varians enn k-fold.
- Monte Carlo CV: Mer fleksibelt, og godt egnet for tuning med tidsbegrensninger.
- Gjentatt k-fold: Lavere varians. Bruk dette når De har råd til mer beregning.
# 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)Kort kontroll
Hva returnerer collect_metrics() når den brukes på et resultat fra fit_resamples()?
Oppsummering av resampling
Viktigste punkter fra Resampling og kryssvalidering med rsample:
initial_split(data, prop, strata)oppretter et stratifisert trenings-/testskille.vfold_cv(data, v = 10)oppretter fold for k-fold-kryssvalidering.bootstraps(data, times)oppretter bootstrap-utvalg for små datasett.fit_resamples(wf, folds, metrics)evaluerer en arbeidsflyt på tvers av alle foldene.collect_metrics()oppsummerer resultatene med gjennomsnitt og standardfeil.tune_grid()søker etter hyperparametere, mensselect_best()velger vinneren.finalize_workflow()+last_fit()fullfører arbeidsflyten fra tuning til produksjonssetting.
# 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 deg R med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 43
- Leksjoner
- 159
Ofte stilte spørsmål
Er leksjonen «Resampling og kryssvalidering med rsample» gratis?
Ja – du kan lese valgfritt 3 av leksjonene i læringsstien R Academy, inkludert «Resampling og kryssvalidering med rsample», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i R Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Resampling og kryssvalidering med rsample»?
Evaluer modeller med k-fold-CV, bootstrap og nestet resampling. Du øver på R Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med R Academy?
Ingen tidligere erfaring er nødvendig. R Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.
Hvor lang tid tar leksjonen «Resampling og kryssvalidering med rsample»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne R Academy-leksjonen?
Ja. Alle R Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Feature engineering med recipes
- Modellspesifikasjoner med parsnip
- Arbeidsflyter: kombinere oppskrifter og modeller
- Resampling og kryssvalidering med rsample