Tidymodels : une approche claire pour la modélisation et le machine learning avec R

Durant cette semaine, j’ai décidé de partager une série d’articles de blog avec vous pour vous aider à maîtriser le framework tidymodels. Ce framework est très utile pour la modélisation et le machine learning en utilisant le langage de programmation R. L’ensemble d’outils que tidymodels fournit permet de simplifier les différentes étapes de la modélisation, de la préparation des données jusqu’à l’évaluation des modèles. Il est vrai que ce framework n’est pas aussi complet que scikit-learn en termes de fonctionnalités, mais il est en constante évolution et présente de nombreux avantages.J’estime que cet écosystème (tidyverse) devrait être enseigné davantage dans les universités, car il offre une approche claire et bien structurée pour les projets de machine learning. En effet, la réussite d’un projet de ML repose sur la clarté de l’approche adoptée, incluant le prétraitement des données et les différentes méthodes de modélisation et d’ingénierie de caractéristiques employées. Tidymodels permet de visualiser toutes ces étapes et d’avoir une vue d’ensemble du processus de modélisation, ce qui facilite la compréhension et l’interprétation des résultats.

Qu’est-ce que vous découvrirez dans cet article ?

• • Tidymodels : un unificateur de packages
  • Tidymodels : une boîte à outil de prétraitement
  • Tidymodels : un workflow de modélisation claire
  • Autres packages interressants

Tidymodels : un unificateur de packages

Outre la clarté de l’approche de tidymodels pour la modélisation, une des raisons principales de l’utiliser est sa capacité à rassembler en un seul endroit l’ensemble des packages et fonctions préférés pour la modélisation sur R, grâce à son package parsnip. Par exemple, si vous souhaitez effectuer une forêt aléatoire, vous avez le choix entre plusieurs bibliothèques telles que ranger ou randomForest, tandis que pour une simple régression linéaire pénalisée, vous pourriez utiliser glmnet, stan, etc. Ces packages ont souvent des structures différentes, avec des noms de paramètres, des valeurs d’entrée et de sortie différents. Tidymodels permet d’uniformiser tout cela en fournissant un ensemble cohérent d’outils pour les différentes étapes de modélisation, et en facilitant l’utilisation de différents packages pour des tâches spécifiques.

Dans l’exemple ci-dessous, j’ai construit un modèle de forêt aléatoire en utilisant deux packages différents : ranger et randomForest. Cette flexibilité est rendue possible grâce à l’utilisation du package parsnip, qui est chargé en même temps que tidymodels. 

#install.packages("tidymodels")
library(tidymodels)

# package ranger
rf_model = rand_forest(trees = 1000, min_n = 5) %>% 
        set_engine("ranger") %>% 
        set_mode("classification")

rf_model %>% translate()

Random Forest Model Specification (classification)

Main Arguments:
  trees = 1000
  min_n = 5

Computational engine: ranger 

Model fit template:
ranger::ranger(x = missing_arg(), y = missing_arg(), weights = missing_arg(), 
    num.trees = 1000, min.node.size = min_rows(~5, x), num.threads = 1, 
    verbose = FALSE, seed = sample.int(10^5, 1), probability = TRUE)

# package randomForest
rf_model = rand_forest(trees = 1000, min_n = 5) %>% 
  set_engine("randomForest") %>% 
  set_mode("classification")

rf_model %>% translate()

Random Forest Model Specification (classification)

Main Arguments:
  trees = 1000
  min_n = 5

Computational engine: randomForest 

Model fit template:
randomForest::randomForest(x = missing_arg(), y = missing_arg(), 
   ntree = 1000, nodesize = min_rows(~5, x))

En observant la zone surlignée, vous pouvez remarquer que les deux packages ne nomment pas les mêmes paramètres, par exemple pour désigner le nombre d’arbres et le nombre minimal de nœuds. Cependant, des noms de paramètres uniques, tels que “tree” et “min_n”, sont fournis pour faire référence à ces paramètres. Cela montre que tidymodels unifie les noms de fonctions et de paramètres, ce qui facilite l’utilisation de différents packages pour effectuer différentes tâches.

Pour ajuster le modèle avec des données, vous pouvez choisir entre deux fonctions : fit(), qui prend en paramètre une formule R, et fit_xy(), qui prend en paramètre x pour les variables explicatives et y pour la variable cible.

rf_model_fit = rf_model %>% fit(y ~ x1 + x2, data = data) 
rf_model_fit = rf_model %>% fit_xy(x=X, y=y)

La prédiction s’effectue extrèment simplement en utilisant la fonction unique predict() avec des paramètres et les sorties qui sont aussi uniformisées.

predict(rf_model_fit, new_data = data_test)

Tidymodels : une boîte à outil de prétraitement

