Prétraitement Scikit-learn: Maîtriser les pipelines de transformation de données pour l'apprentissage automatique

Dans le domaine de l'apprentissage automatique, la qualité de vos données a un impact direct sur les performances de vos modèles. Les données brutes contiennent souvent des incohérences, des valeurs manquantes et des échelles variables, ce qui les rend impropres à une utilisation directe. Scikit-learn, une puissante bibliothèque Python, fournit une suite complète de techniques de prétraitement pour transformer vos données dans un format adapté aux algorithmes d'apprentissage automatique. Cet article explore le monde du prétraitement Scikit-learn, en se concentrant sur la création et l'utilisation de pipelines de transformation de données pour rationaliser vos flux de travail d'apprentissage automatique.

Pourquoi le prétraitement des données est crucial

Le prétraitement des données est le processus de nettoyage, de transformation et d'organisation des données brutes pour les rendre plus adaptées aux modèles d'apprentissage automatique. C'est une étape essentielle car les algorithmes d'apprentissage automatique sont sensibles à l'échelle et à la distribution des caractéristiques d'entrée. Sans un prétraitement approprié, les modèles peuvent mal performer, entraînant des prédictions inexactes et des résultats peu fiables. Voici quelques raisons clés pour lesquelles le prétraitement des données est essentiel :

• Amélioration des performances du modèle : les données prétraitées permettent aux modèles d'apprendre plus efficacement et d'atteindre une plus grande précision.
• Gestion des valeurs manquantes : les techniques d'imputation comblent les points de données manquants, empêchant les algorithmes de se bloquer ou de produire des résultats biaisés.
• Normalisation des échelles des caractéristiques : les méthodes de mise à l'échelle garantissent que toutes les caractéristiques contribuent de la même manière au modèle, empêchant les caractéristiques avec des valeurs plus importantes de dominer le processus d'apprentissage.
• Encodage des variables catégorielles : les techniques d'encodage convertissent les données catégorielles en représentations numériques que les algorithmes d'apprentissage automatique peuvent comprendre.
• Réduction du bruit et des valeurs aberrantes : le prétraitement peut aider à atténuer l'impact des valeurs aberrantes et des données bruyantes, ce qui conduit à des modèles plus robustes.

Introduction aux pipelines Scikit-learn

Les pipelines Scikit-learn fournissent un moyen d'enchaîner plusieurs étapes de transformation de données en un seul objet réutilisable. Cela simplifie votre code, améliore la lisibilité et empêche la fuite de données lors de l'évaluation du modèle. Un pipeline est essentiellement une séquence de transformations de données suivie d'un estimateur final (par exemple, un classificateur ou un régresseur). Voici pourquoi les pipelines sont si bénéfiques :

• Organisation du code : les pipelines encapsulent l'intégralité du flux de travail de prétraitement des données et de modélisation en une seule unité, ce qui rend votre code plus organisé et plus facile à entretenir.
• Prévention de la fuite de données : les pipelines garantissent que les transformations de données sont appliquées de manière cohérente aux données d'entraînement et de test, empêchant la fuite de données, ce qui peut conduire au surapprentissage et à une mauvaise généralisation.
• Évaluation simplifiée du modèle : les pipelines facilitent l'évaluation des performances de votre modèle à l'aide de techniques telles que la validation croisée, car l'ensemble du flux de travail de prétraitement et de modélisation est appliqué de manière cohérente à chaque pli.
• Déploiement rationalisé : les pipelines peuvent être facilement déployés dans des environnements de production, garantissant que les données sont prétraitées de la même manière que lors de l'entraînement.

Techniques courantes de prétraitement des données dans Scikit-learn

Scikit-learn offre un large éventail de techniques de prétraitement. Voici quelques-unes des plus couramment utilisées :

1. Mise à l'échelle et normalisation

La mise à l'échelle et la normalisation sont des techniques utilisées pour transformer les caractéristiques numériques en une plage de valeurs similaire. Ceci est important car les caractéristiques avec des échelles différentes peuvent influencer de manière disproportionnée le processus d'apprentissage. Scikit-learn fournit plusieurs méthodes de mise à l'échelle et de normalisation :

