Scikit-Learn (sklearn) est la bibliothèque open-source fondamentale de modélisation statistique et de machine learning en Python, construite sur NumPy, SciPy et Matplotlib. Sa force architecturale repose sur un schéma de conception strictement unifié à trois interfaces :
- Estimator (Estimateur) : Apprend les paramètres du modèle à partir des données via
fit(X, y). - Transformer (Transformateur) : Prétraite et projette les caractéristiques via
transform(X)etfit_transform(X). - Predictor (Prédicteur) : Effectue des prédictions sur de nouveaux échantillons via
predict(X),predict_proba(X)etscore(X, y).
🔗 Aide-mémoires associés: Aide-mémoire NumPy · Aide-mémoire Pandas · Algorithmes d'apprentissage supervisé · Méthodes d'analyse de données · Aide-mémoire Python
1. Exemple de démarrage rapide de bout en bout
Le script complet suivant présente le chargement d'un jeu de données, le découpage stratifié, la mise à l'échelle des caractéristiques, l'entraînement et l'évaluation du modèle :
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report
# 1. Chargement des données
iris = load_iris()
X, y = iris.data, iris.target
# 2. Découpage stratifié entraînement / test
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
# 3. Mise à l'échelle des caractéristiques (ajuster UNIQUEMENT sur l'entraînement pour éviter les fuites)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 4. Entraînement de l'estimateur
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train_scaled, y_train)
# 5. Prédiction et évaluation
y_pred = knn.predict(X_test_scaled)
print(f"Précision : {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=iris.target_names))
2. Préparation et découpage des données
Scikit-Learn attend des structures numériques 2D : une matrice de caractéristiques $X$ de forme (n_samples, n_features) et un vecteur cible $y$ de forme (n_samples,). Les entrées peuvent être des ndarrays NumPy, des matrices creuses SciPy (scipy.sparse) ou des DataFrames/Series Pandas.
2.1 Jeux de données intégrés & Génération synthétique
from sklearn import datasets
# Petits jeux de données de référence (retourne un objet Bunch)
iris = datasets.load_iris() # Classification multi-classes
digits = datasets.load_digits() # Images de chiffres manuscrits 8x8
diabetes = datasets.load_diabetes() # Référence pour la régression
wine = datasets.load_wine() # Analyse chimique du vin à 3 classes
# Jeux de données réels de référence (mis en cache localement)
housing = datasets.fetch_california_housing()
# Génération de données synthétiques pour les tests d'algorithmes
X, y = datasets.make_classification(
n_samples=1000, n_features=20, n_informative=15, n_classes=2, random_state=42
)
X_reg, y_reg = datasets.make_regression(n_samples=500, n_features=10, noise=0.1, random_state=42)
X_blob, y_blob = datasets.make_blobs(n_samples=300, centers=3, n_features=2, random_state=42)
2.2 Découpage des données (train_test_split)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y,
test_size=0.25, # Proportion de l'ensemble de test (par défaut : 0.25)
random_state=42, # Graine fixe pour la reproductibilité
shuffle=True, # Mélanger les échantillons avant le découpage
stratify=y # Fortement recommandé en classification : préserve le ratio des classes
)
3. Ingénierie des caractéristiques & Prétraitement (sklearn.preprocessing & sklearn.impute)
| Transformateur | Cas d'usage | Transformation mathématique / Logique | Paramètres clés |
|---|---|---|---|
StandardScaler |
Standardisation Z-score des caractéristiques numériques | $z = \frac{x - \mu}{\sigma}$ (moyenne nulle, variance unitaire) | with_mean=True, with_std=True |
MinMaxScaler |
Mise à l'échelle des caractéristiques dans un intervalle fermé | $x' = \frac{x - x_{\min}}{x_{\max} - x_{\min}} \cdot (\max - \min) + \min$ | feature_range=(0, 1) |
RobustScaler |
Mise à l'échelle robuste face aux valeurs aberrantes | Échelle basée sur l'intervalle interquartile : $x' = \frac{x - Q_2}{Q_3 - Q_1}$ | quantile_range=(25.0, 75.0) |
Normalizer |
Normalisation ligne par ligne par échantillon | Normalise chaque échantillon pour avoir une norme unitaire ($L_1$, $L_2$ ou Max) | norm='l2' ('l1', 'max') |
Binarizer |
Binarisation par seuillage de valeurs continues | $x > \text{threshold} \Rightarrow 1$, sinon $0$ | threshold=0.0 |
SimpleImputer |
Imputation des valeurs manquantes | Remplace les valeurs manquantes par la moyenne, médiane, mode ou une constante | missing_values=np.nan, strategy='mean' |
OneHotEncoder |
Encodage One-Hot des variables catégorielles nominales | Convertit les catégories en colonnes binaires indicatrices | drop='first', handle_unknown='ignore' |
OrdinalEncoder |
Encodage ordinal des variables catégorielles ordonnées | Encode les catégories en entiers ordonnés $0, \dots, K-1$ | categories='auto', encoded_missing_value |
LabelEncoder |
Encodage des étiquettes de la variable cible $y$ | Convertit les chaînes de caractères en entiers $0 \dots C-1$ | UNIQUEMENT pour la cible $y$, JAMAIS pour les caractéristiques $X$ |
PolynomialFeatures |
Génération de termes d'interaction et polynomiaux | Génère des caractéristiques polynomiales $[1, a, b, a^2, ab, b^2]$ | degree=2, include_bias=False |
3.1 Exemples de code de prétraitement
import numpy as np
from sklearn.preprocessing import (
StandardScaler, MinMaxScaler, RobustScaler, Normalizer,
Binarizer, OneHotEncoder, OrdinalEncoder, LabelEncoder, PolynomialFeatures
)
from sklearn.impute import SimpleImputer
# 1. Standardisation numérique (ne jamais ajuster sur les données de test !)
scaler = StandardScaler()
X_train_std = scaler.fit_transform(X_train)
X_test_std = scaler.transform(X_test)
# 2. Imputation des valeurs manquantes (stratégie médiane)
imputer = SimpleImputer(missing_values=np.nan, strategy='median')
X_train_imp = imputer.fit_transform(X_train)
X_test_imp = imputer.transform(X_test)
# 3. Encodage One-Hot catégoriel (gère les catégories inconnues en test)
ohe = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
X_train_ohe = ohe.fit_transform(X_train_cat)
X_test_ohe = ohe.transform(X_test_cat)
# 4. Encodage de la variable cible
le = LabelEncoder()
y_train_enc = le.fit_transform(y_train)
y_test_enc = le.transform(y_test)
# 5. Expansion polynomiale des caractéristiques
poly = PolynomialFeatures(degree=2, include_bias=False)
X_train_poly = poly.fit_transform(X_train)
4. Index maître des estimateurs courants
4.1 Apprentissage supervisé : Classification
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingClassifier
# Régression logistique (ligne de base linéaire)
clf_lr = LogisticRegression(C=1.0, max_iter=200, random_state=42)
# K plus proches voisins (KNN)
clf_knn = KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=2)
# Machine à vecteurs de support (noyau RBF)
clf_svm = SVC(C=1.0, kernel='rbf', gamma='scale', probability=True, random_state=42)
# Naive Bayes gaussien
clf_gnb = GaussianNB()
# Forêt aléatoire (ensemble Bagging)
clf_rf = RandomForestClassifier(n_estimators=100, max_depth=None, n_jobs=-1, random_state=42)
# Gradient Boosting basé sur histogrammes (GBDT rapide proche de LightGBM)
clf_hgb = HistGradientBoostingClassifier(learning_rate=0.1, max_iter=100, random_state=42)
4.2 Apprentissage supervisé : Régression
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.svm import SVR
from sklearn.ensemble import RandomForestRegressor, HistGradientBoostingRegressor
# Régression linéaire ordinaire par moindres carrés (OLS)
reg_lr = LinearRegression()
# Régression Ridge (régularisation L2 contre la multicolinéarité)
reg_ridge = Ridge(alpha=1.0)
# Régression Lasso (régularisation L1 pour sélection de variables)
reg_lasso = Lasso(alpha=0.1)
# Régression par vecteurs de support (SVR)
reg_svr = SVR(kernel='rbf', C=1.0, epsilon=0.1)
# Régresseur Forêt Aléatoire
reg_rf = RandomForestRegressor(n_estimators=100, n_jobs=-1, random_state=42)
4.3 Apprentissage non supervisé : Partitionnement & Réduction de dimension
from sklearn.cluster import KMeans, DBSCAN
from sklearn.decomposition import PCA
# Partitionnement K-Means
kmeans = KMeans(n_clusters=3, init='k-means++', n_init=10, random_state=42)
kmeans.fit(X)
cluster_labels = kmeans.labels_ # Assignations de clusters
cluster_centers = kmeans.cluster_centers_
# Clustering spatial basé sur la densité (DBSCAN : résistant au bruit)
dbscan = DBSCAN(eps=0.5, min_samples=5)
db_labels = dbscan.fit_predict(X) # -1 indique les valeurs aberrantes (bruit)
# Analyse en composantes principales (PCA) : conserve 95% de variance expliquée
pca = PCA(n_components=0.95)
X_pca = pca.fit_transform(X)
print("Composantes conservées :", pca.n_components_)
print("Ratio de variance expliquée :", pca.explained_variance_ratio_)
5. Aide-mémoire des opérations d'API unifiée
| Opération | Méthode canonique | Type d'objet cible | Sémantique & Valeur de retour |
|---|---|---|---|
| Ajuster (Fit) | estimator.fit(X, y) |
Tous les Estimateurs | Estime les paramètres à partir des données ; retourne self |
| Prédire (Predict) | predictor.predict(X) |
Tous les Prédicteurs | Génère des étiquettes discrètes ou des valeurs cibles continues |
| Probabilité | predictor.predict_proba(X) |
Classificateurs | Produit la matrice de distribution des probabilités a posteriori |
| Distance de décision | predictor.decision_function(X) |
Modèles linéaires / SVM | Distance signée des échantillons à l'hyperplan séparateur |
| Transformer | transformer.transform(X) |
Tous les Transformateurs | Projette les caractéristiques d'entrée via les paramètres appris |
| Ajuster & Transformer | transformer.fit_transform(X) |
Tous les Transformateurs | Calcule les paramètres et transforme en une seule étape optimisée |
| Score par défaut | estimator.score(X, y) |
Classificateurs / Régresseurs | Précision (Accuracy) en classification ; coefficient $R^2$ en régression |
6. Métriques d'évaluation (sklearn.metrics)
6.1 Métriques de classification
from sklearn.metrics import (
accuracy_score, precision_score, recall_score, f1_score,
roc_auc_score, confusion_matrix, classification_report,
ConfusionMatrixDisplay
)
# 1. Métriques de classification à étiquettes dures (spécifier average en multi-classes)
acc = accuracy_score(y_test, y_pred)
prec = precision_score(y_test, y_pred, average='macro')
rec = recall_score(y_test, y_pred, average='macro')
f1 = f1_score(y_test, y_pred, average='macro')
# 2. Métriques de classement continu (ROC-AUC requiert les probabilités prédites)
y_prob = clf.predict_proba(X_test)[:, 1] # Probabilités de la classe positive binaire
auc = roc_auc_score(y_test, y_prob)
# 3. Matrice de confusion & rapport textuel détaillé
cm = confusion_matrix(y_test, y_pred)
print(classification_report(y_test, y_pred))
# 4. Affichage visuel de la matrice de confusion
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot()
6.2 Métriques de régression
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = mean_squared_error(y_test, y_pred, squared=False) # Racine de l'erreur quadratique moyenne (RMSE)
r2 = r2_score(y_test, y_pred) # Coefficient de détermination R²
6.3 Métriques de partitionnement (Clustering)
from sklearn.metrics import (
adjusted_rand_score, homogeneity_score, v_measure_score, silhouette_score
)
# Validation externe (lorsque les vraies étiquettes sont connues)
ari = adjusted_rand_score(y_true, cluster_labels) # Plage : [-1, 1], plus élevé est meilleur
homo = homogeneity_score(y_true, cluster_labels) # Plage : [0, 1]
vm = v_measure_score(y_true, cluster_labels) # Moyenne harmonique de l'homogénéité et de la complétude
# Validation interne (basée sur la géométrie, sans vraies étiquettes)
sil = silhouette_score(X, cluster_labels) # Plage : [-1, 1], proche de 1 indique des clusters bien séparés
7. Validation croisée & Réglage des hyperparamètres (sklearn.model_selection)
7.1 Validation croisée (Cross-Validation)
from sklearn.model_selection import cross_val_score, cross_validate, StratifiedKFold
# Validation croisée K-Fold standard
scores = cross_val_score(clf, X, y, cv=5, scoring='accuracy')
print(f"Précision 5-Fold CV : {scores.mean():.4f} (±{scores.std():.4f})")
# Générateur K-Fold stratifié
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores_skf = cross_val_score(clf, X, y, cv=skf, scoring='f1_macro')
# Évaluation conjointe multi-métriques
multi_scores = cross_validate(
clf, X, y, cv=5,
scoring=['accuracy', 'roc_auc'],
return_train_score=False
)
print("AUC moyenne de validation :", multi_scores['test_roc_auc'].mean())
7.2 Recherche sur grille & Recherche aléatoire
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from scipy.stats import randint
# 1. Recherche exhaustive sur grille (GridSearchCV)
param_grid = {
'n_neighbors': [3, 5, 7, 11],
'weights': ['uniform', 'distance'],
'metric': ['euclidean', 'manhattan']
}
grid = GridSearchCV(
estimator=KNeighborsClassifier(),
param_grid=param_grid,
cv=5,
scoring='accuracy',
n_jobs=-1
)
grid.fit(X_train, y_train)
print("Meilleurs paramètres :", grid.best_params_)
best_model = grid.best_estimator_
# 2. Recherche aléatoire de paramètres (pour les grands espaces de recherche)
param_dist = {
'n_estimators': randint(50, 300),
'max_depth': [None, 5, 10, 20],
'min_samples_split': randint(2, 11)
}
rand_search = RandomizedSearchCV(
estimator=RandomForestClassifier(random_state=42),
param_distributions=param_dist,
n_iter=20, # Nombre de combinaisons de paramètres aléatoires
cv=5,
scoring='accuracy',
random_state=42,
n_jobs=-1
)
rand_search.fit(X_train, y_train)
print("Meilleurs paramètres Random Search :", rand_search.best_params_)
8. Bonnes pratiques de production : Pipeline & ColumnTransformer
8.1 Pourquoi les Pipelines sont indispensables
Effectuer une mise à l'échelle ou une imputation de façon globale sur l'ensemble du jeu de données avant le découpage entraîne une fuite de données (Data Leakage) : les statistiques des plis de validation contaminent l'entraînement, produisant des scores trompeusement optimistes hors ligne qui s'effondrent en production.
Pipeline encapsule les transformations et estimateurs en une entité atomique sans fuite. En validation croisée, les transformateurs sont strictement ajustés sur chaque pli d'entraînement et appliqués sur le pli de validation.
8.2 Recette ColumnTransformer pour la production
Les données tabulaires réelles mélangent colonnes numériques continues et variables catégorielles :
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import RandomForestClassifier
# 1. Partition explicite des noms de colonnes
numeric_features = ['age', 'income', 'credit_score']
categorical_features = ['gender', 'occupation', 'city']
# 2. Sous-pipeline numérique : imputation médiane -> mise à l'échelle standard
numeric_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='median')),
('scaler', StandardScaler())
])
# 3. Sous-pipeline catégoriel : imputation par constante -> encodage One-Hot
categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])
# 4. Liaison des colonnes dans un ColumnTransformer unifié
preprocessor = ColumnTransformer(transformers=[
('num', numeric_transformer, numeric_features),
('cat', categorical_transformer, categorical_features)
])
# 5. Assemblage du pipeline complet du modèle
full_pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('classifier', RandomForestClassifier(n_estimators=100, random_state=42))
])
# 6. Entraînement et inférence atomiques (zéro fuite, déploiement fiable)
full_pipeline.fit(X_train_df, y_train)
y_pred = full_pipeline.predict(X_test_df)
print("Précision du test du Pipeline :", full_pipeline.score(X_test_df, y_test))