Prétraitement des Données avec Python

1 Introduction

En science des données, on dit souvent : “Garbage In, Garbage Out” (Déchets en entrée, déchets en sortie). La qualité de vos modèles de Machine Learning dépend directement de la qualité de vos données. Le prétraitement des données (ou data preprocessing) est l’ensemble des techniques utilisées pour nettoyer, transformer et préparer les données brutes afin qu’elles soient exploitables par les algorithmes.

Objectifs de ce tutoriel :

• Comprendre les enjeux du prétraitement.
• Apprendre à gérer les données manquantes.
• Savoir encoder les variables catégorielles.
• Maîtriser la mise à l’échelle des variables (Standardisation et Normalisation).
• Appliquer ces techniques avec Pandas et Scikit-learn.

---

2 Partie 1 : Gestion des Données Manquantes

Les données manquantes sont un problème courant. La plupart des algorithmes ne peuvent pas fonctionner avec.

2.1 1. Identification

Utilisons le jeu de données du Titanic pour illustrer.

import pandas as pd
import seaborn as sns

df = sns.load_dataset('titanic')

# Afficher le nombre de valeurs manquantes par colonne
print(df.isnull().sum())

Nous voyons que age, deck, et embarked ont des valeurs manquantes.

2.2 2. Stratégies de Traitement

• Suppression :

  • df.dropna() : Supprimer les lignes (ou colonnes) contenant des valeurs manquantes. Risqué, car on peut perdre beaucoup d’information.
  • À utiliser si les données manquantes sont très peu nombreuses.

• Imputation (Remplacement) : La méthode la plus courante.

  • Numérique : Remplacer par la moyenne ou la médiane. La médiane est plus robuste aux valeurs aberrantes.
  • Catégorielle : Remplacer par le mode (la valeur la plus fréquente).

# Imputer 'age' avec la médiane
median_age = df['age'].median()
df['age'].fillna(median_age, inplace=True)

# Imputer 'embarked' avec le mode
mode_embarked = df['embarked'].mode()[0]
df['embarked'].fillna(mode_embarked, inplace=True)

# La colonne 'deck' a trop de valeurs manquantes (>75%), on la supprime
df.drop('deck', axis=1, inplace=True)

print(df.isnull().sum())

---

3 Partie 2 : Encodage des Variables Catégorielles

Les modèles de Machine Learning sont des modèles mathématiques. Ils ont parfois besoin de nombres à la place chaînes de caractères.

3.1 1. One-Hot Encoding

Cette technique transforme chaque catégorie d’une variable en une nouvelle colonne binaire (0 ou 1). C’est la méthode la plus sûre et la plus utilisée. La fonction pd.get_dummies() est parfaite pour cela.

# Appliquer le One-Hot Encoding sur 'sex' et 'embarked'
1df_encoded = pd.get_dummies(df, columns=['sex', 'embarked'], drop_first=True)

df_encoded.head()

1

drop_first=True évite la redondance en supprimant la première colonne après l’encodage.

3.2 2. Label Encoding

Cette technique assigne un entier unique à chaque catégorie (ex: “S” -> 0, “C” -> 1, “Q” -> 2). Attention : À n’utiliser que pour les variables ordinales (où un ordre existe, ex: “faible”, “moyen”, “élevé”), car cela peut introduire une relation d’ordre artificielle que le modèle pourrait mal interpréter.

Exemple 1  

from sklearn.preprocessing import LabelEncoder

# Appliquer le Label Encoding sur 'class'
le = LabelEncoder()
df['class_encoded'] = le.fit_transform(df['class'])

df[['class', 'class_encoded']].head()

4 Partie 3 : Mise à l’échelle des Variables (Feature Scaling)

Pourquoi ? De nombreux algorithmes (k-NN, SVM, réseaux de neurones, etc.) sont sensibles à l’échelle des variables. Une variable allant de 0 à 100 000 (comme un salaire) pèsera plus lourd qu’une variable allant de 0 à 100 (comme un âge), ce qui peut fausser le modèle.

Utilisons le jeu de données iris pour l’exemple.

from sklearn.preprocessing import StandardScaler, MinMaxScaler

