Préparer ses Données pour le Machine Learning
Apprenez à nettoyer, explorer et transformer vos données avant de les donner à un modèle : Pandas, visualisation et bonnes pratiques.
Par Alex Perey
Explorer et Comprendre ses Données
Avant de construire un modèle, il faut comprendre ses données. Un modèle entraîné sur des données sales donnera des résultats absurdes. Cette étape représente souvent 70-80% du temps d'un projet ML.
Pourquoi la Préparation est Cruciale
Imaginez que vous entraînez un modèle pour prédire le prix d'une maison, mais que certaines lignes contiennent "N/A" dans la colonne surface, que d'autres affichent un prix de 0€, et que les dates sont dans 3 formats différents.
Règle n°1 du ML : La qualité de votre modèle ne dépassera jamais la qualité de vos données. "Garbage in, Garbage out."
Charger et Explorer avec Pandas
Pandas est la bibliothèque Python pour manipuler des données tabulaires. Pensez-y comme un Excel surpuissant.
import pandas as pd
# Charger un fichier CSV
df = pd.read_csv("maisons.csv")
# Premières lignes
print(df.head())
# Résumé statistique (moyenne, min, max, etc.)
print(df.describe())
# Combien de valeurs manquantes par colonne ?
print(df.isnull().sum())
🛠️ Micro-Exercice : Exploration Express
Chargeons le dataset Titanic, un classique pour débuter.
import pandas as pd
# Dataset Titanic intégré à seaborn
import seaborn as sns
df = sns.load_dataset("titanic")
# 1. Dimensions du dataset
print(f"Lignes : {len(df)}, Colonnes : {len(df.columns)}")
# 2. Types de données
print(df.dtypes)
# 3. Valeurs manquantes
print(df.isnull().sum())
# 4. Distribution de la variable cible
print(df["survived"].value_counts())
Vous remarquerez que la colonne age a des valeurs manquantes et que deck en a énormément. C'est typique des données réelles.
Nettoyer et Transformer
Maintenant qu'on a identifié les problèmes, il faut les résoudre. Voici les techniques les plus courantes.
Gérer les Valeurs Manquantes
Trois stratégies principales :
- Supprimer les lignes : Simple mais on perd de l'information.
- Remplacer par la moyenne/médiane : Bon compromis pour les chiffres.
- Remplacer par le mode : Pour les catégories (la valeur la plus fréquente).
# Remplacer les âges manquants par la médiane
df["age"] = df["age"].fillna(df["age"].median())
# Supprimer une colonne trop incomplète (>50% manquant)
df = df.drop(columns=["deck"])
# Vérifier qu'il n'y a plus de manquants
print(df.isnull().sum())
Encoder les Variables Catégorielles
Les modèles ML ne comprennent que les nombres. Il faut convertir "homme"/"femme" en 0/1.
# Encodage simple pour 2 catégories
df["sex_encoded"] = df["sex"].map({"male": 0, "female": 1})
# One-Hot Encoding pour 3+ catégories
df = pd.get_dummies(df, columns=["embark_town"], drop_first=True)
Normaliser les Valeurs Numériques
Si une colonne va de 0 à 100 et une autre de 0 à 1 000 000, le modèle va accorder plus d'importance à la seconde. La normalisation met tout le monde sur un pied d'égalité.
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
df[["age", "fare"]] = scaler.fit_transform(df[["age", "fare"]])
# Maintenant age et fare ont une moyenne de 0 et un écart-type de 1
print(df[["age", "fare"]].describe())
Vos données sont maintenant propres, numériques et normalisées. Elles sont prêtes pour n'importe quel algorithme ML.
Visualiser pour Comprendre
Un graphique vaut mille statistiques. La visualisation aide à détecter des patterns, des anomalies et à choisir le bon modèle.
Les Graphiques Essentiels
import matplotlib.pyplot as plt
import seaborn as sns
# Distribution d'une variable numérique
sns.histplot(df["age"], bins=30, kde=True)
plt.title("Distribution des âges")
plt.show()
# Relation entre deux variables
sns.scatterplot(x="age", y="fare", hue="survived", data=df)
plt.title("Âge vs Tarif (coloré par survie)")
plt.show()
# Matrice de corrélation
numeric_cols = df.select_dtypes(include="number")
sns.heatmap(numeric_cols.corr(), annot=True, cmap="coolwarm")
plt.title("Corrélations entre variables")
plt.show()
🛠️ Micro-Exercice : Pipeline Complet
Mettons tout ensemble dans un pipeline propre avec scikit-learn.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
import seaborn as sns
df = sns.load_dataset("titanic")
features = ["age", "fare", "pclass", "sibsp", "parch"]
X = df[features]
y = df["survived"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# Pipeline : imputer → scaler → modèle
pipe = Pipeline([
("imputer", SimpleImputer(strategy="median")),
("scaler", StandardScaler()),
("model", DecisionTreeClassifier(max_depth=5))
])
pipe.fit(X_train, y_train)
print(f"Score : {pipe.score(X_test, y_test):.2%}")
Les pipelines scikit-learn garantissent que les mêmes transformations sont appliquées à l'entraînement ET aux nouvelles données. C'est une bonne pratique indispensable.
À propos de l'auteur
Alex Perey
Diplômé d'un master en intelligence artificielle, je travaille au quotidien sur des projets IA en entreprise. J'ai créé IwanttolearnAI pour rendre l'apprentissage de l'IA accessible à tous, gratuitement.
Continuer à apprendre
Systèmes de Recommandation : de Netflix à Spotify
Découvrez comment Netflix, Spotify et Amazon construisent leurs moteurs de recommandation. De la factorisation matricielle aux two-tower models, maîtrisez les algorithmes et les métriques.
24 min de lecture · 40 vues
Séries Temporelles et Prévision avec Python
Apprenez à modéliser et prévoir des séries temporelles avec ARIMA, Prophet et XGBoost. Maîtrisez la validation temporelle correcte et les métriques adaptées.
22 min de lecture · 61 vues
SVM, Arbres de Décision et Random Forest en Profondeur
Maîtrisez les algorithmes classiques les plus puissants du ML : SVM avec kernel trick, arbres de décision et Random Forest. Comprendre quand ces modèles battent le Deep Learning.
20 min de lecture · 35 vues