• StandardScaler : normalise les caractéristiques en supprimant la moyenne et en mettant à l'échelle sur une variance unitaire. Il s'agit d'une technique largement utilisée qui suppose que les données suivent une distribution normale.

  Formule : x_scaled = (x - mean) / standard_deviation

  Exemple : Supposons que vous ayez des prix de logements en USD et en pieds carrés. La mise à l'échelle de ces caractéristiques garantit que le modèle n'accorde pas une importance excessive à la caractéristique avec des valeurs plus importantes (par exemple, les prix des logements).

• MinMaxScaler : met à l'échelle les caractéristiques dans une plage spécifiée, généralement entre 0 et 1. Ceci est utile lorsque vous souhaitez conserver la distribution d'origine des données.

  Formule : x_scaled = (x - min) / (max - min)

  Exemple : Le traitement d'images utilise souvent MinMaxScaler pour normaliser les valeurs des pixels dans la plage [0, 1].

• RobustScaler : met à l'échelle les caractéristiques à l'aide de statistiques robustes aux valeurs aberrantes, telles que la médiane et l'écart interquartile (IQR). C'est un bon choix lorsque vos données contiennent des valeurs aberrantes.

  Formule : x_scaled = (x - median) / IQR

  Exemple : Dans les ensembles de données financiers, où les valeurs aberrantes sont courantes (par exemple, les fluctuations extrêmes du marché boursier), RobustScaler peut fournir des résultats plus stables.

• Normalizer : normalise les échantillons individuellement sur une norme unitaire. Ceci est utile lorsque l'amplitude du vecteur de caractéristiques est plus importante que les valeurs de caractéristiques individuelles.

  Formule (norme L2) : x_scaled = x / ||x||

  Exemple : Dans le traitement de texte, la normalisation des vecteurs de fréquence des termes-fréquence inverse des documents (TF-IDF) est une pratique courante.

2. Encodage des variables catégorielles

Les algorithmes d'apprentissage automatique nécessitent généralement une entrée numérique, les variables catégorielles doivent donc être converties en représentations numériques. Scikit-learn propose plusieurs techniques d'encodage :

• OneHotEncoder : crée des colonnes binaires pour chaque catégorie de la caractéristique. Ceci convient aux caractéristiques catégorielles nominales (caractéristiques sans ordre inhérent).

  Exemple : L'encodage d'une caractéristique « pays » avec des valeurs telles que « USA », « Canada » et « UK » créerait trois nouvelles colonnes : « pays_USA », « pays_Canada » et « pays_UK ».

• OrdinalEncoder : affecte une valeur entière à chaque catégorie en fonction de son ordre. Ceci est approprié pour les caractéristiques catégorielles ordinales (caractéristiques avec un ordre significatif).

  Exemple : L'encodage d'une caractéristique « niveau d'éducation » avec des valeurs telles que « Lycée », « Licence » et « Master » affecterait des valeurs entières telles que 0, 1 et 2, respectivement.

• LabelEncoder : encode les étiquettes cibles avec des valeurs comprises entre 0 et n_classes-1. Utilisez ceci pour encoder la variable cible dans les problèmes de classification.

  Exemple : Encodage des étiquettes « spam » et « pas spam » comme 0 et 1 respectivement.

• TargetEncoder (nécessite la bibliothèque category_encoders) : encode les caractéristiques catégorielles en fonction de la moyenne de la variable cible pour chaque catégorie. Peut entraîner une fuite de la cible s'il n'est pas utilisé avec soin dans une configuration de validation croisée.

3. Gestion des valeurs manquantes

Les valeurs manquantes sont un problème courant dans les ensembles de données du monde réel. Scikit-learn fournit des techniques pour imputer (remplir) les valeurs manquantes :

• SimpleImputer : Impute les valeurs manquantes à l'aide d'une valeur constante, de la moyenne, de la médiane ou de la valeur la plus fréquente de la caractéristique.
• KNNImputer : Impute les valeurs manquantes à l'aide de l'algorithme des k plus proches voisins. Il trouve les k échantillons les plus proches de l'échantillon avec des valeurs manquantes et utilise la valeur moyenne de ces voisins pour imputer la valeur manquante.
• IterativeImputer : Impute les valeurs manquantes à l'aide d'une approche de modélisation itérative. Chaque caractéristique avec des valeurs manquantes est modélisée en fonction des autres caractéristiques, et les valeurs manquantes sont prédites de manière itérative.

4. Transformation des caractéristiques