iris = sns.load_dataset('iris')
X_iris = iris[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']]

4.1 1. Standardisation (Z-score Normalization)

Transforme les données pour qu’elles aient une moyenne de 0 et un écart-type de 1. C’est la technique la plus courante et la plus robuste.

Formules

• Centrer et réduire: \[z = \dfrac{x - \bar{x}}{s}\]

Où \(\bar{x}=\dfrac{1}{n}\sum_{i=1}^nx_i\) est la moyenne et \(s^2=\dfrac{1}{n-1}\sum_{i=1}^n(x_i - \bar{x})^2\) est l’écart-type.

scaler_std = StandardScaler()
X_scaled_std = scaler_std.fit_transform(X_iris)

print("Moyenne après standardisation (proche de 0):", X_scaled_std.mean(axis=0))
print("Écart-type après standardisation (proche de 1):", X_scaled_std.std(axis=0))

4.2 2. Normalisation (Min-Max Scaling)

Met les données à l’échelle dans un intervalle fixe, généralement [0, 1].

Formule : \[x_{norm} = \dfrac{x - x_{min}}{x_{max} - x_{min}}\]

scaler_minmax = MinMaxScaler()
X_scaled_minmax = scaler_minmax.fit_transform(X_iris)

print("\nMin après normalisation (proche de 0):", X_scaled_minmax.min(axis=0))
print("Max après normalisation (proche de 1):", X_scaled_minmax.max(axis=0))

Quand utiliser quoi ?

• Standardisation : Le choix par défaut. Moins sensible aux valeurs aberrantes.
• Normalisation : Utile quand l’algorithme requiert des données dans un intervalle borné (ex: traitement d’images où les pixels sont entre 0 et 255).

---

5 Partie 4 : Le Pipeline de Prétraitement Complet avec Scikit-learn

Nous avons vu les étapes de prétraitement de manière isolée. En pratique, il est crucial de les enchaîner dans un workflow propre et reproductible. C’est le rôle du Pipeline et du ColumnTransformer de Scikit-learn.

Pourquoi est-ce si important ?

• Prévention de la Fuite de Données (Data Leakage) : Le pipeline garantit que les informations du jeu de test ne “fuient” pas dans le jeu d’entraînement (par exemple, en calculant la moyenne sur l’ensemble des données avant de diviser).
• Reproductibilité : Le pipeline encapsule toutes vos étapes de prétraitement en un seul objet, facile à sauvegarder et à réutiliser.
• Simplicité : Vous pouvez entraîner et évaluer votre workflow complet en une seule ligne de code.

5.1 L’Atelier Pratique : Un Pipeline pour le Titanic

Objectif : Construire un pipeline qui gère l’imputation, l’encodage et la mise à l’échelle pour le jeu de données du Titanic.

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.model_selection import train_test_split

# 1. Recharger les données et séparer X et y
df = sns.load_dataset('titanic')
df.drop(['survived', 'alive', 'who', 'adult_male', 'class', 'embark_town', 'deck'], axis=1, inplace=True)

X = df.drop('pclass', axis=1) # pclass est notre cible pour cet exemple
y = df['pclass']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 2. Définir les pipelines pour chaque type de colonne
numeric_features = ['age', 'fare']
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')), # Gérer les valeurs manquantes
    ('scaler', StandardScaler())                  # Mettre à l'échelle
])

categorical_features = ['sex', 'embarked']
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')), # Gérer les valeurs manquantes
    ('onehot', OneHotEncoder(handle_unknown='ignore'))    # Encoder
])

# 3. Combiner les pipelines avec ColumnTransformer
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ],
    remainder='passthrough' # Garder les autres colonnes (sibsp, parch)
)

# 4. Appliquer le pipeline de prétraitement
X_train_processed = preprocessor.fit_transform(X_train)
X_test_processed = preprocessor.transform(X_test)

print("Dimensions des données d'entraînement après prétraitement :", X_train_processed.shape)
print("Les données sont maintenant prêtes pour un modèle !")

2. Gestion des données manquantes

3. Encodage des variables catégorielles

4. Séparation des features (X) et de la cible (y)

5. Mise à l’échelle des variables numériques

   • On ne met à l’échelle que les colonnes qui en ont besoin.
   • Important : On applique le fit_transform sur les données d’entraînement et seulement transform sur les données de test pour éviter la fuite de données (data leakage). Pour cet exemple, nous le faisons sur l’ensemble du jeu de données.

