Prétraitement des données avec Sklearn
Le prétraitement des données est une étape critique dans les projets d'apprentissage automatique ; il affecte directement l'efficacité de l'entraînement du modèle et ses performances finales.
Lors de la construction de modèles d'apprentissage automatique, le prétraitement des données est une étape cruciale ; il nous aide à nettoyer et transformer les données brutes afin de fournir la meilleure entrée aux modèles d'apprentissage automatique.
Le prétraitement des données implique plusieurs étapes, notamment le traitement des valeurs manquantes, la transformation des données, la standardisation, l'encodage, etc.
Un prétraitement approprié améliore non seulement la précision du modèle, mais aide aussi le modèle à mieux généraliser.
1. Traitement des valeurs manquantes
Les valeurs manquantes désignent l'absence de valeurs pour certaines caractéristiques dans l'ensemble de données.
Les algorithmes d'apprentissage automatique ne peuvent généralement pas traiter directement les valeurs manquantes, nous devons donc les traiter.
Vérifier les valeurs manquantes
Tout d'abord, vérifiez si l'ensemble de données contient des valeurs manquantes.
Généralement, nous pouvons utiliser pandas pour inspecter les valeurs manquantes dans l'ensemble de données :
Exemple
# Supposons que nous ayons un DataFrame df
print(df.isnull().sum()) # Afficher le nombre de valeurs manquantes dans chaque colonne
Remplir les valeurs manquantes
La méthode la plus courante pour gérer les valeurs manquantes est l'imputation (le remplissage).
Les stratégies d'imputation courantes incluent :
- Imputation par la moyenne: Adaptée aux données numériques.
- Imputation par la médiane: Pour les jeux de données avec des valeurs aberrantes, l'utilisation de la médiane peut être plus efficace.
- Imputation par le mode (valeur la plus fréquente): Adaptée aux données catégorielles.
Dans scikit-learn, SimpleImputer peut facilement mettre en œuvre l'imputation des valeurs manquantes :
Exemple
# Pour les données numériques, utiliser l'imputation par la moyenne
imputer = SimpleImputer(strategy='mean') # Options : 'mean', 'median', 'most_frequent'
df_imputed = imputer.fit_transform(df) # Imputer les valeurs manquantes
Supprimer les valeurs manquantes
Si le nombre de valeurs manquantes est faible, et que leur suppression n'affecte pas significativement les résultats de l'analyse, une autre option consiste à supprimer directement les valeurs manquantes.
df_cleaned = df.dropna() # 删除包含缺失值的行Pour plus de détails, consultez :Nettoyage de données Pandas
2. Mise à l'échelle des données
Les algorithmes d'apprentissage automatique sont sensibles à l'échelle des données, donc les données doivent être mises à l'échelle afin que les caractéristiques aient la même échelle.
Les méthodes de mise à l'échelle courantes comprennent :
- Standardisation: Transformer les données pour qu'elles aient une moyenne de 0 et un écart-type de 1. Adaptée à la plupart des algorithmes d'apprentissage automatique.
- Normalisation: Mettre les données à l'échelle dans une plage spécifiée (généralement [0, 1]).
Normalisation
La standardisation peut être implémentée avec StandardScaler, qui transforme chaque caractéristique pour qu'elle ait une moyenne nulle et une variance unitaire :
Exemple
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X) # Standardiser X
Normalisation
La normalisation met chaque caractéristique à l'échelle dans une plage spécifiée (généralement [0, 1]).
MinMaxScaler est utilisé pour normaliser les données :
Exemple
scaler = MinMaxScaler()
X_normalized = scaler.fit_transform(X) # Normaliser X
Pourquoi avons-nous besoin de la standardisation et de la normalisation ?
Standardisation: Il est très important pour les métriques basées sur la distance (telles que les K plus proches voisins, les machines à vecteurs de support, etc.), car des échelles de caractéristiques incohérentes peuvent faire en sorte que certaines caractéristiques aient une influence trop importante sur le modèle. La standardisation garantit que chaque caractéristique contribue de manière égale au modèle.
Normalisation: Certains algorithmes (tels que les réseaux de neurones, les algorithmes d'optimisation par descente de gradient, etc.) sont très sensibles à la plage des données d'entrée. La normalisation aide à accélérer la convergence.
3. Encodage des variables catégorielles
Les modèles d'apprentissage automatique ne peuvent généralement pas traiter directement les variables catégorielles de type chaîne, donc les variables catégorielles doivent être converties en données numériques.
Les méthodes d'encodage courantes incluent :
Encodage par étiquettes
L'encodage par étiquettes associe chaque catégorie à un entier unique.
Adapté aux cas où il existe une relation d'ordre entre les catégories (par exemple, faible, moyen, élevé).
Exemple
# Supposons que nous ayons une variable catégorielle y
label_encoder = LabelEncoder()
y_encoded = label_encoder.fit_transform(y) # Convertir la variable catégorielle en entiers
Encodage one-hot
L'encodage one-hot convertit chaque catégorie en un vecteur binaire, adapté aux cas où il n'existe pas de relation d'ordre entre les catégories (par exemple, les couleurs, les pays, etc.).
OneHotEncoder peut convertir des variables catégorielles en encodage one-hot.
Exemple
# Supposons que nous ayons une variable catégorielle X
encoder = OneHotEncoder(sparse=False) # sparse=False renvoie une matrice dense
X_encoded = encoder.fit_transform(X) # Convertit la variable catégorielle en encodage one-hot
Dans pandas, la fonction get_dummies() peut également être utilisée pour l'encodage one-hot :
X_encoded = pd.get_dummies(X)
4. Sélection de caractéristiques
La sélection de caractéristiques améliore les performances du modèle en sélectionnant les caractéristiques les plus importantes et réduit le coût de calcul.
Les méthodes courantes de sélection de caractéristiques incluent :
Sélection de caractéristiques basée sur un modèle
Utiliser certains modèles d'apprentissage automatique (tels queles arbres de décisionoules forêts aléatoires) pour évaluer l'importance des caractéristiques, et ainsi effectuer une sélection de caractéristiques.
Exemple
# Entraîner un modèle de forêt aléatoire
clf = RandomForestClassifier()
clf.fit(X_train, y_train)
# Obtenir l'importance des caractéristiques
importances = clf.feature_importances_
print(importances)
Élimination récursive des caractéristiques (RFE)
RFE est une méthode qui supprime récursivement, étape par étape, les caractéristiques les moins importantes afin de sélectionner les caractéristiques optimales.
RFE peut nous aider à sélectionner automatiquement les caractéristiques importantes.
Exemple
# Utiliser un modèle linéaire pour l'élimination récursive des caractéristiques
rfe = RFE(clf, n_features_to_select=3) # Conserver les 3 caractéristiques les plus importantes
X_rfe = rfe.fit_transform(X_train, y_train)
5. Ingénierie des caractéristiques
L'ingénierie des caractéristiques vise à améliorer les performances du modèle en traitant, combinant ou construisant de nouvelles caractéristiques à partir de celles existantes.
Les méthodes courantes d'ingénierie des caractéristiques incluent :
- Combinaison de caractéristiques: Combiner deux caractéristiques ou plus en une nouvelle caractéristique.
- Transformation de caractéristiques: Appliquer des transformations telles que des transformations logarithmiques ou de racine carrée aux caractéristiques pour traiter la non-linéarité des données.
- Création de caractéristiques: Créer de nouvelles caractéristiques à partir de données existantes, comme extraire la date, le mois, le jour de la semaine, etc., à partir d'un horodatage.
Exemple
df['new_feature'] = df['feature1'] * df['feature2']
6. Extraction de caractéristiques
L'extraction de caractéristiques vise à extraire de nouvelles caractéristiques plus expressives à partir des caractéristiques d'origine.
Les méthodes courantes d'extraction de caractéristiques incluent :Analyse en composantes principales (ACP)etAnalyse discriminante linéaire (ADL)。
Analyse en composantes principales (ACP)
L'ACP est une technique de réduction de dimension couramment utilisée qui projette les données d'un espace de grande dimension vers un espace de dimension inférieure via une transformation linéaire, ce qui permet aux nouvelles caractéristiques (composantes principales) de préserver autant de variance que possible.
L'ACP est particulièrement adaptée lorsqu'il y a trop de caractéristiques, car elle peut réduire efficacement la complexité de calcul.
Exemple
# Supposons que X est la matrice de caractéristiques
pca = PCA(n_components=2) # Réduire à 2 composantes principales
X_pca = pca.fit_transform(X)
PCA est principalement utilisé dans deux scénarios :
- Réduction de dimensionnalité: Lorsqu'il y a trop de caractéristiques, utiliser PCA pour la réduction de dimensionnalité peut réduire le coût de calcul tout en conservant l'information principale des données.
- Visualisation: Projeter des données de grande dimension dans un espace 2D ou 3D pour nous aider à visualiser la structure des données.
Analyse discriminante linéaire (LDA)
LDA est une méthode de réduction de dimensionnalité en apprentissage supervisé qui vise à trouver une combinaison linéaire qui maximise la distance entre les différentes classes et minimise la distance au sein des classes.
LDA est couramment utilisée dans les tâches de classification.
Exemple
# Supposons que X est la matrice de caractéristiques et que y est la variable cible
lda = LinearDiscriminantAnalysis(n_components=2) # Réduire la dimensionnalité à 2 composantes discriminantes linéaires
X_lda = lda.fit_transform(X, y)
7. Gestion des données déséquilibrées
Dans les problèmes de classification, si le nombre d'échantillons entre les classes du jeu de données varie fortement, le modèle peut devenir biaisé en faveur de la prédiction de la classe majoritaire, ce qui affecte les performances du modèle.
Les méthodes de gestion courantes incluent :
Sur-échantillonnage
Équilibrer le jeu de données en augmentant le nombre d'échantillons dans la classe minoritaire.
Une méthode courante consiste à utiliser l'algorithme SMOTE (Synthetic Minority Over-sampling Technique).
Exemple
smote = SMOTE()
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)
Sous-échantillonnage
Équilibrer le jeu de données en réduisant le nombre d'échantillons dans la classe majoritaire.
Exemple
undersampler = RandomUnderSampler()
X_resampled, y_resampled = undersampler.fit_resample(X_train, y_train)