La transformation des caractéristiques implique la création de nouvelles caractéristiques à partir de celles existantes. Cela peut améliorer les performances du modèle en capturant des relations non linéaires ou des interactions entre les caractéristiques. Certaines techniques incluent :

• PolynomialFeatures : Génère des combinaisons polynomiales de caractéristiques. Par exemple, si vous avez deux caractéristiques x1 et x2, PolynomialFeatures peut créer de nouvelles caractéristiques comme x1^2, x2^2, x1*x2.
• FunctionTransformer : Applique une fonction personnalisée aux caractéristiques. Cela vous permet d'effectuer des transformations arbitraires, telles que des transformations logarithmiques ou exponentielles.
• PowerTransformer : Applique une transformation de puissance pour rendre les données plus gaussiennes. Cela peut être utile pour les algorithmes qui supposent la normalité, tels que la régression linéaire. (Comprend les transformations Box-Cox et Yeo-Johnson)

Construction de pipelines de transformation de données avec Scikit-learn

Maintenant, mettons ces techniques de prétraitement en pratique en construisant des pipelines de transformation de données. Voici un guide étape par étape :

1. Importer les bibliothèques nécessaires

Commencez par importer les bibliothèques requises de Scikit-learn :

from sklearn.pipeline import Pipeline from sklearn.preprocessing import StandardScaler, OneHotEncoder, SimpleImputer from sklearn.compose import ColumnTransformer from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression import pandas as pd

2. Charger et préparer vos données

Chargez votre ensemble de données à l'aide de pandas ou de toute autre méthode appropriée. Identifiez les caractéristiques numériques et catégorielles de votre ensemble de données. Par exemple :

data = { 'age': [25, 30, 35, 40, 45, None], 'country': ['USA', 'Canada', 'USA', 'UK', 'Canada', 'USA'], 'salary': [50000, 60000, 70000, 80000, 90000, 55000], 'purchased': [0, 1, 0, 1, 0, 1] } df = pd.DataFrame(data)

3. Définir les étapes de prétraitement

Créez des instances des transformateurs de prétraitement que vous souhaitez utiliser. Par exemple, pour gérer les caractéristiques numériques, vous pouvez utiliser StandardScaler et SimpleImputer. Pour les caractéristiques catégorielles, vous pouvez utiliser OneHotEncoder. Envisagez d'inclure des stratégies pour gérer les valeurs manquantes avant la mise à l'échelle ou l'encodage.

numerical_features = ['age', 'salary'] categorical_features = ['country'] numerical_transformer = Pipeline(steps=[ ('imputer', SimpleImputer(strategy='mean')), ('scaler', StandardScaler()) ]) categorical_transformer = Pipeline(steps=[ ('onehot', OneHotEncoder(handle_unknown='ignore')) ])

4. Créer un ColumnTransformer

Utilisez ColumnTransformer pour appliquer différents transformateurs à différentes colonnes de vos données. Cela vous permet de prétraiter séparément les caractéristiques numériques et catégorielles.

preprocessor = ColumnTransformer( transformers=[ ('num', numerical_transformer, numerical_features), ('cat', categorical_transformer, categorical_features) ])

5. Construire le pipeline

Créez un objet Pipeline qui enchaîne les étapes de prétraitement avec un modèle d'apprentissage automatique. Cela garantit que les données sont prétraitées de manière cohérente avant d'être introduites dans le modèle.

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

6. Entraîner et évaluer le modèle

Divisez vos données en ensembles d'entraînement et de test. Ensuite, entraînez le pipeline sur les données d'entraînement et évaluez ses performances sur les données de test.

X = df.drop('purchased', axis=1) y = df['purchased'] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) pipeline.fit(X_train, y_train) score = pipeline.score(X_test, y_test) print(f'Model accuracy: {score}')

Exemple de code complet

Voici le code complet pour construire et entraîner un pipeline de transformation de données :