6. Vérification du résultat final

6 Conclusion

Le prétraitement des données est une étape fondamentale et souvent la plus longue d’un projet de Data Science. En maîtrisant la gestion des données manquantes, l’encodage des catégories et la mise à l’échelle des variables, vous augmentez considérablement les chances de succès de vos modèles.

Votre jeu de données X et votre cible y sont maintenant prêts à être utilisés pour entraîner un modèle de classification !

---

7 Exercices

Exercice 1  

Question 1 : Importance du Prétraitement

Selon le principe ‘Garbage In, Garbage Out’, pourquoi le prétraitement des données est-il une étape cruciale en Machine Learning ?

1. Pour rendre les graphiques plus esthétiques.
2. Pour accélérer la vitesse de chargement des données.
3. Parce que la qualité et la performance d’un modèle dépendent directement de la qualité des données d’entrée.
4. Pour augmenter le nombre de variables dans le jeu de données.

Question 2 : Identification des Données Manquantes

Quelle méthode Pandas est utilisée pour compter le nombre de valeurs manquantes dans chaque colonne d’un DataFrame df ?

1. df.count_nulls()
2. df.missing().sum()
3. df.isnull().sum()
4. df.nan_count()

Question 3 : Stratégie d’Imputation Numérique

Pour imputer une variable numérique qui contient des valeurs aberrantes (outliers), quelle est la stratégie la plus robuste ?

1. Remplacer par la moyenne.
2. Remplacer par la médiane.
3. Remplacer par zéro.
4. Supprimer les lignes contenant les valeurs manquantes.

Question 4 : Stratégie d’Imputation Catégorielle

Quelle est la méthode standard pour imputer les valeurs manquantes d’une variable catégorielle ?

1. Remplacer par la moyenne.
2. Remplacer par une nouvelle catégorie ‘Manquant’.
3. Remplacer par la catégorie la plus fréquente (le mode).
4. Remplacer par la médiane.

Question 5 : Gestion des Colonnes Vides

Si une colonne a un très grand pourcentage de valeurs manquantes (ex: 75%), quelle est souvent la meilleure stratégie ?

1. Imputer avec la moyenne.
2. Supprimer la colonne.
3. Imputer avec le mode.
4. Laisser les valeurs manquantes telles quelles.

Question 6 : Nécessité de l’Encodage

Pourquoi doit-on encoder les variables catégorielles avant de les utiliser dans la plupart des modèles de Machine Learning ?

1. Pour réduire le nombre de catégories.
2. Parce que les modèles mathématiques nécessitent des entrées numériques.
3. Pour rendre les données plus faciles à lire pour un humain.
4. L’encodage n’est jamais nécessaire.

Question 7 : One-Hot Encoding

Que fait le One-Hot Encoding sur une variable couleur ayant les catégories [‘Rouge’, ‘Vert’, ‘Bleu’] ?

1. Il la remplace par les chiffres 1, 2, et 3.
2. Il crée de nouvelles colonnes binaires (0/1) comme couleur_Rouge, couleur_Vert, etc.
3. Il supprime la variable du jeu de données.
4. Il calcule la fréquence de chaque couleur.

Question 8 : Risque du Label Encoding

Quel est le principal risque à utiliser le Label Encoding sur une variable nominale (non ordonnée) comme ville ?

1. Cela prend trop de temps de calcul.
2. Cela introduit une relation d’ordre artificielle que le modèle peut mal interpréter.
3. Cela crée trop de nouvelles colonnes.
4. Cela ne fonctionne que pour les variables avec deux catégories.

Question 9 : Fonction Pandas pour One-Hot Encoding

Quelle fonction Pandas est la plus directe pour appliquer le One-Hot Encoding ?

1. pd.to_categorical()
2. pd.get_dummies()
3. pd.encode()
4. pd.transform()

Question 10 : Importance de la Mise à l’Échelle

Pour quels types d’algorithmes la mise à l’échelle des variables (Feature Scaling) est-elle particulièrement cruciale ?

1. Les algorithmes basés sur les arbres de décision comme les Random Forests.
2. Les algorithmes basés sur le calcul de distances comme k-NN et les SVM.
3. Tous les algorithmes de Machine Learning sans exception.
4. Uniquement pour les algorithmes de régression.

