Apprendre Estimateur final

Glissez pour afficher le menu

Pipeline était auparavant utilisé pour la prétraitement, mais son véritable objectif est de chaîner le prétraitement avec un prédicteur final. La dernière étape d'un pipeline peut être n'importe quel estimateur (généralement un modèle) qui produit des prédictions.

Note

Lors de l'appel de .fit(), chaque transformateur exécute .fit_transform(). Lors de l'appel de .predict(), le pipeline utilise .transform() avant d'envoyer les données à l'estimateur final. Cela est nécessaire car les nouvelles données doivent être transformées exactement comme les données d'entraînement.

Pourquoi utiliser `.transform()` ?

Utiliser .fit_transform() sur de nouvelles données peut modifier les encodages (par exemple, dans OneHotEncoder), créant des colonnes non correspondantes et des prédictions peu fiables. .transform() garantit un prétraitement cohérent, en ignorant les catégories inconnues et en conservant le même ordre de colonnes.

Voici le jeu de données original avant toute transformation. Ces données brutes constituent le point de départ du processus de transformation. Aucun encodage ou prétraitement n'a encore été appliqué—chaque ligne présente une instance avec sa caractéristique de couleur sous forme de chaîne de caractères. Ce sont ces données qui seront transformées à l'aide des étapes de prétraitement dans le pipeline.

Ce tableau présente le jeu de données avant l'encodage one-hot. La colonne Color est catégorielle—elle contient des valeurs textuelles au lieu de nombres. Vous allez transformer cette colonne en colonnes binaires distinctes à l'étape suivante en utilisant l'encodage one-hot, ce qui est essentiel pour que la plupart des modèles d'apprentissage automatique puissent traiter correctement les données catégorielles.

Voici à quoi ressemble un jeu de données d'entraînement après encodage one-hot :

Le tableau ci-dessous présente le jeu de données après application de l'encodage one-hot. La colonne Color d'origine a été remplacée par des colonnes binaires distinctes—Color_Red, Color_Blue et Color_Green. Chaque colonne indique si l'observation possède cette couleur spécifique (1) ou non (0).

Remarquez comment la colonne unique d'origine Color a été remplacée par trois colonnes distinctes : Color_Red, Color_Blue et Color_Green. Chaque colonne indique si une couleur spécifique est présente pour cette instance, en utilisant 1 pour oui et 0 pour non. Cette transformation s'appelle l'encodage one-hot.

Ce changement est essentiel pour les modèles d'apprentissage automatique, car la plupart des algorithmes ne peuvent pas traiter directement les données textuelles ou catégorielles. En convertissant les catégories en colonnes binaires séparées, vous fournissez au modèle des caractéristiques numériques claires qu'il peut utiliser pour apprendre des motifs et faire des prédictions. Cette approche empêche également le modèle de supposer une relation ordinale entre les catégories d'origine, ce qui pourrait conduire à des conclusions erronées.

Voici les nouvelles instances à prédire :

Voici les nouvelles données sur lesquelles vous souhaitez effectuer des prédictions. Il s'agit de l'entrée brute—l'état « avant »—telle qu'elle apparaît avant toute transformation ou prétraitement. Le pipeline va transformer ces données pour correspondre au format utilisé lors de l'entraînement avant de réaliser des prédictions.

L'étape suivante consiste à transformer ces nouvelles instances à l'aide de l'encodeur précédemment ajusté. Cela garantit que les nouvelles données sont traitées de la même manière que les données d'entraînement, assurant ainsi la cohérence et la fiabilité des prédictions du modèle.

Si .fit_transform() était appliqué à de nouveaux exemples, le OneHotEncoder pourrait générer des colonnes dans un ordre différent ou même en introduire de nouvelles. Cela entraînerait une transformation des nouvelles données incohérente avec l'ensemble d'entraînement, rendant les prédictions peu fiables.

Si vous utilisez .fit_transform() sur de nouvelles données au lieu de .transform(), l'encodeur considérera ces nouvelles données comme si elles étaient vues pour la première fois. Cela l'amène à :

Réapprendre les catégories à partir des nouvelles données ;
Modifier l'ordre des colonnes en fonction du nouvel ensemble de catégories ;
Ajouter une nouvelle colonne pour toute catégorie inconnue, comme 'Color_Yellow' dans ce cas.

Cela crée une incohérence entre les données d'entraînement et de prédiction, rendant les prédictions peu fiables et pouvant entraîner des erreurs dans votre pipeline.

Remarquer la différence entre la transformation incorrecte et la transformation correcte. Le tableau avec la transformation incorrecte inclut une nouvelle colonne (Color_Yellow) et modifie l'ordre des colonnes par rapport aux données d'entraînement. Cela rompt la cohérence entre l'entraînement et la prédiction :

