Pipelines ML tidymodels R 2026 (guide expert)

Introduction

En 2026, tidymodels est la référence pour le machine learning en R, unifiant le préprocessing, la modélisation et l'évaluation dans un framework cohérent inspiré du tidyverse. Contrairement aux approches fragmentées comme caret, tidymodels offre des workflows reproductibles et scalables, idéaux pour les data scientists experts gérant des datasets massifs. Ce tutoriel expert vous guide pas à pas pour créer un pipeline complet de classification sur le dataset iris : preprocessing avec recipes, random forest via parsnip, tuning hyperparamétrique avec tune, et évaluation robuste. Vous obtiendrez un modèle optimisé, prêt pour le déploiement, avec des métriques précises comme l'AUC-ROC. Pourquoi c'est crucial ? Les pipelines tidymodels réduisent les fuites de données, accélèrent l'itération et intègrent seamlessly avec des outils comme vetiver pour le serving. À la fin, vous maîtriserez des techniques pros pour booster vos performances ML de 20-30%.

Prérequis

R version 4.3+ installé
Connaissances avancées en tidyverse et statistiques
Dataset iris (built-in)
Environnement RStudio ou VS Code avec R extension
30 minutes pour exécuter tous les codes

Installation des packages tidymodels

01_install_packages.R

if (!require("tidymodels", quietly = TRUE)) {
  install.packages("tidymodels")
}
library(tidymodels)
library(tidyverse)

# Vérification de l'installation
tidymodels:::version()

Ce code installe et charge tidymodels, qui inclut parsnip, recipes, tune et dials pour un écosystème unifié. Utilisez require pour éviter les redémarrages inutiles. Piège : oubliez quietly = TRUE pour supprimer les warnings verbeux lors des tutoriels reproductibles.

Préparation des données

Nous utilisons le dataset iris pour une classification multi-classe (Setosa, Versicolor, Virginica). Tidymodels excelle en split initial pour train/validation/test, évitant les biais d'évaluation. Pensez-y comme à un convoyeur : données brutes entrent, features prêtes sortent.

Chargement et split des données

02_load_split_data.R

data(iris)
set.seed(123)
split <- initial_split(iris, prop = 0.8, strata = Species)
train_data <- training(split)
test_data  <- testing(split)

# Vérification de la stratification
cat("Train:", nrow(train_data), "| Test:", nrow(test_data), "\n")
table(train_data$Species)

Ce bloc charge iris, applique un split stratifié 80/20 avec initial_split pour préserver les proportions de classes. set.seed(123) assure la reproductibilité. Évitez les splits aléatoires non seedés qui ruinent les benchmarks comparatifs.

Création de la recipe de preprocessing

03_create_recipe.R

iris_recipe <- recipe(Species ~ ., data = train_data) %>%
  step_normalize(all_predictors()) %>%
  step_dummy(all_nominal_predictors()) %>%  # Pas nécessaire ici mais exemple
  step_zv(all_predictors()) %>%
  step_corr(all_predictors(), threshold = 0.9)

iris_recipe <- prep(iris_recipe, training = train_data)

# Aperçu baked
baked_train <- bake(iris_recipe, new_data = train_data)
baked_test  <- bake(iris_recipe, new_data = test_data)
head(baked_train)

La recipe normalise (z-score), supprime les variables à variance zéro et corrélations >0.9, préparant des features propres. prep() ajuste sur train seulement, bake() applique. Piège majeur : ne jamais fitter sur test pour éviter la data leakage.

Spécification du modèle

Parsnip abstrait les engines (randomForest, xgboost...). Nous tunons un random forest pour capturer des interactions non-linéaires, comme un orchestre où chaque arbre vote intelligemment.

Définition du modèle et workflow

04_model_workflow.R

rf_model <- rand_forest(trees = tune(), mtry = tune()) %>%
  set_engine("ranger", importance = "permutation") %>%
  set_mode("classification")

wf <- workflow() %>%
  add_recipe(iris_recipe) %>%
  add_model(rf_model)

wf

Le modèle random forest utilise tune() pour hyperparams (trees, mtry). ranger comme engine pour vitesse et importance. Le workflow enchaîne recipe + model, rendant le pipeline modulaire et testable.

Tuning hyperparamétrique avec grid

05_tune_grid.R

folds <- vfold_cv(train_data, v = 5)

param_grid <- grid_regular(
  trees(range = c(100, 500)),
  mtry(range = c(1, 4)),
  levels = 3
)

tune_res <- tune_grid(
  wf,
  resamples = folds,
  grid = param_grid,
  metrics = metric_set(roc_auc, accuracy)
)

autoplot(tune_res)

Cross-validation 5-fold sur train, grid de 9 combos hyperparams via dials. Évalue AUC-ROC et accuracy. autoplot visualise ; sélectionnez le meilleur avec select_best(tune_res, "roc_auc") pour éviter l'overfitting.

Finalisation et évaluation

Après tuning, finalisez le workflow et prédisez sur test pour metrics réalistes. Tidymodels gère seamlessly le tout.

Fit final et prédictions

06_final_fit_predict.R

best_params <- select_best(tune_res, metric = "roc_auc")
final_wf <- finalize_workflow(wf, best_params)

final_fit <- fit(final_wf, data = train_data)

predictions <- predict(final_fit, test_data) %>%
  bind_cols(test_data %>% select(Species))

# Métriques finales
final_metrics <- predictions %>%
  conf_mat(truth = Species, estimate = .pred_class) %>%
  summary(roc_auc)
final_metrics

Finalise avec meilleurs params, fit sur train complet, prédit sur test. conf_mat et summary(roc_auc) donnent matrice de confusion et AUC. Piège : toujours évaluer sur held-out test pour estimer la généralisation réelle.

Importance des features et export

07_feature_importance_export.R

# Importance des features
final_fit %>%
  extract_fit_parsnip() %>%
  vip::vip(num_features = 4)

# Sauvegarde du modèle
saveRDS(final_fit, "iris_rf_model.rds")

# Chargement futur
# loaded_model <- readRDS("iris_rf_model.rds")
# predict(loaded_model, new_data = newdata)

Extrait l'importance via vip (installez si besoin : install.packages('vip')). Sauvegarde avec saveRDS pour déploiement. Idéal pour pipelines CI/CD ; chargez et prédisez sans re-fit.

Bonnes pratiques

Toujours stratifier les splits et folds pour classes déséquilibrées.
Utilisez metric_set() pour évaluer plusieurs métriques simultanément.
Intégrez themis pour upsampling en cas d'imbalance.
Versionnez workflows avec renv ou packrat pour reproductibilité.
Déployez via vetiver pour APIs REST scalables.

Erreurs courantes à éviter

Préprocesser sur tout le dataset avant split (data leakage fatale).
Ignorer le tuning : defaults sous-performent souvent de 10-15%.
Oublier set.seed() : résultats non reproductibles.
Évaluer uniquement sur train (optimisme bias).

Pour aller plus loin

Plongez dans les formations Learni sur R et ML. Lisez la doc tidymodels : tidymodels.org. Essayez xgboost ou neuralnets pour régression. Intégrez avec Plumber pour APIs.

Comment implémenter des pipelines ML avec tidymodels en R en 2026