Question 11 : Standardisation (StandardScaler)

Après avoir appliqué StandardScaler de Scikit-learn, quelles seront approximativement la moyenne et l’écart-type de chaque variable ?

1. Moyenne = 0.5, Écart-type = 0.5
2. Moyenne = 0, Écart-type = 1
3. Moyenne = 1, Écart-type = 0
4. La moyenne et l’écart-type dépendent des données originales.

Question 12 : Normalisation (MinMaxScaler)

Quel est le résultat de l’application de MinMaxScaler sur une variable ?

1. Les données auront une moyenne de 0 et un écart-type de 1.
2. Les données seront transformées pour suivre une loi normale.
3. Les données seront mises à l’échelle dans un intervalle fixe, généralement [0, 1].
4. Les valeurs aberrantes seront supprimées.

Question 13 : Fuite de Données (Data Leakage)

Pour éviter la fuite de données (data leakage), quand doit-on ajuster (fitter) un StandardScaler ?

1. Sur l’ensemble du jeu de données (entraînement + test).
2. Uniquement sur l’ensemble de test.
3. Uniquement sur l’ensemble d’entraînement.
4. Après avoir entraîné le modèle.

Question 14 : Paramètre drop_first

Dans pd.get_dummies(..., drop_first=True), à quoi sert le paramètre drop_first ?

1. À supprimer la première ligne du DataFrame.
2. À supprimer la première catégorie pour éviter la multicolinéarité entre les variables muettes.
3. À supprimer la colonne originale après l’encodage.
4. À n’encoder que la première catégorie.

Question 15 : Choix de la Méthode de Mise à l’Échelle

Quelle méthode de mise à l’échelle est généralement considérée comme le choix par défaut car elle est moins sensible aux valeurs aberrantes ?

1. La Normalisation (Min-Max Scaling).
2. La Standardisation (Z-score Normalization).
3. Le Label Encoding.
4. Le One-Hot Encoding.

Question 16 : Rôle du ColumnTransformer

Quel est le rôle principal de ColumnTransformer dans un pipeline de prétraitement ?

1. Appliquer la même transformation à toutes les colonnes du jeu de données.
2. Appliquer des transformations différentes à des sous-ensembles de colonnes spécifiques (ex: numériques vs. catégorielles).
3. Transformer les colonnes en lignes.
4. Supprimer les colonnes qui ne sont pas utiles pour le modèle.

Question 17 : Paramètre remainder

Dans ColumnTransformer(..., remainder='passthrough'), que signifie le paramètre remainder ?

1. Les colonnes non spécifiées dans transformers sont supprimées.
2. Les colonnes non spécifiées sont remplies avec des zéros.
3. Les colonnes non spécifiées sont conservées telles quelles dans le jeu de données de sortie.
4. Une erreur est levée si toutes les colonnes ne sont pas transformées.

Question 18 : Ordre des Opérations

Dans un pipeline typique pour des données numériques, quel est l’ordre correct des opérations pour éviter la fuite de données ?

1. Mise à l’échelle, puis imputation des valeurs manquantes.
2. Imputation des valeurs manquantes, puis mise à l’échelle.
3. Encodage, puis mise à l’échelle.
4. L’ordre n’a pas d’importance.

Question 19 : Avantage du Pipeline pour le Déploiement

En plus de prévenir la fuite de données, quel est un avantage majeur de l’utilisation d’un Pipeline pour le déploiement d’un modèle ?

1. Il rend le modèle plus rapide à l’entraînement.
2. Il garantit que les nouvelles données de prédiction subissent exactement le même prétraitement que les données d’entraînement.
3. Il choisit automatiquement le meilleur modèle.
4. Il génère automatiquement des visualisations des résultats.

Question 20 : handle_unknown='ignore'

Dans OneHotEncoder(handle_unknown='ignore'), à quoi sert le paramètre handle_unknown ?

1. À ignorer les colonnes qui ne sont pas catégorielles.
2. À ignorer les valeurs manquantes avant l’encodage.
3. À gérer les nouvelles catégories qui apparaissent dans les données de test (mais pas dans les données d’entraînement) en les encodant avec des zéros.
4. À lever une erreur si une catégorie inconnue est rencontrée.