Le modèle attend les mêmes colonnes et le même ordre qu'au moment de l'entraînement ;
Les colonnes nouvelles ou réordonnées perturbent le modèle, qui utilise alors les mauvaises caractéristiques ;
Les prédictions deviennent peu fiables car la structure d'entrée ne correspond plus à ce que le modèle a appris.

Toujours s'assurer que les nouvelles données sont transformées avec .transform() après l'ajustement, afin que les colonnes et leur ordre restent cohérents. Ceci est essentiel pour obtenir des prédictions précises et fiables.

Cependant, l'utilisation de .transform() garantit que les nouvelles données sont encodées exactement comme les données d'entraînement, en ignorant les catégories non vues lors de l'entraînement :

Lorsque .transform() est utilisé sur de nouvelles données, seules les colonnes issues de l'entraînement sont incluses dans la sortie. Toute catégorie non vue lors de l'entraînement—comme 'Yellow'—est ignorée. Cela garantit que les nouvelles données correspondent à la structure attendue par le modèle, sans colonne supplémentaire ou manquante.

Comparaison des trois tableaux :

Les données d'entraînement originales (après encodage one-hot) possèdent des colonnes pour Color_Red, Color_Blue et Color_Green ;
Les nouvelles données transformées de manière incorrecte (avec .fit_transform()) ajoutent une colonne Color_Yellow et suppriment Color_Green, modifiant ainsi l'ordre et la structure des colonnes ;
Les nouvelles données transformées correctement (avec .transform()) conservent les mêmes colonnes et le même ordre que l'ensemble d'entraînement, avec des zéros pour les catégories non vues comme Yellow.

L'utilisation de .transform() est la bonne approche car elle garantit que les nouvelles données sont traitées exactement de la même manière que les données d'entraînement. Cela assure que le modèle reçoit les données dans le format attendu, évitant ainsi les erreurs et rendant les prédictions fiables.

Ajout de l'estimateur final

Ajouter simplement le modèle comme dernière étape du pipeline :

pipe = make_pipeline(
    ct,
    SimpleImputer(strategy='most_frequent'),
    StandardScaler(),
    KNeighborsClassifier()
)
pipe.fit(X, y)
pipe.predict(X_new)

Cela permet à l'ensemble du flux de travail—prétraitement + prédiction—de s'exécuter en une seule commande.


              12345678910111213141516171819202122232425262728293031323334353637
            
from sklearn.pipeline import make_pipeline
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
import pandas as pd

# Example data
data = pd.DataFrame({
    'color': ['red', 'blue', 'green'],
    'value': [1, 2, 3]
})
labels = [0, 1, 0]

# Define a simple column transformer (placeholder for real preprocessing)
ct = ColumnTransformer([
    ('imputer', SimpleImputer(strategy='most_frequent'), ['color'])
])

# --- Before: Pipeline with only preprocessing steps ---
# This pipeline only transforms the data; it cannot make predictions.
pipeline_preprocessing = make_pipeline(
    ct,
    StandardScaler()
)
# pipeline_preprocessing.fit(data)  # Only fits transformers, no estimator at the end

# --- After: Pipeline with a final estimator ---
# Now the pipeline ends with a model, so it can fit and predict.
pipeline_full = make_pipeline(
    ct,
    StandardScaler(),
    KNeighborsClassifier()
)
pipeline_full.fit(data, labels)
predictions = pipeline_full.predict(data)
print("Predictions:", predictions)

L'ajout de l'estimateur final comme dernière étape transforme votre pipeline en un flux de travail complet de bout en bout. Au lieu de simplement préparer vos données, le pipeline gère désormais à la fois la prétraitement et la prédiction dans un seul objet. Cela signifie que vous pouvez appeler directement fit() et predict() sur le pipeline, et il appliquera automatiquement toutes les étapes de prétraitement avant de faire des prédictions.

Cette approche est importante car :

Elle garantit que toutes les données sont traitées exactement de la même manière lors de l'entraînement et de la prédiction ;
Elle réduit le risque d'erreurs, comme oublier une étape de prétraitement lors de la prédiction sur de nouvelles données ;
Elle rend votre code plus clair et plus facile à maintenir, puisque l'ensemble du flux de travail est géré en un seul endroit.

En enchaînant prétraitement et modélisation, vous assurez cohérence, fiabilité et simplicité dans vos projets de machine learning.

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 5

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Section 3. Chapitre 5

Estimateur final

Pourquoi utiliser .transform() ?

Ajout de l'estimateur final

Pourquoi utiliser `.transform()` ?