Introduction
Dans scikit-learn, les pipelines et les estimateurs composites sont utilisés pour combiner plusieurs transformateurs et estimateurs en un seul modèle. Cela est utile lorsqu'il existe une séquence fixe d'étapes pour traiter les données, telles que la sélection de caractéristiques, la normalisation et la classification. Les pipelines peuvent également être utilisés pour la sélection conjointe de paramètres et pour s'assurer que les statistiques issues des données de test ne fuitent pas dans le modèle entraîné lors de la validation croisée.
Conseils sur la machine virtuelle
Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.
Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.
Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.
Pipeline - Chaînage d'estimateurs
La classe Pipeline dans scikit-learn est utilisée pour chaîner plusieurs estimateurs en un seul. Cela vous permet d'appeler fit et predict une seule fois sur vos données pour ajuster une séquence complète d'estimateurs. Cela permet également une sélection conjointe de paramètres et aide à éviter les fuites de données lors de la validation croisée.
Pour créer un pipeline, vous devez fournir une liste de paires (clé, valeur), où la clé est une chaîne de caractères pour identifier chaque étape et la valeur est un objet estimateur. Voici un exemple de création d'un pipeline avec un transformateur PCA et un classifieur SVM :
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC
from sklearn.decomposition import PCA
estimators = [('reduce_dim', PCA()), ('clf', SVC())]
pipe = Pipeline(estimators)
Vous pouvez accéder aux étapes d'un pipeline en utilisant l'indexation ou par nom :
pipe.steps[0] ## accéder par index
pipe[0] ## équivalent à ce qui précède
pipe['reduce_dim'] ## accéder par nom
Vous pouvez également utiliser la fonction make_pipeline comme raccourci pour construire des pipelines :
from sklearn.pipeline import make_pipeline
from sklearn.naive_bayes import MultinomialNB
from sklearn.preprocessing import Binarizer
make_pipeline(Binarizer(), MultinomialNB())
Paramètres imbriqués
Vous pouvez accéder aux paramètres des estimateurs dans un pipeline en utilisant la syntaxe <estimateur>__<paramètre>. Cela est utile pour effectuer des recherches de grille sur les paramètres de tous les estimateurs dans le pipeline. Voici un exemple :
pipe.set_params(clf__C=10)
Mémorisation des transformateurs
La mise en forme des transformateurs peut être coûteuse en termes de calcul. Pour éviter les calculs répétés, vous pouvez activer la mémorisation des transformateurs dans un pipeline en utilisant le paramètre memory. Ce paramètre peut être défini sur un répertoire où les transformateurs seront mis en cache, ou sur un objet joblib.Memory. Voici un exemple :
from sklearn.decomposition import PCA
from sklearn.svm import SVC
from sklearn.pipeline import Pipeline
from tempfile import mkdtemp
from shutil import rmtree
estimators = [('reduce_dim', PCA()), ('clf', SVC())]
cachedir = mkdtemp()
pipe = Pipeline(estimators, memory=cachedir)
## Supprimez le répertoire de cache lorsque vous n'en avez plus besoin
rmtree(cachedir)
TransformedTargetRegressor
La classe TransformedTargetRegressor est utilisée pour transformer la variable cible dans un problème de régression avant d'ajuster un modèle de régression. Cela est utile lorsque vous voulez appliquer une transformation à la variable cible, telle que prendre le logarithme. Les prédictions sont ramenées à l'espace d'origine via une transformation inverse. Voici un exemple d'utilisation de TransformedTargetRegressor avec un modèle de régression linéaire et un transformateur quantile :
import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.compose import TransformedTargetRegressor
from sklearn.preprocessing import QuantileTransformer
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
X, y = fetch_california_housing(return_X_y=True)
transformer = QuantileTransformer(output_distribution='normal')
regressor = LinearRegression()
regr = TransformedTargetRegressor(regressor=regressor, transformer=transformer)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
regr.fit(X_train, y_train)
regr.score(X_test, y_test)
FeatureUnion - Espaces de caractéristiques composites
La classe FeatureUnion est utilisée pour combiner plusieurs objets transformateurs en un nouveau transformateur qui combine leur sortie. Cela est utile lorsque vous voulez appliquer différentes transformations à différentes caractéristiques des données, par exemple le prétraitement du texte, des nombres à virgule flottante et des dates séparément. Les transformateurs sont appliqués en parallèle, et les matrices de caractéristiques qu'ils produisent sont concaténées côte à côte pour former une matrice plus grande. Voici un exemple :
from sklearn.pipeline import FeatureUnion
from sklearn.decomposition import PCA
from sklearn.decomposition import KernelPCA
estimators = [('linear_pca', PCA()), ('kernel_pca', KernelPCA())]
combined = FeatureUnion(estimators)
Sommaire
Les pipelines et les estimateurs composites sont des outils puissants dans scikit-learn pour combiner des transformateurs et des estimateurs en un seul modèle. Ils offrent une commodité, une sélection de paramètres et une sécurité des données. Les pipelines permettent de chaîner des estimateurs, d'avoir des paramètres imbriqués et de mémoriser les transformateurs. Les estimateurs composites comme TransformedTargetRegressor et FeatureUnion offrent respectivement des transformations et une combinaison de caractéristiques. Ces concepts sont essentiels pour construire des modèles de machine learning complexes qui prétraitent et gèrent efficacement des données hétérogènes.