Rééchantillonnage et validation croisée avec rsample
Évaluez les modèles avec une validation croisée CV à k sous-ensembles, un bootstrap et un rééchantillonnage imbriqué.
Rééchantillonnage et validation croisée avec rsample est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.
Pourquoi rééchantillonner ?
Une seule partition entre entraînement et test fournit une estimation bruitée des performances du modèle : vous pouvez avoir eu de la chance ou de la malchance avec les observations qui se sont retrouvées dans l'ensemble de test. Le rééchantillonnage répète le processus plusieurs fois afin d'obtenir une estimation stable et fiable de la façon dont votre modèle se généralisera à de nouvelles données.
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) crée une partition aléatoire unique entre les ensembles d'entraînement et de test. Utilisez strata pour stratifier selon une colonne, par exemple la variable réponse, afin de garantir le maintien de l'équilibre des classes dans les deux partitions.
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() — Validation croisée en k partitions
vfold_cv(data, v = 10) crée 10 partitions. Les données sont divisées en 10 parties égales ; 9 servent à l'entraînement et 1 à la validation, en faisant tourner la partition de validation. Vous obtenez ainsi 10 estimations des performances, dont la moyenne fournit une métrique stable.
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) ajuste votre workflow sur chaque partition d'entraînement et l'évalue sur la partition de validation, en recueillant les métriques demandées. La fonction renvoie une tibble de résultats que vous résumez avec 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) renvoie une tibble ordonnée qui résume les performances du modèle sur toutes les partitions. La colonne mean contient la moyenne de la métrique et std_err l'erreur standard, ce qui vous donne une indication de la variance de l'estimation.
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() — Rééchantillonnage bootstrap
bootstraps(data, times = 25) crée des échantillons bootstrap : chaque échantillon est un tirage aléatoire avec remise, de même taille que le jeu de données d'origine. Les observations qui n'ont pas été tirées forment l'ensemble d'évaluation hors sac (OOB). Le bootstrap présente une variance plus élevée que la validation en k partitions, mais fonctionne bien avec les petits jeux de données.
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)
}))Validation croisée de Monte-Carlo
mc_cv(data, prop, times) crée times partitions aléatoires, en utilisant à chaque fois prop des données pour l'entraînement. Contrairement à la validation en k partitions, une même observation peut apparaître plusieurs fois dans l'ensemble de validation. Cette méthode est utile lorsque vous avez besoin de davantage d'itérations de rééchantillonnage que n'en fournit la validation en k partitions.
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() — Recherche d'hyperparamètres
Lorsque votre workflow contient des espaces réservés tune(), utilisez tune_grid(wf, resamples, grid) pour rechercher parmi une grille de valeurs d'hyperparamètres. Chaque combinaison est évaluée sur toutes les partitions et la meilleure configuration est sélectionnée avec 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() et finalize_workflow()
Après le réglage, select_best(tune_res, metric) sélectionne la combinaison d'hyperparamètres présentant la meilleure métrique moyenne. finalize_workflow(wf, best_params) crée un nouveau workflow en remplaçant tune() par ces valeurs.
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)Validation croisée imbriquée
Pour une évaluation véritablement exempte de biais lorsque vous réglez également les hyperparamètres, utilisez une validation croisée imbriquée : une boucle externe pour estimer les performances et une boucle interne pour le réglage. Dans rsample, créez une validation vfold_cv externe et effectuez le réglage dans chaque partition externe à l'aide des partitions internes.
# 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)Comparer les stratégies de rééchantillonnage
Chaque stratégie de rééchantillonnage présente des compromis. Choisissez en fonction de la taille de votre jeu de données et de votre budget de calcul :
- k partitions (v=10) : faible biais, variance modérée. Choix par défaut pour la plupart des problèmes.
- Bootstrap : fonctionne avec de très petits jeux de données ; variance plus élevée que la validation en k partitions.
- Validation croisée de Monte-Carlo : plus flexible ; convient lorsque le réglage est limité par le temps.
- Validation répétée en k partitions : variance plus faible ; à utiliser si vous pouvez vous permettre davantage de calculs.
# 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)Vérification rapide
Que renvoie collect_metrics() lorsqu'elle est appliquée à un résultat de fit_resamples() ?
Récapitulatif du rééchantillonnage
Points essentiels sur le rééchantillonnage et la validation croisée avec rsample :
initial_split(data, prop, strata)crée une partition stratifiée entre entraînement et test.vfold_cv(data, v = 10)crée des partitions pour une validation croisée en k parties.bootstraps(data, times)crée des échantillons bootstrap pour les petits jeux de données.fit_resamples(wf, folds, metrics)évalue un workflow sur toutes les partitions.collect_metrics()résume les résultats avec la moyenne et l'erreur standard.tune_grid()recherche les hyperparamètres ;select_best()sélectionne le meilleur.finalize_workflow()+last_fit()terminent le pipeline entre le réglage et le déploiement.
# 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()Questions Fréquemment Posées
La leçon « Rééchantillonnage et validation croisée avec rsample » est-elle gratuite ?
Oui — le texte complet de « Rééchantillonnage et validation croisée avec rsample » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Rééchantillonnage et validation croisée avec rsample » ?
Évaluez les modèles avec une validation croisée CV à k sous-ensembles, un bootstrap et un rééchantillonnage imbriqué. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer R Academy ?
Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Rééchantillonnage et validation croisée avec rsample » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon R Academy ?
Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Ingénierie des caractéristiques avec recipes
- Spécifications des modèles avec parsnip
- Flux de travail : combiner recettes et modèles
- Rééchantillonnage et validation croisée avec rsample