Prétraitement des données avec Scikit-learn

Introduction

Bienvenue dans le laboratoire de prétraitement de données scikit-learn. En apprentissage automatique (machine learning), la qualité de vos données a un impact direct sur les performances de votre modèle. Les données brutes sont souvent désordonnées, incohérentes et ne sont pas dans le format optimal pour les algorithmes. Le prétraitement des données est une étape cruciale qui consiste à nettoyer et transformer les données pour les rendre adaptées à un modèle d'apprentissage automatique.

Dans ce laboratoire, vous apprendrez à effectuer deux tâches de prétraitement fondamentales à l'aide de la bibliothèque scikit-learn :

• Mise à l'échelle des caractéristiques (Feature Scaling) : Standardiser la plage des variables indépendantes ou des caractéristiques des données.
• Encodage des étiquettes (Label Encoding) : Convertir les étiquettes catégorielles en un format numérique.

Nous utiliserons le célèbre jeu de données Iris, qui est inclus de manière pratique avec scikit-learn, pour pratiquer ces techniques. À la fin de ce laboratoire, vous aurez une solide compréhension de la manière de préparer vos données pour les pipelines d'apprentissage automatique.

Séparer les données en caractéristiques et cible avec X = iris.data, y = iris.target

Dans cette étape, nous allons commencer par charger le jeu de données Iris et le séparer en caractéristiques et en variable cible. En apprentissage automatique, X est la notation conventionnelle pour les caractéristiques (les variables d'entrée), et y est la notation pour la cible (la variable de sortie que vous souhaitez prédire).

La bibliothèque scikit-learn fournit le jeu de données Iris via son module datasets. L'objet de jeu de données chargé se comporte comme un dictionnaire.

Structure du jeu de données Iris :

• iris.data : Matrice des caractéristiques (150 échantillons × 4 caractéristiques)
• iris.target : Étiquettes cibles (150 échantillons)
• iris.feature_names : Noms des 4 caractéristiques
• iris.target_names : Noms des 3 espèces de fleurs

Pourquoi séparer X et y ?

• X : Caractéristiques d'entrée (ce à partir de quoi le modèle apprend)
• y : Étiquettes cibles (ce que le modèle prédit)
• C'est la convention standard en apprentissage automatique

Tout d'abord, ouvrez le fichier preprocess.py situé dans le répertoire ~/project à l'aide de l'explorateur de fichiers sur la gauche. Nous ajouterons notre code à ce fichier.

Ajoutez les lignes suivantes sous le commentaire ## --- Step 1: Split data --- pour attribuer respectivement les caractéristiques et la cible à X et y. Nous imprimerons également leurs formes pour vérification.

## --- Step 1: Split data ---
X = iris.data
y = iris.target

print("Shape of features (X):", X.shape)
print("Shape of target (y):", y.shape)

Maintenant, enregistrez le fichier et exécutez-le depuis le terminal pour voir la sortie.

python3 preprocess.py

Vous devriez voir la sortie suivante, qui indique que nous avons 150 échantillons et 4 caractéristiques, ainsi que 150 étiquettes cibles correspondantes.

Shape of features (X): (150, 4)
Shape of target (y): (150,)

Mettre à l'échelle les caractéristiques en utilisant StandardScaler de sklearn.preprocessing

Dans cette étape, nous allons nous préparer à mettre à l'échelle nos caractéristiques. La mise à l'échelle des caractéristiques est une exigence courante pour de nombreux algorithmes d'apprentissage automatique, car ils peuvent être sensibles à l'échelle des caractéristiques d'entrée. StandardScaler est une technique populaire qui standardise les caractéristiques en supprimant la moyenne et en les mettant à l'échelle pour obtenir une variance unitaire.

Comment fonctionne StandardScaler :

• Formule : z = (x - u) / s, où u est la moyenne des échantillons d'entraînement et s est l'écart type
• Effet : Transforme les données pour avoir une moyenne de 0 et un écart type de 1
• Avantages : Empêche les caractéristiques avec des échelles plus grandes de dominer le processus d'apprentissage

Paramètres clés de StandardScaler :

• with_mean=True (par défaut) : Centre les données en supprimant la moyenne
• with_std=True (par défaut) : Met à l'échelle les données en divisant par l'écart type

Nous utiliserons StandardScaler de sklearn.preprocessing. La première partie du processus consiste à créer une instance du scaler.

Dans votre fichier preprocess.py, ajoutez le code suivant sous le commentaire ## --- Step 2: Initialize the scaler --- pour créer une instance de StandardScaler.

## --- Step 2: Initialize the scaler ---
scaler = StandardScaler()

print("Scaler object created:", scaler)

Enregistrez le fichier et exécutez-le à nouveau.

python3 preprocess.py

La sortie inclura désormais une ligne confirmant que l'objet StandardScaler a été créé avec succès.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()

Ajuster le scaler avec scaler.fit(X)

Dans cette étape, nous allons ajuster le StandardScaler à nos données de caractéristiques X. La méthode fit() est un concept fondamental dans scikit-learn.

Ce que fait fit() :

• Calcule les statistiques nécessaires (moyenne et écart type) à partir des données d'entraînement
• Stocke ces paramètres en interne pour une utilisation ultérieure
• Important : Apprend uniquement à partir des données, ne les transforme pas

Pourquoi séparer fit() et transform() ?

• Ajustement sur les données d'entraînement uniquement : Empêche la fuite de données en apprenant les paramètres uniquement à partir de l'ensemble d'entraînement
• Application à n'importe quelles données : Peut transformer les données d'entraînement et de test en utilisant les mêmes paramètres appris
• Cohérence : Assure que la même transformation est appliquée à toutes les données

Meilleure pratique en situation réelle :

• scaler.fit(X_train) - Apprendre les paramètres uniquement à partir des données d'entraînement
• X_train_scaled = scaler.transform(X_train) - Transformer les données d'entraînement
• X_test_scaled = scaler.transform(X_test) - Transformer les données de test avec les mêmes paramètres

Ajoutez le code suivant à votre fichier preprocess.py sous le commentaire ## --- Step 3: Fit the scaler ---. Nous imprimerons également l'attribut mean_ du scaler pour voir ce qu'il a appris.

## --- Step 3: Fit the scaler ---
scaler.fit(X)

print("Scaler mean:", scaler.mean_)

Enregistrez le fichier et exécutez-le.

python3 preprocess.py

La sortie affichera désormais la moyenne pour chacune des quatre caractéristiques, que le scaler a calculée à partir des données.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()
Scaler mean: [5.84333333 3.05733333 3.758      1.19933333]

Transformer les données avec scaler.transform(X)

Dans cette étape, nous allons utiliser le scaler ajusté pour transformer nos données. La méthode transform() applique la transformation de mise à l'échelle aux données, en utilisant la moyenne et l'écart type calculés lors de l'étape fit(). Cela centrera nos données autour d'une moyenne de 0 avec un écart type de 1.

Nous stockerons les données transformées dans une nouvelle variable, X_scaled, afin de conserver les données d'origine intactes.

Comprendre le code :

• X_scaled = scaler.transform(X) : Applique la transformation apprise à nos données
• np.set_printoptions(precision=2, suppress=True) : Formate la sortie pour une meilleure lisibilité
  • precision=2 : Affiche 2 décimales
  • suppress=True : Utilise la notation scientifique pour les nombres très petits/grands
• np.mean(X, axis=0) : Calcule la moyenne le long de l'axe 0 (colonnes)
  • axis=0 : Calcule la moyenne pour chaque caractéristique (colonne) sur tous les échantillons
  • Résultat : Une valeur moyenne par caractéristique

Ajoutez le code suivant à votre fichier preprocess.py sous le commentaire ## --- Step 4: Transform the data ---. Nous imprimerons la moyenne des données d'origine et des données mises à l'échelle pour observer l'effet de la transformation.

## --- Step 4: Transform the data ---
X_scaled = scaler.transform(X)

## Use numpy to set precision for cleaner output
np.set_printoptions(precision=2, suppress=True)
print("Original data mean:", np.mean(X, axis=0))
print("Scaled data mean:", np.mean(X_scaled, axis=0))
print("Scaled data sample:\n", X_scaled[:5])

Enregistrez le fichier et exécutez-le.

python3 preprocess.py

Vous verrez que la moyenne des données mises à l'échelle est effectivement nulle, et que les valeurs des données d'échantillon ont été transformées.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()
Scaler mean: [5.84333333 3.05733333 3.758      1.19933333]
Original data mean: [5.84 3.06 3.76 1.2 ]
Scaled data mean: [-0. -0. -0. -0.]
Scaled data sample:
 [[-0.9   1.02 -1.34 -1.32]
 [-1.14 -0.13 -1.34 -1.32]
 [-1.39  0.33 -1.4  -1.32]
 [-1.51  0.1  -1.28 -1.32]
 [-1.02  1.25 -1.34 -1.32]]

Encoder la cible catégorielle avec LabelEncoder de sklearn.preprocessing

Dans cette étape, nous allons prétraiter notre variable cible y. La cible de l'ensemble de données Iris est catégorielle, représentée par les nombres 0, 1 et 2, qui correspondent aux trois espèces différentes de fleurs d'Iris. Bien qu'elles soient déjà numériques, il est de bonne pratique de comprendre comment encoder les étiquettes catégorielles, surtout si elles étaient au format chaîne de caractères (par exemple, 'setosa', 'versicolor').

Explication de LabelEncoder :

• Objectif : Convertit les étiquettes catégorielles (chaînes de caractères ou types mixtes) en entiers
• Fonctionnement : Attribue un entier unique à chaque catégorie unique
• Exemple : ['chat', 'chien', 'chat'] → [0, 1, 0]

Pourquoi utiliser LabelEncoder ?

• De nombreux algorithmes de ML nécessitent des entrées numériques
• Stockage et calcul efficaces
• Conserve la nature catégorielle des données

Méthodes clés :

• fit(y) : Apprend le mappage des catégories aux entiers
• transform(y) : Applique le mappage appris
• fit_transform(y) : Combine les deux étapes en un seul appel
• inverse_transform(y_encoded) : Reconvertit les entiers en catégories d'origine

Notes importantes :

• L'ordre est arbitraire (basé sur la première apparition ou le tri)
• Ne convient pas aux données ordinales où l'ordre est important (utiliser OrdinalEncoder à la place)
• Pour les caractéristiques (pas les cibles), envisagez OneHotEncoder pour les données nominales

Ajoutez le code suivant à votre fichier preprocess.py sous le commentaire ## --- Step 5: Encode the target ---. Nous allons créer une instance de LabelEncoder et utiliser la méthode fit_transform(), qui combine l'ajustement et la transformation en une seule étape.

## --- Step 5: Encode the target ---
encoder = LabelEncoder()
y_encoded = encoder.fit_transform(y)

print("\nOriginal target sample:", y[:5])  ## Show first 5 original labels
print("Encoded target sample:", y_encoded[:5])  ## Show first 5 encoded labels
print("Unique encoded values:", np.unique(y_encoded))  ## Show all unique encoded values

Enregistrez le fichier et exécutez-le pour la dernière fois.

python3 preprocess.py

La sortie montrera que la variable cible a été encodée. Comme elle était déjà dans le bon format entier, le résultat est le même, mais cela démontre le processus que vous utiliseriez pour des étiquettes basées sur des chaînes de caractères.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()
Scaler mean: [5.84333333 3.05733333 3.758      1.19933333]
Original data mean: [5.84 3.06 3.76 1.2 ]
Scaled data mean: [-0. -0. -0. -0.]
Scaled data sample:
 [[-0.9   1.02 -1.34 -1.32]
 [-1.14 -0.13 -1.34 -1.32]
 [-1.39  0.33 -1.4  -1.32]
 [-1.51  0.1  -1.28 -1.32]
 [-1.02  1.25 -1.34 -1.32]]

Original target sample: [0 0 0 0 0]
Encoded target sample: [0 0 0 0 0]
Unique encoded values: [0 1 2]

Résumé

Félicitations pour avoir terminé le laboratoire ! Vous avez effectué avec succès des tâches essentielles de prétraitement de données à l'aide de scikit-learn.

Dans ce laboratoire, vous avez appris à :

• Charger un ensemble de données standard de scikit-learn.
• Séparer les données en caractéristiques (X) et en cible (y).
• Mettre à l'échelle les caractéristiques numériques à l'aide de StandardScaler en l'ajustant (fit) d'abord aux données pour apprendre les paramètres, puis en transformant (transform) les données.
• Encoder les étiquettes cibles catégorielles dans un format entier lisible par machine à l'aide de LabelEncoder.

Ces étapes de prétraitement sont fondamentales pour construire des modèles d'apprentissage automatique robustes et performants. Vous êtes maintenant mieux équipé pour préparer vos propres ensembles de données pour de futurs projets d'apprentissage automatique.