import pandas as pd from sklearn.pipeline import Pipeline from sklearn.preprocessing import StandardScaler, OneHotEncoder, SimpleImputer from sklearn.compose import ColumnTransformer from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression # Sample Data data = { 'age': [25, 30, 35, 40, 45, None], 'country': ['USA', 'Canada', 'USA', 'UK', 'Canada', 'USA'], 'salary': [50000, 60000, 70000, 80000, 90000, 55000], 'purchased': [0, 1, 0, 1, 0, 1] } df = pd.DataFrame(data) # Define features numerical_features = ['age', 'salary'] categorical_features = ['country'] # Create transformers numerical_transformer = Pipeline(steps=[ ('imputer', SimpleImputer(strategy='mean')), ('scaler', StandardScaler()) ]) categorical_transformer = Pipeline(steps=[ ('onehot', OneHotEncoder(handle_unknown='ignore')) ]) # Create preprocessor preprocessor = ColumnTransformer( transformers=[ ('num', numerical_transformer, numerical_features), ('cat', categorical_transformer, categorical_features) ]) # Create pipeline pipeline = Pipeline(steps=[('preprocessor', preprocessor), ('classifier', LogisticRegression())]) # Split data X = df.drop('purchased', axis=1) y = df['purchased'] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # Train model pipeline.fit(X_train, y_train) # Evaluate model score = pipeline.score(X_test, y_test) print(f'Model accuracy: {score}')

Techniques de pipeline avancées

Une fois que vous êtes à l'aise avec les bases, vous pouvez explorer des techniques de pipeline plus avancées :

1. Transformateurs personnalisés

Vous pouvez créer vos propres transformateurs personnalisés pour effectuer des transformations de données spécifiques qui ne sont pas disponibles dans Scikit-learn. Pour créer un transformateur personnalisé, vous devez hériter des classes TransformerMixin et BaseEstimator et implémenter les méthodes fit et transform. Cela peut être utile pour l'ingénierie des caractéristiques ou les transformations spécifiques au domaine. N'oubliez pas d'inclure des docstrings appropriées pour la lisibilité.

2. FeatureUnion

FeatureUnion vous permet de combiner la sortie de plusieurs transformateurs en un seul vecteur de caractéristiques. Ceci peut être utile lorsque vous souhaitez appliquer différentes transformations aux mêmes caractéristiques ou combiner des caractéristiques qui ont été transformées de différentes manières. La classe FeatureUnion est utilisée pour combiner la sortie de plusieurs transformateurs en un seul vecteur de caractéristiques.

3. Recherche de grille avec des pipelines

Vous pouvez utiliser GridSearchCV pour optimiser les hyperparamètres de votre pipeline, y compris les hyperparamètres des étapes de prétraitement. Cela vous permet de trouver automatiquement la meilleure combinaison de techniques de prétraitement et de paramètres de modèle. Soyez prudent quant à l'augmentation du coût de calcul.

Meilleures pratiques pour les pipelines de prétraitement des données

Voici quelques bonnes pratiques à garder à l'esprit lors de la création de pipelines de prétraitement des données :

• Comprendre vos données : avant d'appliquer des techniques de prétraitement, prenez le temps de comprendre vos données. Explorez les distributions de vos caractéristiques, identifiez les valeurs manquantes et recherchez les valeurs aberrantes.
• Documenter votre pipeline : ajoutez des commentaires à votre code pour expliquer chaque étape du pipeline. Cela facilitera la compréhension et la maintenance de votre code.
• Tester votre pipeline : testez minutieusement votre pipeline pour vous assurer qu'il fonctionne correctement. Utilisez des tests unitaires pour vérifier que chaque étape du pipeline produit la sortie attendue.
• Éviter la fuite de données : veillez à éviter la fuite de données lors du prétraitement de vos données. Assurez-vous que vous utilisez uniquement les informations des données d'entraînement pour prétraiter les données d'entraînement. Utilisez des pipelines pour garantir la cohérence entre les données d'entraînement et de test.
• Surveiller les performances : surveillez les performances de votre modèle au fil du temps et entraînez-le à nouveau si nécessaire. Les distributions de données peuvent changer au fil du temps, il est donc important de réévaluer périodiquement votre pipeline et d'apporter les ajustements nécessaires.

Exemples concrets

Explorons quelques exemples concrets de la manière dont les pipelines de transformation de données peuvent être utilisés dans différents secteurs :

