Scikit-learn Pipelines: Streamlining ML Workflows

1. Qu'est-ce qu'un Pipeline et pourquoi en utiliser un ?

En machine learning, un projet typique implique une séquence d'étapes : nettoyage des données, imputation des valeurs manquantes, encodage des variables catégorielles, mise à l'échelle des variables numériques, et enfin, l'entraînement d'un modèle. Un pipeline Scikit-learn formalise cette séquence.

Fondamentalement, Scikit-learn distingue deux types d'objets :

• Les Transformers : Ils transforment les données. Ils possèdent des méthodes .fit() (pour apprendre les paramètres de transformation, ex: la moyenne et l'écart-type pour StandardScaler) et .transform() (pour appliquer la transformation). .fit_transform() est un raccourci pratique.
• Les Estimators : Ils estiment des paramètres à partir des données, typiquement un modèle. Ils possèdent une méthode .fit() (pour entraîner le modèle) et une méthode .predict() (pour faire des prédictions).

Un Pipeline est un objet qui permet d'enchaîner plusieurs "transformers" et de terminer par un "estimator".

Les principaux avantages de l'utilisation des pipelines sont :

• Propreté du code : Il regroupe une séquence complexe d'opérations en un seul objet.
• Prévention des fuites de données : Le pipeline garantit que les transformations sont apprises uniquement sur les données d'entraînement et simplement appliquées aux données de test.
• Facilité d'expérimentation : Il est très simple de changer une étape du pipeline (par exemple, essayer un autre modèle) sans réécrire tout le code.
• Optimisation simplifiée : Comme nous le verrons, il permet de rechercher les meilleurs hyperparamètres pour toutes les étapes du pipeline en même temps à l'aide de GridSearchCV.
• Déploiement facile : Vous pouvez sauvegarder l'intégralité du pipeline entraîné (prétraitement + modèle) en un seul fichier.

2. Construire un Pipeline pour des données mixtes

Le cas le plus courant est celui où votre jeu de données contient différents types de colonnes (numériques, catégorielles) qui nécessitent des traitements différents. On ne peut pas appliquer StandardScaler à une colonne de texte, par exemple. C'est là qu'intervient le ColumnTransformer.

Le ColumnTransformer est un outil puissant qui applique des transformateurs spécifiés à des colonnes spécifiques de votre jeu de données. La stratégie est la suivante :

1. Créer un petit pipeline pour les colonnes numériques (par exemple : imputer les valeurs manquantes, puis mettre à l'échelle).
2. Créer un autre petit pipeline pour les colonnes catégorielles (par exemple : imputer, puis encoder en one-hot).
3. Utiliser un ColumnTransformer pour appliquer ces pipelines aux bonnes colonnes. Cet objet devient notre "préprocesseur" global.
4. Créer un pipeline final qui enchaîne ce "préprocesseur" et notre modèle (l'estimateur).

La vidéo suivante, bien qu'en anglais, est un guide pas à pas exceptionnel qui met en œuvre exactement cette logique.

Le schéma ci-dessous représente parfaitement la structure que nous sommes en train de construire. On y voit bien les deux branches de traitement (catégorielle et numérique) qui sont gérées par un ColumnTransformer, dont le résultat est ensuite envoyé au modèle de régression logistique.

3. Assembler le Pipeline final

Une fois que notre preprocessor (le ColumnTransformer) est créé, il agit lui-même comme un seul et unique "transformer". L'étape finale consiste à le placer dans un Pipeline global, suivi de notre estimateur (le modèle de machine learning).

Le code final ressemble à quelque chose comme ça :

from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression




# 'preprocessor' est le ColumnTransformer que nous avons créé à l'étape précédente
# 'LogisticRegression()' est notre modèle

final_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])




# Entraîner le pipeline complet sur les données brutes
final_pipeline.fit(X_train, y_train)




# Faire des prédictions
predictions = final_pipeline.predict(X_test)

La beauté de cette approche est sa simplicité. Vous n'interagissez qu'avec l'objet final_pipeline, qui gère toute la complexité en interne.

4. La puissance cachée des Pipelines : L'optimisation d'hyperparamètres

L'un des avantages les plus significatifs de l'utilisation des pipelines apparaît lorsque l'on souhaite optimiser les hyperparamètres avec GridSearchCV. Un pipeline vous permet de rechercher simultanément les meilleurs hyperparamètres pour les étapes de prétraitement et pour le modèle.

Par exemple, vous pourriez vouloir tester si l'imputation par la moyenne est meilleure que par la médiane, tout en testant différentes valeurs pour l'hyperparamètre C de votre régression logistique. Avec un pipeline, c'est possible. Il suffit de définir la grille de paramètres en utilisant une syntaxe spéciale : nom_etape__parametre.

Cette vidéo en arabe explique très bien ce concept.

Par exemple, pour changer la stratégie d'imputation dans la branche numérique (num) de notre préprocesseur (preprocessor), le paramètre dans la grille de GridSearchCV serait :
'preprocessor__num__imputer__strategy': ['mean', 'median']

Pour changer l'hyperparamètre C du classifieur :
'classifier__C': [0.1, 1, 10]

GridSearchCV testera alors toutes les combinaisons pour trouver la meilleure configuration globale du pipeline.

Enfin, une fois votre pipeline optimal trouvé et entraîné, vous pouvez le sauvegarder sur disque en un seul fichier avec la bibliothèque joblib.

import joblib




# Sauvegarder le pipeline entraîné
joblib.dump(final_pipeline, 'mon_modele_complet.pkl')




# Charger le pipeline plus tard pour faire des prédictions
loaded_pipeline = joblib.load('mon_modele_complet.pkl')
predictions_nouvelles_donnees = loaded_pipeline.predict(nouvelles_donnees)

Conclusion

Cette leçon conclut notre parcours dans le monde du machine learning classique avec Scikit-learn. Vous avez maintenant une boîte à outils complète pour aborder une grande variété de problèmes.

Points clés à retenir :

• Les pipelines (Pipeline) enchaînent des étapes de transformation de données et se terminent par un modèle (estimateur).
• Le ColumnTransformer est essentiel pour gérer les données à types mixtes, en appliquant différents pipelines de prétraitement à différentes colonnes.
• L'assemblage de ces outils crée un objet unique et robuste qui simplifie l'entraînement, la prédiction et le déploiement.
• Les pipelines préviennent les fuites de données en appliquant correctement les transformations fit sur l'ensemble d'entraînement et transform sur l'ensemble de test.
• Ils débloquent une optimisation d'hyperparamètres puissante et globale via GridSearchCV en utilisant la syntaxe etape__parametre.

Dans le prochain module, nous allons changer de cap pour jeter les bases de l'apprentissage profond (deep learning) avec PyTorch. Nous commencerons par un concept fondamental de la programmation moderne : la Programmation Orientée Objet (POO) en Python, et plus particulièrement les classes. Cette idée d'encapsuler des données et des fonctionnalités dans des "objets", que vous venez d'expérimenter de manière conceptuelle avec les Pipelines, est absolument centrale à la conception des frameworks de deep learning comme PyTorch.