Herschikking en crossvalidatie met rsample
Evalueer modellen met k-fold-CV, bootstrap en geneste herschikking.
Herschikking en crossvalidatie met rsample is een gratis R Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject R Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus R Academy bevat in totaal 4 lessen.
Waarom resamplen?
Een enkele train/test-split geeft een onnauwkeurige schatting van de modelprestaties — je had geluk of pech met de waarnemingen die in de testset terechtkwamen. Met resampling herhaal je het proces meerdere keren om een stabiele, betrouwbare schatting te krijgen van hoe goed je model generaliseert naar nieuwe gegevens.
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) maakt één willekeurige splitsing in trainings- en testsets. Gebruik strata om te stratificeren op basis van een kolom, bijvoorbeeld de doelvariabele, zodat de klassenverdeling in beide delen behouden blijft.
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() — kruisvalidatie met k vouwen
vfold_cv(data, v = 10) maakt 10 vouwen. De gegevens worden opgesplitst in 10 gelijke delen; 9 delen worden gebruikt voor training en 1 voor validatie, waarbij alle vouwen aan de beurt komen. Dit levert 10 prestatieberamingen op die worden gemiddeld voor een stabiele metrische waarde.
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) fit je workflow op elk trainingsvouw en evalueert deze op het validatievouw, waarbij de gevraagde metrische waarden worden verzameld. De functie retourneert een tibble met resultaten, die je samenvat met 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) retourneert een tidy tibble die de modelprestaties over alle vouwen samenvat. De kolom mean bevat de gemiddelde metrische waarde en std_err de standaardfout, zodat je een indruk krijgt van de variantie in de schatting.
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() — bootstrapresampling
bootstraps(data, times = 25) maakt bootstrapsteekproeven: elke steekproef is een willekeurige trekking met teruglegging en heeft dezelfde omvang als de oorspronkelijke dataset. Waarnemingen die niet zijn getrokken, vormen de out-of-bag-beoordelingsset (OOB). Bootstraps hebben een grotere variantie dan k-fold, maar werken goed met kleine datasets.
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-Carlokruisvalidatie
mc_cv(data, prop, times) maakt times willekeurige splitsingen, waarbij voor elke splitsing prop van de gegevens voor training wordt gebruikt. In tegenstelling tot bij k-fold kan dezelfde waarneming meerdere keren in de validatieset voorkomen. Dit is nuttig wanneer je meer resampling-iteraties nodig hebt dan k-fold biedt.
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() — hyperparameterzoektocht
Wanneer je workflow tijdelijke aanduidingen met tune() bevat, gebruik je tune_grid(wf, resamples, grid) om te zoeken in een raster van hyperparameterwaarden. Elke combinatie wordt op alle vouwen geëvalueerd en de beste configuratie wordt geselecteerd met 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() en finalize_workflow()
Na het tunen kiest select_best(tune_res, metric) de hyperparametercombinatie met de beste gemiddelde metrische waarde. finalize_workflow(wf, best_params) maakt een nieuwe workflow waarin die waarden worden ingevuld op de plaats van 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)Geneste kruisvalidatie
Gebruik voor een echt onbevooroordeelde evaluatie wanneer je ook hyperparameters tunet geneste kruisvalidatie: een buitenste lus voor het schatten van de prestaties en een binnenste lus voor het tunen. Maak in rsample een buitenste vfold_cv en tune binnen elke buitenste vouw met de binnenste vouwen.
# 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)Resamplingstrategieën vergelijken
Elke resamplingstrategie heeft voor- en nadelen. Kies op basis van de omvang van je dataset en je beschikbare rekenbudget:
- k-fold (v=10): geringe vertekening, gemiddelde variantie. De standaardkeuze voor de meeste problemen.
- Bootstrap: werkt met zeer weinig gegevens; grotere variantie dan k-fold.
- Monte Carlo-CV: flexibeler; geschikt voor tunen met beperkte tijd.
- Herhaalde k-fold: lagere variantie; gebruik dit wanneer je meer rekenwerk aankunt.
# 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)Korte controle
Wat retourneert collect_metrics() wanneer je deze toepast op een resultaat van fit_resamples()?
Samenvatting van resampling
Belangrijkste punten uit Resampling en kruisvalidatie met rsample:
initial_split(data, prop, strata)maakt een gestratificeerde train/test-split.vfold_cv(data, v = 10)maakt vouwen voor k-fold-kruisvalidatie.bootstraps(data, times)maakt bootstrapsteekproeven voor kleine datasets.fit_resamples(wf, folds, metrics)evalueert een workflow over alle vouwen.collect_metrics()vat resultaten samen met het gemiddelde en de standaardfout.tune_grid()zoekt naar hyperparameters;select_best()kiest de beste combinatie.finalize_workflow()+last_fit()voltooien de pipeline van tunen naar implementatie.
# 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()
Leer R met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 43
- Lessen
- 159
Veelgestelde vragen
Is de les “Herschikking en crossvalidatie met rsample” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad R Academy, waaronder “Herschikking en crossvalidatie met rsample”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus R Academy bevat in totaal 4 lessen.
Wat leer ik in “Herschikking en crossvalidatie met rsample”?
Evalueer modellen met k-fold-CV, bootstrap en geneste herschikking. Je oefent met R Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met R Academy te beginnen?
Ervaring vooraf is niet nodig. R Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.
Hoe lang duurt de les “Herschikking en crossvalidatie met rsample”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over R Academy?
Ja. Elke les over R Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Feature engineering met recipes
- Modelspecificaties met parsnip
- Workflows: recipes en modellen combineren
- Herschikking en crossvalidatie met rsample