• Finance : dans la modélisation du risque de crédit, les pipelines peuvent être utilisés pour prétraiter les données client, y compris les caractéristiques numériques telles que le revenu et la cote de crédit, ainsi que les caractéristiques catégorielles telles que le statut d'emploi et le but du prêt. Les valeurs manquantes peuvent être imputées à l'aide de techniques telles que l'imputation de la moyenne ou l'imputation des k plus proches voisins. La mise à l'échelle est cruciale pour s'assurer que les caractéristiques avec des échelles différentes ne dominent pas le modèle.
• Soins de santé : dans le diagnostic médical, les pipelines peuvent être utilisés pour prétraiter les données des patients, y compris les caractéristiques numériques telles que l'âge, la tension artérielle et le taux de cholestérol, ainsi que les caractéristiques catégorielles telles que le sexe et les antécédents médicaux. L'encodage One-hot peut être utilisé pour convertir les caractéristiques catégorielles en représentations numériques.
• Commerce électronique : dans les systèmes de recommandation de produits, les pipelines peuvent être utilisés pour prétraiter les données des clients et des produits, y compris les caractéristiques numériques telles que la fréquence d'achat et les évaluations des produits, ainsi que les caractéristiques catégorielles telles que la catégorie de produits et les données démographiques des clients. Les pipelines peuvent inclure des étapes de prétraitement du texte, telles que la tokenisation et la racinisation, pour extraire des caractéristiques des descriptions de produits et des avis des clients.
• Fabrication : dans la maintenance prédictive, les pipelines peuvent être utilisés pour prétraiter les données des capteurs provenant des machines, y compris les caractéristiques numériques telles que la température, la pression et les vibrations, ainsi que les caractéristiques catégorielles telles que le type de machine et les conditions de fonctionnement. RobustScaler peut être particulièrement utile ici en raison du potentiel de lectures aberrantes.

Relever les défis dans les ensembles de données mondiaux

Lorsque vous travaillez avec des ensembles de données mondiaux, vous rencontrerez souvent des défis spécifiques qui nécessitent une attention particulière lors du prétraitement. Voici quelques problèmes courants et des stratégies pour les résoudre :

• Formats de données variables : les dates, les nombres et les devises peuvent avoir des formats différents selon les régions. Assurez une analyse et un formatage cohérents. Par exemple, les dates peuvent être au format JJ/MM/AAAA ou MM/JJ/AAAA. Utilisez des bibliothèques appropriées pour gérer les conversions et le formatage des dates.
• Différences linguistiques : les données textuelles peuvent être dans différentes langues, ce qui nécessite des techniques de traduction ou de prétraitement spécifiques à la langue. Envisagez d'utiliser des bibliothèques telles que l'API Google Translate (avec des considérations d'utilisation et des implications de coûts appropriées) pour la traduction ou NLTK pour le traitement de texte spécifique à la langue.
• Conversion de devises : les données financières peuvent être exprimées dans différentes devises. Convertissez toutes les valeurs dans une devise commune à l'aide des taux de change à jour. Utilisez des API fiables pour obtenir des taux de change précis et en temps réel.
• Fuseaux horaires : les données de séries chronologiques peuvent être enregistrées dans différents fuseaux horaires. Convertissez tous les horodatages dans un fuseau horaire commun (par exemple, UTC) pour assurer la cohérence. Utilisez des bibliothèques comme pytz pour gérer les conversions de fuseaux horaires.
• Différences culturelles : les nuances culturelles peuvent affecter l'interprétation des données. Par exemple, les scores de satisfaction client peuvent être interprétés différemment selon les cultures. Soyez conscient de ces nuances et tenez-en compte lors de la conception de vos étapes de prétraitement.
• Problèmes de qualité des données : la qualité des données peut varier considérablement selon les différentes sources. Mettez en œuvre des procédures robustes de validation et de nettoyage des données pour identifier et corriger les erreurs.

Conclusion

Le prétraitement des données est une étape essentielle du pipeline d'apprentissage automatique. En utilisant les pipelines Scikit-learn, vous pouvez rationaliser votre flux de travail, empêcher la fuite de données et améliorer les performances de vos modèles. La maîtrise de ces techniques vous permettra de créer des solutions d'apprentissage automatique plus robustes et fiables pour un large éventail d'applications. N'oubliez pas d'adapter les étapes de prétraitement aux caractéristiques spécifiques de vos données et aux exigences de votre modèle d'apprentissage automatique. Expérimentez différentes techniques pour trouver la combinaison optimale pour votre problème particulier. En investissant du temps dans un prétraitement approprié des données, vous pouvez libérer tout le potentiel de vos algorithmes d'apprentissage automatique et obtenir des résultats supérieurs.