Le prétraitement des données est une étape cruciale dans le processus de modélisation. Avant de créer un modèle, les données brutes doivent être nettoyées, transformées et préparées. Le package Recipe de Tidymodels est un outil puissant qui facilite le prétraitement des données en fournissant une interface cohérente pour les tâches courantes de prétraitement. 

Supposons que vous disposez d’un jeu de données nommé “data” contenant à la fois des variables quantitatives et qualitatives. Vous souhaitez appliquer une Analyse en Composantes Principales (ACP) sur les variables quantitatives et encoder les variables qualitatives avec l’encodage “one-hot” avant de procéder à l’ajustement du modèle. Pour ce faire, les fonctions “step” de la bibliothèque “recipe” permettent de réaliser cette tâche facilement et de manière explicite.

recipe_rf <- recipe(y ~ ., data = data) %>%
  # Ajouter une étape d'ACP pour réduire la dimensionnalité des données
  step_pca(all_numeric(), num_comp = 2)
  # Encodage des variables qualitatives
  step_dummy(all_nominal(), one_hot = TRUE)

Diverses fonctions de prétraitement sont disponibles avec la librairie recipe, notamment l’imputation des valeurs manquantes, la normalisation, le regroupement des variables qualitatives, etc. Il est également possible de créer sa propre étape de prétraitement. 

Tidymodels : un workflow de modélisation claire

Le package “workflows” de tidymodels permet d’enchaîner facilement les étapes clés de la modélisation, notamment le prétraitement des données et l’ajustement des modèles. Il fournit une interface cohérente pour spécifier un flux de travail de modélisation, en utilisant une syntaxe claire et intuitive. Avec “workflows”, vous pouvez créer un pipeline de modélisation en définissant les étapes successives de traitement des données, telles que la normalisation, l’imputation de valeurs manquantes ou la sélection de variables. Vous pouvez également spécifier différentes méthodes de modélisation, telles que la régression linéaire, la régression logistique ou les arbres de décision, et ajuster ces modèles à vos données. De plus, “workflow” facilite la réutilisation de code et la collaboration en permettant de stocker toutes les étapes du processus de modélisation dans un objet unique et en le partageant avec d’autres membres de l’équipe ou avec la communauté.

# workflow pour la modélisation
rf_workflow <- workflow() %>% 
  add_recipe(recipe_rf) %>% 
  add_model(rf_model)

Autres packages interressants

Il existent d’autres packages qui sont également indispasble pour travailler avec Tidymodels.

Le package rsample 

Le package rsample est conçue pour faciliter la division des données en échantillons pour les tâches d’apprentissage automatique, telles que l’évaluation des modèles et l’optimisation des hyperparamètres. Il fournit une interface commune pour créer des jeux de données de formation et de test à partir de jeux de données bruts, ainsi que pour effectuer une validation croisée. le code ci-dessous fournit un exemple de division des données en apprentissage et test grâce aux fonctions de rsample.

set.seed(123)
# partitionnement en train et test
set.seed(123)
data_split <- initial_split(data, prop = 0.7)
train_data <- training(data_split)
test_data <- testing(data_split)

Le package yardstick

Le package yardstick est un package de Tidymodels qui fournit des outils pour évaluer les performances des modèles de machine learning. Il inclut une variété de métriques de performance couramment utilisées pour les modèles supervisés, telles que la précision, le rappel, la F1-score, l’aire sous la courbe ROC (AUC-ROC) et bien d’autres encore. Le package yardstick est utilisé en combinaison avec le package tidyverse, ce qui rend l’analyse des résultats de modèles plus facile et plus cohérente.

Voici un exemple d’utilisation de yardstick pour évaluer les performances d’un modèle avec la fonctions metrics.

rf_model_fit = rf_workflow %>% fit()

# Faire des prédictions sur l'ensemble de test
pred <- predict(rf_model_fit, new_data = test_data)
# Évaluer la performance du modèle c
metrics_values <- pred %>% metrics(truth, estimate = .pred_class)
# Afficher les métriques de performance
metrics_values

Le package tune 

Le package tune est permet de réaliser une recherche d’hyperparamètres pour un modèle donné. Il est conçu pour vous aider à ajuster les hyperparamètres de votre modèle pour améliorer sa performance. Il fournit plusieurs méthodes pour rechercher les meilleurs hyperparamètres, telles que la recherche aléatoire, la recherche en grille, la recherche par optimisation bayésienne, etc. Il est fournit un cadre unique pour optimiser les hyperparamètres des modèles. Je ferai article dans les prochains consacrés uniquement à ce package.

Conclusion 

J’espère que cet article vous a aidé à mieux comprendre le fonctionnement de tidymodels, et que vous choisirez désormais cet outil pour vos projets de Machine Learning avec R. N’hésitez pas à consulter la documentation de tidymodels qui, bien qu’elle ne soit pas aussi exhaustive que celle de scikit-learn, présente des cas d’utilisation pratiques très intéressants.

voir aussi :  Construction d’un modèle de classification avec tidymodels (pas encore disponible)