100 Jours de ML — Module 4 : préparer ses données (preprocessing)

Quatrième module du challenge #100JoursDeML, et le plus sous-estimé. Le preprocessing (prétraitement) désigne l'ensemble des transformations qui rendent des données brutes exploitables par un modèle. En entreprise, il représente l'essentiel du temps d'un projet — et c'est lui qui décide de la qualité du modèle final. Chaque leçon est détaillée ci-dessous avec sa vidéo.

Leçon 1 — Le preprocessing expliqué simplement

La vue d'ensemble du module : pourquoi les données brutes ne sont jamais prêtes (échelles hétérogènes, catégories textuelles, trous, valeurs aberrantes), et dans quel ordre enchaîner les traitements — nettoyage, encodage, imputation, mise à l'échelle, sélection — pour construire un pipeline reproductible qui s'appliquera à l'identique aux données futures.

Leçon 2 — Normalisation ou standardisation ?

Deux techniques de mise à l'échelle à ne plus confondre. La normalisation (min-max scaling) ramène les valeurs dans l'intervalle [0, 1] : simple, mais sensible aux valeurs extrêmes. La standardisation (z-score) centre les données sur 0 avec un écart-type de 1 : plus robuste, c'est le choix par défaut pour la plupart des modèles sensibles aux distances (KNN, SVM, régressions pénalisées, ACP).

from sklearn.preprocessing import MinMaxScaler, StandardScaler

X_norm = MinMaxScaler().fit_transform(X)   # normalisation : valeurs dans [0, 1]
X_std  = StandardScaler().fit_transform(X) # standardisation : moyenne 0, écart-type 1

Leçon 3 — L'encodage des variables catégorielles

Les modèles ne comprennent que des nombres. Le label encoding attribue un entier à chaque modalité — adapté aux variables ordinales, où l'ordre a un sens. Le one-hot encoding crée une colonne binaire par modalité — indispensable pour les variables nominales, sous peine d'inventer un ordre qui n'existe pas (coder Paris=1, Lyon=2, Marseille=3 laisserait croire au modèle que Marseille « vaut » trois fois Paris). La leçon couvre aussi les encodages avancés pour les variables à très nombreuses modalités.

# One-hot : une colonne binaire par modalité (variables nominales)
df_encode = pd.get_dummies(df, columns=["ville"], drop_first=True)

# Label encoding : un entier par modalité (variables ordinales uniquement)
df["niveau"] = df["niveau"].map({"faible": 0, "moyen": 1, "eleve": 2})

Leçon 4 — Transformer les variables : Box-Cox, Yeo-Johnson, log

Beaucoup de variables réelles (revenus, prix, délais) ont des distributions très asymétriques qui gênent les modèles. Les transformations corrigent cette asymétrie : le logarithme (le grand classique pour les variables strictement positives à queue longue), Box-Cox (une famille paramétrée de transformations, pour valeurs strictement positives) et Yeo-Johnson (sa généralisation qui accepte zéros et valeurs négatives). La leçon montre comment choisir et vérifier l'effet sur la distribution.

Leçon 5 — Traiter les valeurs manquantes

Les valeurs manquantes sont inévitables. Avant de les traiter, il faut comprendre leur mécanisme : manquantes au hasard ou pas (un revenu manquant est rarement un hasard). Les stratégies : supprimer (si rare et aléatoire), imputer par la médiane ou la modalité la plus fréquente (simple et robuste), ou par des méthodes plus fines (imputation par KNN, par modèle). Et souvent le plus informatif : ajouter un indicateur binaire « était manquant », car l'absence elle-même est un signal.

from sklearn.impute import SimpleImputer

df.isna().mean().sort_values(ascending=False)  # % de manquants par colonne
imputer = SimpleImputer(strategy="median")
df[["revenu"]] = imputer.fit_transform(df[["revenu"]])
df["revenu_manquant"] = df["revenu"].isna().astype(int)  # l'absence est un signal

Leçon 6 — Identifier et traiter les outliers

Un outlier (valeur aberrante) est une observation anormalement éloignée des autres. Détection : la règle de l'écart interquartile (au-delà de 1,5 × IQR des quartiles), le z-score (au-delà de 3 écarts-types), et toujours la visualisation (boxplot, nuage de points). Traitement au cas par cas : corriger l'erreur de saisie, winsoriser (plafonner), transformer, ou… conserver précieusement — en détection de fraude, l'outlier est précisément ce qu'on cherche.

⚠️ Point important : le piège mortel du débutant est la fuite de données (data leakage) — calculer sa standardisation ou son imputation sur tout le jeu de données avant de séparer entraînement et test. Le modèle « voit » alors le futur et ses performances s'effondrent en production. Toutes les transformations s'apprennent sur l'entraînement seulement.

Leçon 7 — Les mathématiques indispensables

Le bagage minimal pour comprendre ce que font vraiment les algorithmes : vecteurs et matrices (l'algèbre linéaire qui sous-tend toutes les données tabulaires), notion de distance, dérivée et gradient (la pente qui guide l'optimisation des modèles), et le vocabulaire des fonctions. Rien d'insurmontable : chaque notion est reliée à son usage concret en machine learning.

Leçon 8 — Choisir les bonnes variables : la feature selection

La feature selection (sélection de variables) élimine les variables inutiles ou redondantes : moins de bruit, moins de surapprentissage, des modèles plus rapides et plus lisibles. Cette leçon pose la carte des trois familles de méthodes : filtrage, wrapper et intégrées.

Leçon 9 — L'approche par filtrage

Les méthodes de filtrage évaluent chaque variable avant toute modélisation, par des critères statistiques : corrélation avec la cible, tests statistiques, information mutuelle. Rapides et indépendantes du modèle, elles constituent le premier tri — au prix d'ignorer les interactions entre variables.

Leçon 10 — Approches automatiques et intégrées en Python

Les méthodes wrapper testent des sous-ensembles de variables avec le modèle lui-même — comme la RFE (élimination récursive : on entraîne, on retire la variable la moins utile, on recommence). Les méthodes intégrées font la sélection pendant l'entraînement — le Lasso qui annule des coefficients, les importances de variables des arbres. La leçon les implémente avec scikit-learn.

💡 À retenir : « on ne met pas de pétrole brut dans une voiture » — l'IA a besoin de données raffinées. C'est exactement ce que Didier Gaultier expliquait dans l'épisode du podcast sur les IA génératives.

La suite

Vos données sont prêtes. Il est temps d'entraîner vos premiers modèles avec le Module 5 : les fondamentaux de l'apprentissage supervisé.

Références

• Documentation scikit-learn : preprocessing, imputation et feature selection
• Box, G.E.P. & Cox, D.R. (1964), « An analysis of transformations », Journal of the Royal Statistical Society
• Guyon, I. & Elisseeff, A. (2003), « An introduction to variable and feature selection », JMLR