Skip to content

Machine Learning Aide-mémoire

Concepts, algorithmes et implémentation Python du machine learning.

01

Démarrage

Qu'est-ce que le machine learning ?

Le machine learning bâtit des systèmes qui généralisent depuis les données plutôt que de suivre des règles écrites à la main. Les trois paradigmes (supervisé, non supervisé, renforcement) couvrent la plupart des problèmes réels. Suivre un workflow structuré — surtout en réservant un jeu de test propre — prévient le péché cardinal du sur-apprentissage de votre évaluation.

machine-learning
# Machine Learning: systems that learn patterns from data
# instead of being explicitly programmed.

# Three main paradigms:
# - Supervised:    learn f: X -> y from labeled (X, y) pairs
# - Unsupervised:  find structure in unlabeled X
# - Reinforcement: learn actions that maximize reward via trial-and-error

# Typical workflow:
# 1. Define problem & collect data
# 2. Preprocess & feature engineering
# 3. Split train / validation / test
# 4. Train model, tune hyperparameters
# 5. Evaluate on test set
# 6. Deploy & monitor

Bibliothèques principales

scikit-learn est le cheval de trait du ML tabulaire/classique — une API fit/predict/transform cohérente sur tous les algorithmes. NumPy et Pandas gèrent la préparation des données ; Matplotlib/Seaborn la visualisation. Pour le deep learning, choisissez PyTorch (orienté recherche) ou TensorFlow/Keras (orienté production) — les deux couvrent le même terrain.

machine-learning
# The standard ML stack in Python
import numpy as np          # numerical arrays
import pandas as pd         # tabular data
import matplotlib.pyplot as plt  # plotting
import seaborn as sns       # statistical plots

# scikit-learn: classical ML (trees, SVM, linear models, preprocessing)
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# Deep learning (pick one):
import torch                # PyTorch
# import tensorflow as tf   # TensorFlow/Keras

# Install:
# pip install numpy pandas matplotlib seaborn scikit-learn torch

Découpage Train / Validation / Test

Ne touchez jamais le jeu de test avant l'évaluation finale — l'employer pour le réglage fuite de l'information et gonfle vos métriques rapportées. stratify=y préserve l'équilibre des classes, critique pour la classification déséquilibrée. random_state rend les découpages reproductibles. Pour les petits jeux de données, employez la CV k-fold au lieu d'un jeu de validation fixe.

machine-learning
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,      # 20% held out for test
    random_state=42,    # reproducibility
    stratify=y,         # keep class proportions (classification only)
)

# For a third validation set:
X_train, X_temp, y_train, y_temp = train_test_split(
    X, y, test_size=0.4, stratify=y, random_state=42)
X_val, X_test, y_val, y_test = train_test_split(
    X_temp, y_temp, test_size=0.5, stratify=y_temp, random_state=42)
# Now: 60% train, 20% val, 20% test

Premier modèle (Iris)

Le jeu de données Iris est le « Hello World » du ML — 150 échantillons de fleurs, 4 caractéristiques, 3 classes. Ce snippet montre le pattern canonique sklearn : charger les données, découper, instancier un modèle, fit, predict, évaluer. classification_report donne précision/rappel/F1 par classe, bien plus informatif que la seule exactitude pour les problèmes déséquilibrés.

machine-learning
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

iris = load_iris()
X, y = iris.data, iris.target

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

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(classification_report(y_test, y_pred, target_names=iris.target_names))

Reproductibilité

Fixez les graines pour numpy, random et votre framework DL pour que les initialisations de poids et les mélanges soient reproductibles. Passez random_state à chaque estimateur stochastique sklearn. Le déterminisme complet (surtout sur GPU) exige aussi des algorithmes déterministes et des flags d'env — utile pour déboguer des résultats qui « devraient » se correspondre mais ne le font pas.

machine-learning
import numpy as np
import random
import torch

SEED = 42
np.random.seed(SEED)
random.seed(SEED)
torch.manual_seed(SEED)
if torch.cuda.is_available():
    torch.cuda.manual_seed_all(SEED)

# For sklearn, pass random_state to each estimator:
# RandomForestClassifier(random_state=SEED)

# Force deterministic operations (slower but fully reproducible):
torch.use_deterministic_algorithms(True)

# Optional: pin GPU non-determinism
import os
os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
02

Prétraitement des données

Gérer les valeurs manquantes

Ajuster un imputer sur tout le jeu de données fuit les statistiques du test vers l'entraînement — ajustez toujours sur le train seulement. La médiane est plus robuste aux valeurs aberrantes que la moyenne. Pour les caractéristiques catégorielles, employez 'most_frequent' ou 'constant'. L'imputation KNN peut capter la structure multivariée mais est coûteuse sur les grandes données. Demandez-vous si la présence d'un manque est informative (ajoutez un indicateur 'is_missing').

machine-learning
import pandas as pd
from sklearn.impute import SimpleImputer, KNNImputer

df = pd.DataFrame({"age": [25, np.nan, 35, 45],
                   "income": [50000, 60000, np.nan, 80000]})

# Drop rows with any missing values (use sparingly)
df_drop = df.dropna()

# Mean/median/mode imputation
imp = SimpleImputer(strategy="median")  # 'mean','most_frequent','constant'
df_imputed = pd.DataFrame(imp.fit_transform(df), columns=df.columns)

# KNN imputer (uses similar samples)
knn_imp = KNNImputer(n_neighbors=3)
df_knn = pd.DataFrame(knn_imp.fit_transform(df), columns=df.columns)

# Always fit imputers on TRAINING data only, then transform test
imp.fit(X_train)
X_train_imp = imp.transform(X_train)
X_test_imp  = imp.transform(X_test)   # uses train medians

Mise à l'échelle et normalisation

Beaucoup d'algorithmes (SVM, KNN, régression logistique, réseaux de neurones, PCA) sont sensibles à l'échelle — les modèles à arbres généralement non. StandardScaler est le défaut ; MinMaxScaler quand il faut des plages bornées (ex. images) ; RobustScaler quand les valeurs aberrantes déformeraient StandardScaler. Ajustez TOUJOURS sur le train et transformez le test avec le même scaler ajusté — jamais de fit_transform sur le test.

machine-learning
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

# Standardization: mean 0, std 1 (most common)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled  = scaler.transform(X_test)   # use train mean/std!

# Min-max: scale to [0, 1]
minmax = MinMaxScaler()
X_mm = minmax.fit_transform(X_train)

# Robust to outliers: uses median & IQR
robust = RobustScaler()
X_robust = robust.fit_transform(X_train)

Encoder les variables catégorielles

LabelEncoder sert à la cible ; OneHotEncoder aux caractéristiques nominales (pas d'ordre inhérent — le one-hot évite d'impliquer rouge < vert < bleu). OrdinalEncoder convient aux catégories ordonnées comme les tailles. handle_unknown='ignore' prévient les erreurs sur les catégories inconnues au moment du test. Les catégorielles à haute cardinalité (ex. codes postaux) se traitent mieux par encodage cible/comptage pour éviter l'explosion de dimensionnalité.

machine-learning
from sklearn.preprocessing import LabelEncoder, OneHotEncoder, OrdinalEncoder

# Label encode TARGET (classification): strings -> integers
le = LabelEncoder()
y = le.fit_transform(["cat", "dog", "cat", "bird"])  # [0, 1, 0, 2]
le.inverse_transform([0, 1, 2])                       # back to strings

# One-hot encode FEATURES (nominal, no order)
ohe = OneHotEncoder(sparse_output=False, handle_unknown="ignore")
X_ohe = ohe.fit_transform(df[["color"]])  # red/green/blue -> 3 cols

# Ordinal encode (ordered categories)
oe = OrdinalEncoder(categories=[["low", "medium", "high"]])
X_ord = oe.fit_transform(df[["size"]])

# For high-cardinality features, consider target encoding
# or just drop them if they're IDs.

Gérer les données déséquilibrées

Les données déséquilibrées biaisent les modèles vers la classe majoritaire. Le correctif le plus propre est class_weight='balanced' (pas de duplication de données). SMOTE synthétise de nouveaux échantillons minoritaires mais peut créer du bruit — ne l'appliquez qu'au train. Le sur/ sous-échantillonnage fonctionne mais peut sur-apprendre ou perdre des données. Évaluez toujours avec précision, rappel, F1 et AUC — jamais la seule exactitude sur des données déséquilibrées.

machine-learning
from sklearn.utils import resample
from imblearn.over_sampling import SMOTE
from sklearn.utils.class_weight import compute_class_weight

# 1. Class weights (no resampling — preferred for trees/linear)
classes = np.unique(y_train)
weights = compute_class_weight("balanced", classes=classes, y=y_train)
class_weight = dict(zip(classes, weights))
model = RandomForestClassifier(class_weight=class_weight)

# 2. Oversample minority
df_majority = df[df.y == 0]
df_minority = df[df.y == 1]
df_minority_up = resample(df_minority, replace=True,
                          n_samples=len(df_majority), random_state=42)

# 3. SMOTE: synthesize new minority samples via k-nearest neighbors
smote = SMOTE(random_state=42)
X_res, y_res = smote.fit_resample(X_train, y_train)

# Always resample on TRAINING data only — never the test set!

Détection des valeurs aberrantes

Les valeurs aberrantes déforment moyennes, écarts-types et modèles linéaires. Le z-score est rapide mais suppose la normalité et est lui-même déformé par les aberrantes (employez plutôt l'IQR robuste). Isolation Forest gère les hautes dimensions et les frontières non linéaires. Décidez de supprimer, plafonner (winsoriser) ou garder selon le domaine — parfois les aberrantes sont exactement les cas qui vous importent (fraude, anomalies).

machine-learning
import numpy as np
from sklearn.ensemble import IsolationForest

# Z-score: |x - mean| / std > 3 is an outlier
z_scores = np.abs((X - X.mean()) / X.std())
outliers = (z_scores > 3).any(axis=1)

# IQR method (more robust to outliers than z-score)
Q1, Q3 = X.quantile(0.25), X.quantile(0.75)
IQR = Q3 - Q1
outliers_iqr = ((X < (Q1 - 1.5 * IQR)) | (X > (Q3 + 1.5 * IQR))).any(axis=1)

# Isolation Forest (good for high-dimensional data)
iso = IsolationForest(contamination=0.05, random_state=42)
outliers_iso = iso.fit_predict(X)  # -1 = outlier, 1 = inlier

# Remove or cap (winsorize) outliers before training
X_clean = X[~outliers]
03

Ingénierie des caractéristiques

Caractéristiques polynomiales et d'interaction

PolynomialFeatures laisse les modèles linéaires capter les relations non linéaires en ajoutant x^2, x*y, etc. comme nouvelles caractéristiques. interaction_only évite les carrés purs, utile quand on ne veut que des termes croisés. Le compte de caractéristiques explose combinatoirement — associez toujours une régularisation (Ridge/Lasso) pour prévenir le sur-apprentissage, ou employez-le après une réduction de dimensionnalité.

machine-learning
from sklearn.preprocessing import PolynomialFeatures

# Generate degree-2 features including interactions
poly = PolynomialFeatures(degree=2, interaction_only=False,
                          include_bias=False)
X_poly = poly.fit_transform(X)
# For X = [a, b], produces: [a, b, a^2, a*b, b^2]

# interaction_only=True keeps just [a, b, a*b] — no squares
poly_int = PolynomialFeatures(degree=2, interaction_only=True,
                              include_bias=False)
X_int = poly_int.fit_transform(X)

# Useful for linear models to capture non-linearity
# WARNING: feature count grows quickly — use with regularization

Binning et discrétisation

Le binning convertit les caractéristiques continues en buckets discrets, aidant les modèles à capter les effets non linéaires et réduisant la sensibilité aux valeurs aberrantes. Les bins par quantiles (fréquence égale) évitent le problème des bins vides des bins à largeur égale. Les bins propres au domaine (ex. tranches d'âge) battent souvent les automatiques. Encodez en one-hot les caractéristiques binées pour que le modèle traite les buckets comme catégories distinctes.

machine-learning
from sklearn.preprocessing import KBinsDiscretizer
import pandas as pd

# Equal-width bins (uniform spacing)
df["age_bin"] = pd.cut(df["age"], bins=5, labels=False)

# Equal-frequency bins (quantiles — same count per bin)
df["age_quantile"] = pd.qcut(df["age"], q=5, labels=False,
                              duplicates="drop")

# KBinsDiscretizer with strategy
kbd = KBinsDiscretizer(n_bins=5, encode="onehot-dense",
                        strategy="quantile")  # 'uniform','kmeans'
X_binned = kbd.fit_transform(X[["age"]])

# Custom bins with domain knowledge
df["age_group"] = pd.cut(df["age"],
                          bins=[0, 18, 35, 60, 100],
                          labels=["child","young","adult","senior"])

Extraction de caractéristiques textuelles

Les comptages sac-de-mots sont simples mais traitent tous les mots pareil ; TF-IDF rabaisse les mots communs aux documents. ngram_range=(1,2) capte les courtes phrases. Pour le NLP moderne, employez des embeddings pré-entraînés (sentence-transformers, BERT) — ils capturent la sémantique que le sac-de-mots ne peut. Réglez toujours max_features et min_df pour contrôler la taille du vocabulaire et le bruit.

machine-learning
from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer

corpus = [
    "machine learning is fun",
    "deep learning is a subset of machine learning",
    "python is great for data science",
]

# Bag of words (counts)
cv = CountVectorizer(max_features=1000, stop_words="english",
                     ngram_range=(1, 2))
X_counts = cv.fit_transform(corpus)

# TF-IDF: downweights common words
tfidf = TfidfVectorizer(max_features=1000, stop_words="english",
                        ngram_range=(1, 2), min_df=2)
X_tfidf = tfidf.fit_transform(corpus)

# For production, consider sentence-transformers for embeddings:
# from sentence_transformers import SentenceTransformer
# model = SentenceTransformer("all-MiniLM-L6-v2")
# embeddings = model.encode(corpus)

Caractéristiques de date et heure

Les colonnes datetime brutes sont inutiles aux modèles — extrayez les parties significatives (heure, jour de semaine, mois). Les caractéristiques cycliques (sin/cos) préservent la continuité : l'heure 23 est proche de l'heure 0, ce que l'encodage entier brut rate. is_weekend et les jours fériés capturent les motifs du cycle humain. days_since est une simple caractéristique de tendance pour les séries temporelles.

machine-learning
import pandas as pd

df["date"] = pd.to_datetime(df["date"])

# Extract calendar parts
df["year"]      = df["date"].dt.year
df["month"]     = df["date"].dt.month
df["day"]       = df["date"].dt.day
df["dayofweek"] = df["date"].dt.dayofweek    # 0=Mon
df["dayofyear"] = df["date"].dt.dayofyear
df["hour"]      = df["date"].dt.hour
df["is_weekend"] = df["date"].dt.dayofweek >= 5

# Cyclic encoding (preserves continuity: hour 23 -> 0)
df["hour_sin"] = np.sin(2 * np.pi * df["hour"] / 24)
df["hour_cos"] = np.cos(2 * np.pi * df["hour"] / 24)
df["month_sin"] = np.sin(2 * np.pi * df["month"] / 12)
df["month_cos"] = np.cos(2 * np.pi * df["month"] / 12)

# Time elapsed (useful as a trend feature)
df["days_since"] = (df["date"] - df["date"].min()).dt.days

Sélection de caractéristiques

Plus de caractéristiques n'est pas mieux — les non pertinentes ajoutent du bruit et un risque de sur-apprentissage. SelectKBest est rapide et statistique ; RFE est minutieux mais lent (ré-entraîne le modèle répétément) ; SelectFromModel emploie les feature_importances_ d'un arbre comme filtre en un coup. Les filtres de corrélation retirent les caractéristiques redondantes à bon compte. Ne faites la sélection que sur les données d'ENTRAÎNEMENT et appliquez le même sélecteur au test.

machine-learning
from sklearn.feature_selection import (SelectKBest, f_classif,
    RFE, SelectFromModel)
from sklearn.ensemble import RandomForestClassifier

# 1. Univariate: keep top-k by statistical test
selector = SelectKBest(f_classif, k=10)
X_new = selector.fit_transform(X, y)
selected = selector.get_support(indices=True)

# 2. Recursive Feature Elimination (model-based, iterative)
rfe = RFE(RandomForestClassifier(random_state=42),
          n_features_to_select=10)
X_rfe = rfe.fit_transform(X, y)

# 3. Select from model importance
sfm = SelectFromModel(RandomForestClassifier(random_state=42),
                      threshold="median")
X_sfm = sfm.fit_transform(X, y)

# 4. Correlation filter — drop one of highly-correlated pairs
corr = pd.DataFrame(X).corr().abs()
to_drop = [c for c in corr.columns
           if any(corr[c] > 0.95)]
X_filtered = X.drop(columns=to_drop)
04

Apprentissage supervisé

Régressions linéaire et logistique

Les modèles linéaires sont rapides, interprétables et un solide point de départ. LogisticRegression emploie la régularisation L2 par défaut ; un C plus bas signifie une régularisation plus forte. En multiclasse, il emploie softmax. Les coefficients montrent l'importance des caractéristiques mais seulement après mise à l'échelle — des caractéristiques non mises à l'échelle rendent les coefficients incomparables. Commencez toujours par une base linéaire avant les modèles complexes.

machine-learning
from sklearn.linear_model import LinearRegression, LogisticRegression

# Regression: predict a continuous value
lr = LinearRegression()
lr.fit(X_train, y_train)
y_pred = lr.predict(X_test)

# Inspect coefficients
print("Coef:", lr.coef_, "Intercept:", lr.intercept_)

# Classification: predict a class (uses softmax for multiclass)
clf = LogisticRegression(
    penalty="l2",            # 'l1' (Lasso), 'elasticnet', None
    C=1.0,                   # inverse of regularization strength
    max_iter=1000,
    multi_class="multinomial",
)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
y_proba = clf.predict_proba(X_test)  # class probabilities

Arbres de décision et forêts aléatoires

Les arbres de décision sont interprétables mais à haute variance — de petits changements de données donnent des arbres très différents. Les forêts aléatoires y remédient en moyennant beaucoup d'arbres entraînés sur des échantillons bootstrap avec sous-ensembles aléatoires de caractéristiques (bagging). max_features='sqrt' est le standard en classification. L'importance des caractéristiques issue des forêts est biaisée vers les caractéristiques à haute cardinalité — essayez permutation_importance pour une vue plus juste.

machine-learning
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier

# Single tree (high variance, easy to overfit)
tree = DecisionTreeClassifier(
    max_depth=5,              # limit depth to prevent overfitting
    min_samples_leaf=10,      # min samples per leaf
    random_state=42,
)
tree.fit(X_train, y_train)

# Random forest: ensemble of trees on bootstrapped samples
rf = RandomForestClassifier(
    n_estimators=200,         # number of trees
    max_depth=None,
    max_features="sqrt",      # features per split
    n_jobs=-1,                # use all CPUs
    random_state=42,
)
rf.fit(X_train, y_train)

# Feature importance (averaged across trees)
importances = pd.Series(rf.feature_importances_, index=X.columns)

Gradient boosting (XGBoost / LightGBM)

Le gradient boosting bâtit des arbres séquentiellement, chacun corrigeant les erreurs du précédent — généralement la meilleure performance sur les données tabulaires. Le GradientBoosting de sklearn est lent ; HistGradientBoosting est son équivalent rapide à histogrammes. XGBoost et LightGBM sont les standards production/compétition avec gestion native des valeurs manquantes et arrêt précoce. Employez toujours early_stopping avec un jeu de validation pour trouver le nombre optimal d'arbres.

machine-learning
from sklearn.ensemble import GradientBoostingClassifier, HistGradientBoostingClassifier
import lightgbm as lgb
import xgboost as xgb

# sklearn (slow on large data)
gbm = GradientBoostingClassifier(
    n_estimators=200, learning_rate=0.1, max_depth=3, random_state=42)
gbm.fit(X_train, y_train)

# sklearn's faster histogram-based version (like LightGBM)
hgbm = HistGradientBoostingClassifier(
    max_iter=200, learning_rate=0.1, max_leaf_nodes=31, random_state=42)
hgbm.fit(X_train, y_train)

# XGBoost (popular in competitions)
xgb_clf = xgb.XGBClassifier(
    n_estimators=200, learning_rate=0.1, max_depth=6,
    subsample=0.8, colsample_bytree=0.8, n_jobs=-1,
    eval_metric="logloss", random_state=42)
xgb_clf.fit(X_train, y_train, eval_set=[(X_val, y_val)], early_stopping_rounds=10)

# LightGBM (fastest on large data)
lgb_clf = lgb.LGBMClassifier(n_estimators=200, learning_rate=0.1, num_leaves=31)
lgb_clf.fit(X_train, y_train, eval_set=(X_val, y_val))

Machines à vecteurs de support

Les SVM trouvent l'hyperplan à marge maximale séparant les classes — puissants pour les jeux de données petits à moyens aux frontières claires. La mise à l'échelle est obligatoire (les SVM sont basés sur les distances). Le noyau RBF traite la non-linéarité ; ajustez C (régularisation) et gamma (largeur du noyau) par recherche en grille. SVC passe mal à l'échelle avec les échantillons (O(n^2)–O(n^3)) — au-delà de 50k échantillons, employez LinearSVC ou un ensemble d'arbres.

machine-learning
from sklearn.svm import SVC, SVR
from sklearn.preprocessing import StandardScaler

# SVC requires scaling!
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s  = scaler.transform(X_test)

# Kernels: 'linear', 'rbf' (Gaussian), 'poly', 'sigmoid'
svm = SVC(
    kernel="rbf",
    C=1.0,              # regularization (higher = fit harder)
    gamma="scale",      # kernel width
    probability=True,   # enable predict_proba (slower)
    random_state=42,
)
svm.fit(X_train_s, y_train)
y_pred = svm.predict(X_test_s)

# SVR for regression
svr = SVR(kernel="rbf", C=1.0, epsilon=0.1)
svr.fit(X_train_s, y_train)

k plus proches voisins

KNN est l'algorithme ML le plus simple : stocker les données d'entraînement, puis prédire par vote parmi les k voisins les plus proches. La mise à l'échelle est essentielle (basé sur les distances). Petit k = faible biais/haute variance (sur-apprend) ; grand k = haut biais/faible variance (sous-apprend). KNN est lent à la prédiction sur les grands jeux de données — employez les plus proches voisins approximatifs (FAISS, HNSW) en production.

machine-learning
from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor

# KNN: classify by majority vote of k nearest training samples
knn = KNeighborsClassifier(
    n_neighbors=5,        # k — try odd values to break ties
    weights="uniform",    # or 'distance' (closer = more weight)
    metric="minkowski",   # 'euclidean','manhattan', etc.
    p=2,                  # 2=euclidean, 1=manhattan
    n_jobs=-1,
)
knn.fit(X_train_scaled, y_train)
y_pred = knn.predict(X_test_scaled)

# Choose k via cross-validation
from sklearn.model_selection import cross_val_score
for k in [1, 3, 5, 7, 9, 11]:
    score = cross_val_score(KNeighborsClassifier(n_neighbors=k),
                            X_train_scaled, y_train, cv=5).mean()
    print(f"k={k}: {score:.3f}")
05

Apprentissage non supervisé

Clustering K-Means

K-Means partitionne les données en k clusters sphériques en minimisant la variance intra-cluster. n_init=10 lance l'algorithme depuis 10 initialisations aléatoires et garde la meilleure (défaut changé en sklearn 1.4). Choisissez k par le coude (inertie) ou le score silhouette (plus fondé). K-Means suppose des clusters sphériques et de même taille — employez DBSCAN ou un mélange gaussien pour les clusters non sphériques.

machine-learning
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

# Choose k via the elbow method or silhouette score
inertias, silhouettes = [], []
for k in range(2, 11):
    km = KMeans(n_clusters=k, n_init=10, random_state=42)
    labels = km.fit_predict(X)
    inertias.append(km.inertia_)
    silhouettes.append(silhouette_score(X, labels))

# Final model with chosen k
kmeans = KMeans(n_clusters=4, n_init=10, random_state=42)
clusters = kmeans.fit_predict(X)
centers = kmeans.cluster_centers_

# Predict cluster for new points
new_labels = kmeans.predict(X_new)

DBSCAN (basé sur la densité)

DBSCAN trouve des clusters de forme arbitraire et détecte automatiquement les valeurs aberrantes (étiquetées -1) — pas besoin de préciser k. eps est le paramètre critique ; ajustez-le par le graphique k-distance (le « coude » des distances aux k plus proches voisins triées). min_samples contrôle la sensibilité au bruit. DBSCAN peine avec la densité variable — HDBSCAN gère mieux. Il ne peut prédire de nouveaux points directement ; ré-ajustez ou employez le approximate_predict de HDBSCAN.

machine-learning
from sklearn.cluster import DBSCAN

# DBSCAN groups densely-connected points; marks sparse ones as noise (-1)
db = DBSCAN(
    eps=0.5,            # max distance between points in a cluster
    min_samples=5,      # min points to form a dense region
    metric="euclidean",
)
labels = db.fit_predict(X)
n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
n_noise = list(labels).count(-1)

# Tune eps via the k-distance plot (k = min_samples)
from sklearn.neighbors import NearestNeighbors
nn = NearestNeighbors(n_neighbors=5).fit(X)
distances, _ = nn.kneighbors(X)
distances = np.sort(distances[:, -1])

# DBSCAN doesn't have predict() — refit to predict on new data
# Or use HDBSCAN for a more robust, parameter-light alternative

Clustering hiérarchique

Le clustering hiérarchique bâtit un arbre (dendrogramme) de clusters imbriqués — utile pour comprendre la structure des clusters à plusieurs granularités. Le dendrogramme montre visuellement où couper pour un nombre quelconque de clusters. La liaison 'ward' (minimise la variance intra-cluster) est la plus courante ; 'single' est fragile (effet de chaînage). AgglomerativeClustering passe mal au-delà de ~10k échantillons — employez K-Means ou HDBSCAN pour les données plus grandes.

machine-learning
from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram, linkage
import matplotlib.pyplot as plt

# Compute linkage matrix (for dendrogram)
Z = linkage(X, method="ward")  # 'ward','complete','average','single'

# Plot dendrogram to choose number of clusters
plt.figure(figsize=(10, 5))
dendrogram(Z, truncate_mode="level", p=5)
plt.axhline(y=Z[-4, 2], color="r", linestyle="--")  # cut at 4 clusters
plt.show()

# Agglomerative clustering with chosen k
agg = AgglomerativeClustering(
    n_clusters=4,
    linkage="ward",   # minimizes variance
    metric="euclidean",
)
labels = agg.fit_predict(X)

Modèles de mélange gaussien

GMM est le pendant probabiliste de K-Means : chaque cluster est une gaussienne avec sa propre moyenne et covariance, il gère donc les clusters elliptiques et donne des affectations douces (probabilités). covariance_type='full' est le plus flexible mais lourd en paramètres ; 'diag' est un bon compromis. Choisissez k par le BIC (plus bas est mieux). GMM peut aussi générer de nouveaux échantillons — utile pour l'augmentation de données.

machine-learning
from sklearn.mixture import GaussianMixture

# GMM: probabilistic clustering — each cluster is a Gaussian
gmm = GaussianMixture(
    n_components=4,
    covariance_type="full",  # 'spherical','tied','diag','full'
    n_init=10,
    random_state=42,
)
gmm.fit(X)

labels = gmm.predict(X)
probs = gmm.predict_proba(X)   # soft clustering (responsibilities)

# Generative: sample new data
X_sampled, y_sampled = gmm.sample(100)

# Choose n_components via BIC (lower is better)
bics = []
for k in range(1, 11):
    g = GaussianMixture(n_components=k, n_init=10, random_state=42).fit(X)
    bics.append(g.bic(X))

Détection d'anomalies

La détection d'anomalies identifie les éléments rares et suspects — fraude, défauts, intrusions. Isolation Forest est le gagnant polyvalent (rapide, passe bien à l'échelle, gère les hautes dimensions). One-Class SVM fonctionne bien quand on dispose d'un jeu d'entraînement « normal » propre. LOF attrape les anomalies locales que les méthodes globales ratent. contamination fixe le taux d'anomalies attendu ; ajustez-le selon la connaissance du domaine.

machine-learning
from sklearn.ensemble import IsolationForest
from sklearn.svm import OneClassSVM
from sklearn.neighbors import LocalOutlierFactor

# Isolation Forest: isolates anomalies with shallow trees
iso = IsolationForest(contamination=0.05, random_state=42)
labels = iso.fit_predict(X)  # -1 anomaly, 1 normal
scores = iso.decision_function(X)  # lower = more anomalous

# One-Class SVM: learns a boundary around normal data
ocsvm = OneClassSVM(kernel="rbf", nu=0.05, gamma="scale")
labels = ocsvm.fit_predict(X_train_normal)

# Local Outlier Factor: density-based (good for local anomalies)
lof = LocalOutlierFactor(n_neighbors=20, contamination=0.05)
labels = lof.fit_predict(X)
# For new data: lof.negative_outlier_factor_ (lower = more anomalous)
06

Régression

Régression linéaire et variantes régularisées

OLS minimise l'erreur quadratique sans régularisation — haute variance sur les données multicolinéaires. Ridge (L2) rétrécit les coefficients en douceur, bien quand beaucoup de caractéristiques comptent. Lasso (L1) pousse certains coefficients à zéro, faisant de la sélection de caractéristiques. ElasticNet mélange les deux, utile quand les caractéristiques sont corrélées. Mettez toujours les caractéristiques à l'échelle avant la régression régularisée pour que la pénalité soit équitable.

machine-learning
from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet

# Ordinary Least Squares
ols = LinearRegression()
ols.fit(X_train, y_train)

# Ridge (L2): shrinks coefficients, keeps all features
ridge = Ridge(alpha=1.0)
ridge.fit(X_train_scaled, y_train)

# Lasso (L1): shrinks some coefficients to 0 (feature selection)
lasso = Lasso(alpha=0.1, max_iter=10000)
lasso.fit(X_train_scaled, y_train)
print("Non-zero coefs:", (lasso.coef_ != 0).sum())

# ElasticNet: mix of L1 and L2
en = ElasticNet(alpha=0.1, l1_ratio=0.5)  # l1_ratio=1 -> pure Lasso
en.fit(X_train_scaled, y_train)

Métriques d'évaluation de régression

RMSE pénalise les grandes erreurs (au carré) et est dans les mêmes unités que y — la métrique la plus courante. MAE est plus interprétable et robuste aux valeurs aberrantes. R2 est la fraction de variance expliquée ; 0 signifie que votre modèle ne vaut pas mieux que prédire la moyenne. MAPE donne l'erreur en pourcentage mais est indéfini quand y=0. Choisissez les métriques selon le coût métier : si les grandes erreurs sont catastrophiques, employez RMSE ; si toutes les erreurs coûtent pareil, MAE.

machine-learning
from sklearn.metrics import (mean_squared_error, mean_absolute_error,
    r2_score, mean_absolute_percentage_error)

y_pred = model.predict(X_test)

mse  = mean_squared_error(y_test, y_pred)         # sensitive to outliers
rmse = np.sqrt(mse)                                # same units as y
mae  = mean_absolute_error(y_test, y_pred)         # robust to outliers
r2   = r2_score(y_test, y_pred)                    # 1=perfect, 0=mean, <0=worse
mape = mean_absolute_percentage_error(y_test, y_pred)  # % error

print(f"RMSE: {rmse:.3f}")
print(f"MAE:  {mae:.3f}")
print(f"R2:   {r2:.3f}")
print(f"MAPE: {mape:.1%}")

# Adjusted R2 accounts for number of features
n, p = X_test.shape
adj_r2 = 1 - (1 - r2) * (n - 1) / (n - p - 1)

Régression par arbre de décision

Les régresseurs à arbres font des prédictions constantes par morceaux — ils ne peuvent extrapoler au-delà des plages des données d'entraînement. Les forêts aléatoires réduisent la variance par moyenne ; le gradient boosting réduit le biais par correction séquentielle. La régression quantile (loss='quantile') prédit un percentile plutôt que la moyenne — combinez les modèles quantile bas/haut pour des intervalles de prédiction, utile quand il faut estimer l'incertitude.

machine-learning
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor

# Single tree (piecewise constant predictions)
dt = DecisionTreeRegressor(max_depth=5, min_samples_leaf=10,
                            random_state=42)
dt.fit(X_train, y_train)

# Random forest regressor (averages trees)
rf = RandomForestRegressor(n_estimators=200, max_features="sqrt",
                            n_jobs=-1, random_state=42)
rf.fit(X_train, y_train)

# Gradient boosting regressor
gb = GradientBoostingRegressor(n_estimators=200, learning_rate=0.1,
                                max_depth=3, random_state=42)
gb.fit(X_train, y_train)

# Quantile regression — predict ranges instead of points
from sklearn.ensemble import GradientBoostingRegressor
gbr_lower = GradientBoostingRegressor(loss="quantile", alpha=0.1)
gbr_upper = GradientBoostingRegressor(loss="quantile", alpha=0.9)
gbr_lower.fit(X_train, y_train)
gbr_upper.fit(X_train, y_train)

Chemin de régularisation

Le chemin de régularisation montre comment les coefficients du Lasso se réduisent à zéro à mesure qu'alpha croît — visualisant l'importance des caractéristiques selon différentes forces de pénalité. Les caractéristiques qui survivent à un alpha élevé sont les plus prédictives. Excellent diagnostic pour comprendre quelles caractéristiques comptent et pour choisir une plage d'alpha raisonnable avant la validation croisée.

machine-learning
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import lasso_path

# Compute Lasso coefficients for many alpha values
alphas, coefs, _ = lasso_path(X_train_scaled, y_train,
                               alphas=np.logspace(-3, 1, 100))

# Plot: each line is a coefficient vs alpha
plt.figure(figsize=(8, 5))
for coef in coefs:
    plt.plot(alphas, coef)
plt.xscale("log")
plt.xlabel("alpha (regularization strength)")
plt.ylabel("coefficient")
plt.title("Lasso regularization path")
plt.axhline(0, color="k", lw=0.5)
plt.show()

Analyse des résidus

Les graphiques de résidus diagnostiquent la mauvaise spécification du modèle. Un nuage aléatoire autour de 0 signifie que le modèle s'ajuste bien ; une forme en U suggère une non-linéarité manquante (ajoutez des caractéristiques polynomiales ou employez un arbre) ; une forme d'entonnoir indique de l'hétéroscédasticité (essayez une transformation log de y). La normalité des résidus compte pour l'inférence (intervalles de confiance) mais pas pour la précision de prédiction.

machine-learning
import matplotlib.pyplot as plt
import seaborn as sns

residuals = y_test - y_pred

fig, axes = plt.subplots(1, 2, figsize=(12, 5))

# 1. Residuals vs predicted — should look random around 0
axes[0].scatter(y_pred, residuals, alpha=0.5)
axes[0].axhline(0, color="r", linestyle="--")
axes[0].set_xlabel("Predicted"); axes[0].set_ylabel("Residual")

# 2. Residual distribution — should be ~normal
sns.histplot(residuals, kde=True, ax=axes[1])
axes[1].set_xlabel("Residual")

plt.show()

# Patterns in residuals suggest model issues:
# - U-shape: missing non-linearity (add polynomial features)
# - Funnel: heteroscedasticity (try log-transforming y)
# - Skew: try transforming y or use a different loss
07

Classification

Bases de la classification binaire

predict renvoie des étiquettes de classe dures (seuil 0.5) ; predict_proba renvoie des probabilités — généralement plus utile. Le seuil par défaut de 0.5 est rarement optimal : abaissez-le pour un rappel plus haut (attraper plus de positifs, ex. dépistage du cancer), élevez-le pour une précision plus haute (moins de fausses alertes, ex. filtre anti-spam). ROC-AUC mesure la qualité du classement des positifs au-dessus des négatifs, indépendamment du seuil.

machine-learning
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (confusion_matrix, classification_report,
    roc_auc_score, precision_recall_curve)

clf = LogisticRegression(max_iter=1000)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
y_proba = clf.predict_proba(X_test)[:, 1]  # P(class=1)

# Confusion matrix: TN FP / FN TP
cm = confusion_matrix(y_test, y_pred)
print(cm)
print(classification_report(y_test, y_pred))

# Adjust threshold (default 0.5) to trade precision for recall
y_pred_custom = (y_proba > 0.3).astype(int)  # higher recall

# ROC-AUC: probability ranking quality (threshold-independent)
print("ROC-AUC:", roc_auc_score(y_test, y_proba))

Matrice de confusion et métriques dérivées

L'exactitude est trompeuse sur les données déséquilibrées — un jeu à 99% de négatifs donne 99% d'exactitude en prédisant tout négatif. La précision et le rappel exposent le compromis précision-rappel : la précision répond « parmi les positifs prédits, combien sont réels ? », le rappel « parmi les positifs réels, combien avons-nous attrapés ? ». F1 est leur moyenne harmonique. Employez la moyenne macro quand les classes doivent peser également, weighted quand elles doivent refléter leur fréquence.

machine-learning
from sklearn.metrics import (confusion_matrix, precision_score,
    recall_score, f1_score)

# Binary: confusion_matrix returns [[TN, FP], [FN, TP]]
tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel()

accuracy  = (tp + tn) / (tp + tn + fp + fn)
precision = tp / (tp + fp)    # of predicted positives, how many correct
recall    = tp / (tp + fn)    # of actual positives, how many caught
f1        = 2 * precision * recall / (precision + recall)  # harmonic mean
specificity = tn / (tn + fp)  # true negative rate

# sklearn shortcuts
print("Precision:", precision_score(y_test, y_pred))
print("Recall:    ", recall_score(y_test, y_pred))
print("F1:        ", f1_score(y_test, y_pred))

# Multi-class: average='macro' (unweighted) or 'weighted' (by class size)
print("Macro F1:", f1_score(y_test, y_pred, average="macro"))

Courbes ROC et PR

Les courbes ROC tracent le rappel (TPR) contre le taux de faux positifs à travers les seuils ; l'aire sous la courbe (AUC) résume la qualité du classement (0.5 = aléatoire, 1.0 = parfait). Les courbes PR sont plus informatives que ROC sur les données déséquilibrées — ROC peut sembler déceptivement bon quand les négatifs dominent. Visez le coin haut-gauche en ROC et haut-droite en PR.

machine-learning
from sklearn.metrics import (roc_curve, precision_recall_curve,
    auc, RocCurveDisplay, PrecisionRecallDisplay)
import matplotlib.pyplot as plt

# ROC curve: TPR (recall) vs FPR at all thresholds
fpr, tpr, thresholds = roc_curve(y_test, y_proba)
roc_auc = auc(fpr, tpr)

# PR curve: precision vs recall (better for imbalanced data)
prec, rec, thresholds = precision_recall_curve(y_test, y_proba)
pr_auc = auc(rec, prec)

fig, axes = plt.subplots(1, 2, figsize=(12, 5))
RocCurveDisplay.from_predictions(y_test, y_proba, ax=axes[0])
PrecisionRecallDisplay.from_predictions(y_test, y_proba, ax=axes[1])
axes[0].set_title(f"ROC (AUC={roc_auc:.3f})")
axes[1].set_title(f"PR (AUC={pr_auc:.3f})")
plt.show()

Classification multiclasse

Pour N>2 classes, LogisticRegression emploie softmax (multi_class='multinomial'). La précision/rappel par classe montre quelles classes le modèle confond. Normalisez la matrice de confusion par ligne (classe réelle) pour voir le rappel par classe — utile pour repérer les catégories systématiquement mal classées. Le kappa de Cohen ajuste l'exactitude pour l'accord dû au hasard ; log_loss mesure la qualité des probabilités prédites (plus bas est mieux).

machine-learning
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (cohen_kappa_score, log_loss,
    classification_report, confusion_matrix, ConfusionMatrixDisplay)

# Multiclass: logistic regression uses softmax by default
clf = LogisticRegression(multi_class="multinomial", max_iter=1000)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
y_proba = clf.predict_proba(X_test)

# Per-class report
print(classification_report(y_test, y_pred))

# Confusion matrix (now NxN)
disp = ConfusionMatrixDisplay.from_predictions(
    y_test, y_pred, display_labels=clf.classes_,
    cmap="Blues", normalize="true")  # normalize per true class

# Multiclass metrics
print("Cohen's kappa:", cohen_kappa_score(y_test, y_pred))
print("Log loss:     ", log_loss(y_test, y_proba))

Calibration des probabilités

Un modèle à 80% de probabilité prédite devrait avoir raison 80% du temps — mais beaucoup de classifieurs (Random Forest, SVM, Naive Bayes) sortent des scores non calibrés. CalibratedClassifierCV corrige cela en ajustant une régression isotonique ou sigmoïde sur un jeu retenu. La calibration compte dès qu'on agit sur les probabilités (scoring de risque, ajustement de seuil) — inutile si on n'emploie que des prédictions de classe dures.

machine-learning
from sklearn.calibration import CalibratedClassifierCV, calibration_curve
import matplotlib.pyplot as plt

# Many classifiers output poorly-calibrated probabilities
# (e.g. Random Forest, SVM). Calibrate them.

# Method 1: isotonic regression (more flexible, needs more data)
# Method 2: sigmoid (Platt scaling) — parametric, works with less data
calibrated = CalibratedClassifierCV(rf, method="isotonic", cv=5)
calibrated.fit(X_train, y_train)
y_proba = calibrated.predict_proba(X_test)[:, 1]

# Calibration curve: predicted prob vs observed frequency
prob_true, prob_pred = calibration_curve(y_test, y_proba, n_bins=10)
plt.plot([0, 1], [0, 1], "k--")
plt.plot(prob_pred, prob_true, "s-")
plt.xlabel("Predicted probability"); plt.ylabel("Observed frequency")
plt.show()
08

Clustering en profondeur

Choisir k : coude et silhouette

La méthode du coude cherche le k où l'inertie cesse de chuter vite — subjectif et parfois invisible. Le score silhouette est plus fondé : il mesure la similarité de chaque point à son propre cluster contre le cluster le plus proche (plage -1 à 1). Silhouette > 0.5 est une structure raisonnable ; > 0.7 est fort. Visualisez toujours les deux et préférez la silhouette quand le coude n'est pas clair.

machine-learning
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score, silhouette_samples
import matplotlib.pyplot as plt

# Elbow method: inertia (sum of squared distances to centroid)
inertias = []
for k in range(1, 11):
    km = KMeans(n_clusters=k, n_init=10, random_state=42).fit(X)
    inertias.append(km.inertia_)

plt.plot(range(1, 11), inertias, "o-")
plt.xlabel("k"); plt.ylabel("Inertia"); plt.title("Elbow method")
plt.show()

# Silhouette: -1 (bad) to 1 (well-clustered), 0 = on boundary
silhouettes = []
for k in range(2, 11):
    labels = KMeans(n_clusters=k, n_init=10, random_state=42).fit_predict(X)
    silhouettes.append(silhouette_score(X, labels))

Graphique silhouette

Un graphique silhouette montre le coefficient de silhouette de chaque échantillon, groupé par cluster. Des formes « couteau » de largeur égale signifient des clusters équilibrés ; des largeurs inégales signifient que certains clusters dominent. La ligne pointillée rouge est la moyenne — les clusters sous cette ligne sont mal séparés. Employez ce graphique pour comparer visuellement différentes valeurs de k.

machine-learning
from sklearn.metrics import silhouette_samples
import matplotlib.pyplot as plt
import numpy as np

k = 4
km = KMeans(n_clusters=k, n_init=10, random_state=42).fit(X)
labels = km.labels_
sil_values = silhouette_samples(X, labels)

fig, ax = plt.subplots(figsize=(8, 6))
y_lower = 10
for i in range(k):
    ith = np.sort(sil_values[labels == i])
    y_upper = y_lower + len(ith)
    ax.fill_betweenx(np.arange(y_lower, y_upper), 0, ith, alpha=0.7)
    ax.text(-0.05, (y_lower + y_upper) / 2, str(i))
    y_lower = y_upper + 10
ax.axvline(sil_values.mean(), color="red", linestyle="--")
ax.set_xlabel("Silhouette coefficient"); ax.set_ylabel("Cluster")
plt.show()

HDBSCAN (DBSCAN hiérarchique)

HDBSCAN corrige la plus grande faiblesse de DBSCAN — le besoin d'ajuster eps. Il bâtit une hiérarchie sur des niveaux de densité variables et extrait des clusters stables, fonctionnant donc sur des données aux densités de cluster variables. min_cluster_size est le paramètre principal et intuitif (le plus petit cluster qui vous importe). Les points des zones clairsemées reçoivent l'étiquette -1 (bruit). HDBSCAN produit souvent des clusters plus significatifs que K-Means sur des données réelles.

machine-learning
import hdbscan  # pip install hdbscan

# HDBSCAN: DBSCAN that automatically chooses eps via hierarchy
clusterer = hdbscan.HDBSCAN(
    min_cluster_size=5,   # min points to form a cluster
    min_samples=None,     # how conservative to be about noise
    metric="euclidean",
    cluster_selection_method="eom",  # 'leaf' for fine-grained
)
labels = clusterer.fit_predict(X)

# Soft clustering: probability of cluster membership
probs = clusterer.probabilities_

# Compare clusters across parameter settings
clusterer.condensed_tree_.plot()

Évaluation du clustering

Les métriques internes (silhouette, Davies-Bouldin, Calinski-Harabasz) évaluent la qualité des clusters sans vérité terrain — utiles pour la sélection de modèles. Les métriques externes (ARI, NMI) comparent le clustering aux étiquettes connues — utiles pour référencer sur des données étiquetées. ARI et NMI corrigent tous deux le hasard et sont invariants à la permutation. Aucune métrique n'est la meilleure — employez-en plusieurs et visualisez les clusters.

machine-learning
from sklearn.metrics import (silhouette_score, davies_bouldin_score,
    calinski_harabasz_score, adjusted_rand_score, normalized_mutual_info_score)

# Internal metrics (no ground truth)
print("Silhouette:        ", silhouette_score(X, labels))      # higher = better
print("Davies-Bouldin:    ", davies_bouldin_score(X, labels))   # lower = better
print("Calinski-Harabasz: ", calinski_harabasz_score(X, labels)) # higher = better

# External metrics (when you have ground-truth labels)
true_labels = y  # e.g. the actual iris species
print("Adjusted Rand:    ", adjusted_rand_score(true_labels, labels))
print("NMI:              ", normalized_mutual_info_score(true_labels, labels))

# ARI and NMI: 0 = random, 1 = perfect match
# Both are invariant to label permutations (cluster 1 vs cluster 2 doesn't matter)

Dimensionnalité pour le clustering

Le clustering en haute dimension souffre de la malédiction de la dimensionnalité — les distances deviennent insignifiantes. Réduisez d'abord à 5-50 dimensions avec PCA (linéaire, rapide) ou UMAP (non linéaire, préserve la structure locale). t-SNE ne sert qu'à la visualisation (pas de méthode transform pour de nouvelles données, et les distorsions le rendent impropre en entrée de clustering). Visualisez toujours les clusters en 2D avec t-SNE ou UMAP.

machine-learning
from sklearn.decomposition import PCA, UMAP  # umap-learn package
from sklearn.manifold import TSNE
from sklearn.cluster import KMeans

# Reduce dimensions BEFORE clustering high-dim data
# PCA: linear, fast, preserves global structure
pca = PCA(n_components=10, random_state=42).fit(X)
X_pca = pca.transform(X)

# UMAP: non-linear, fast, preserves local+global structure
reducer = UMAP(n_components=5, random_state=42)
X_umap = reducer.fit_transform(X)

# t-SNE: visualization only (no transform on new data)
X_tsne = TSNE(n_components=2, perplexity=30, random_state=42).fit_transform(X)

# Cluster on the embeddings
labels = KMeans(n_clusters=4, n_init=10, random_state=42).fit_predict(X_umap)

# Plot 2D embedding colored by cluster
plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=labels, cmap="tab10", s=10)
plt.show()
09

Réduction de dimensionnalité

PCA (analyse en composantes principales)

PCA trouve des axes orthogonaux (composantes principales) capturant le plus de variance, permettant de compresser les données de haute dimension en préservant l'essentiel de l'information. La mise à l'échelle compte — PCA est sensible aux échelles des caractéristiques. Employez n_components=0.95 pour garder automatiquement 95% de la variance. PCA est linéaire et rapide ; il suppose variance = information, ce qui n'est pas toujours vrai (les caractéristiques à faible variance peuvent être les discriminantes).

machine-learning
from sklearn.decomposition import PCA

# PCA finds orthogonal axes of maximum variance
pca = PCA(n_components=2, random_state=42)
X_pca = pca.fit_transform(X_scaled)   # scaling matters!

# Explained variance: how much info each PC retains
print("Explained variance ratio:", pca.explained_variance_ratio_)
print("Total retained:", pca.explained_variance_ratio_.sum())

# Choose n_components to retain 95% of variance
pca_full = PCA(n_components=0.95, random_state=42).fit(X_scaled)
print("Components for 95%:", pca_full.n_components_)
X_reduced = pca_full.transform(X_scaled)

# Reconstruct (lossy) from compressed representation
X_reconstructed = pca_full.inverse_transform(X_reduced)

t-SNE pour la visualisation

t-SNE excelle à la visualisation 2D/3D des données de haute dimension, préservant les voisinages locaux pour que les clusters apparaissent visuellement. perplexity (typiquement 5-50) contrôle l'équilibre entre structure locale et globale. Distorsions de t-SNE : les tailles des clusters et les distances entre clusters ne sont PAS significatives, seuls les voisinages locaux. Lent sur les grandes données — réduisez d'abord la dimensionnalité avec PCA (ex. à 50) avant t-SNE.

machine-learning
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt

# t-SNE is for 2D/3D visualization, NOT as preprocessing
tsne = TSNE(
    n_components=2,
    perplexity=30,         # try 5-50; ~ sqrt(n_samples) is a heuristic
    learning_rate="auto",
    n_iter=1000,
    init="pca",            # better than random init
    random_state=42,
)
X_tsne = tsne.fit_transform(X_scaled)

plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap="tab10", s=10)
plt.colorbar(); plt.show()

UMAP

UMAP est une alternative moderne à t-SNE : plus rapide, passe mieux à l'échelle, préserve les structures locale et globale, et surtout gère transform sur de nouvelles données, pouvant donc être une étape de pipeline. n_neighbors contrôle le compromis local-global (petit = détail local, grand = structure globale) ; min_dist contrôle le tassement des points. Pour les pipelines ML, employez UMAP pour compresser à 5-50 dimensions, pas 2.

machine-learning
from umap import UMAP  # pip install umap-learn

# UMAP: faster than t-SNE, preserves more global structure,
# and supports transform on new data (good for ML pipelines)
reducer = UMAP(
    n_components=2,
    n_neighbors=15,    # smaller = local, larger = global
    min_dist=0.1,      # how tightly points pack
    metric="euclidean",
    random_state=42,
)
X_umap = reducer.fit_transform(X_scaled)

# Can transform new data (unlike t-SNE)
X_new_umap = reducer.transform(X_new)

# Use in a pipeline as a preprocessor before clustering/classification
from sklearn.pipeline import Pipeline
pipe = Pipeline([
    ("umap", UMAP(n_components=5, random_state=42)),
    ("clf",  RandomForestClassifier(random_state=42)),
])

LDA (analyse discriminante linéaire)

Contrairement à PCA (non supervisé), LDA emploie les étiquettes de classe pour trouver la projection maximisant la variance inter-classes tout en minimisant la variance intra-classe. Le maximum de n_components est n_classes - 1, il ne sert donc qu'aux problèmes à peu de classes. LDA sert aussi de classifieur linéaire (suppose des classes gaussiennes à covariance partagée). Employez LDA quand vous avez des étiquettes et voulez une réduction de dimensionnalité maximisant la séparabilité des classes.

machine-learning
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

# LDA is SUPERVISED dimensionality reduction — uses class labels
# to find axes that best separate classes
lda = LinearDiscriminantAnalysis(n_components=2)
X_lda = lda.fit_transform(X_train, y_train)  # note: y_train passed in

# Also a classifier (Gaussian model per class)
y_pred = lda.predict(X_test)

# Max n_components = n_classes - 1
# For 3 classes, you get at most 2 LDA components

# Compare: PCA ignores class labels (unsupervised);
# LDA uses labels to maximize class separability

SVD tronquée (données creuses)

TruncatedSVD (alias LSA pour le texte) est l'alternative aux données creuses de PCA — il ne centre pas les données et fonctionne donc sur les matrices creuses comme TF-IDF. Combiné à TF-IDF il produit des « topics » — des groupes de mots co-occurrents. Pour un meilleur topic modeling, essayez NMF ou les approches modernes à embeddings. Gardez ~100-300 composantes pour le texte ; le bon nombre dépend de la taille du corpus et de la tâche en aval.

machine-learning
from sklearn.decomposition import TruncatedSVD

# PCA doesn't work on sparse matrices (it needs to center data)
# Use TruncatedSVD instead — works directly on sparse TF-IDF, etc.

from scipy.sparse import csr_matrix
X_sparse = csr_matrix(X_tfidf)  # e.g. from TfidfVectorizer

svd = TruncatedSVD(n_components=100, random_state=42)
X_reduced = svd.fit_transform(X_sparse)

# Often combined with TF-IDF for LSA (Latent Semantic Analysis)
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVD

vectorizer = TfidfVectorizer(max_features=10000)
lsa = Pipeline([
    ("tfidf", vectorizer),
    ("svd",   TruncatedSVD(n_components=100, random_state=42)),
])
X_topics = lsa.fit_transform(documents)
10

Évaluation des modèles

Validation croisée

La validation croisée donne une estimation robuste de la performance en moyennant sur plusieurs découpages train/test. StratifiedKFold préserve l'équilibre des classes en classification (essentiel pour les données déséquilibrées). RepeatedStratifiedKFold exécute la CV plusieurs fois avec des découpages différents — estimations plus stables à un coût de calcul plus élevé. Employez toujours la CV pour la sélection de modèles plutôt qu'un seul découpage train/test.

machine-learning
from sklearn.model_selection import (cross_val_score, cross_validate,
    StratifiedKFold, KFold, RepeatedStratifiedKFold)

# Basic 5-fold CV
scores = cross_val_score(model, X, y, cv=5, scoring="accuracy")
print(f"{scores.mean():.3f} +/- {scores.std():.3f}")

# Stratified (preserves class balance — use for classification)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=cv, scoring="f1_macro")

# Multiple metrics at once
results = cross_validate(model, X, y, cv=cv,
    scoring=["accuracy", "f1_macro", "roc_auc_ovr"],
    return_train_score=True)
print(results["test_f1_macro"].mean())

# Repeated CV for more stable estimates
rcv = RepeatedStratifiedKFold(n_splits=5, n_repeats=3, random_state=42)

Courbes d'apprentissage

Les courbes d'apprentissage tracent la performance d'entraînement et de validation contre la taille du jeu de données — le meilleur diagnostic unique biais vs variance. Un grand écart entre un score d'entraînement haut et une validation basse signifie sur-apprentissage (ajoutez des données, régularisez, simplifiez). Les deux scores bas et proches signifient sous-apprentissage (employez un modèle plus complexe ou ajoutez des caractéristiques). Si les courbes s'améliorent encore au bord droit, plus de données aiderait.

machine-learning
from sklearn.model_selection import learning_curve
import matplotlib.pyplot as plt

train_sizes, train_scores, val_scores = learning_curve(
    model, X, y,
    train_sizes=np.linspace(0.1, 1.0, 10),
    cv=5, scoring="accuracy", n_jobs=-1, random_state=42,
)

train_mean = train_scores.mean(axis=1)
val_mean   = val_scores.mean(axis=1)

plt.plot(train_sizes, train_mean, "o-", label="Train")
plt.plot(train_sizes, val_mean,   "o-", label="Validation")
plt.xlabel("Training samples"); plt.ylabel("Accuracy")
plt.legend(); plt.show()

# Diagnose:
# - High train, low val  -> overfitting (high variance) -> more data or regularize
# - Both low and close   -> underfitting (high bias) -> more complex model/features
# - Gap closing with data -> more data helps

Courbes de validation (hyperparamètre)

Les courbes de validation tracent la performance contre une seule valeur d'hyperparamètre — utiles pour comprendre le comportement d'un modèle et trouver une plage sensée avant la recherche en grille. Le score d'entraînement ne cesse de monter avec la complexité du modèle tandis que le score de validation culmine puis décline. Le pic est le point idéal ; avant il y a sous-apprentissage, après sur-apprentissage.

machine-learning
from sklearn.model_selection import validation_curve
import matplotlib.pyplot as plt

param_range = [1, 2, 4, 8, 16, 32, 64]
train_scores, val_scores = validation_curve(
    RandomForestClassifier(random_state=42),
    X, y,
    param_name="max_depth",
    param_range=param_range,
    cv=5, scoring="accuracy", n_jobs=-1,
)

plt.plot(param_range, train_scores.mean(axis=1), "o-", label="Train")
plt.plot(param_range, val_scores.mean(axis=1),   "o-", label="Validation")
plt.xlabel("max_depth"); plt.ylabel("Accuracy")
plt.legend(); plt.show()

# Sweet spot is where validation peaks before overfitting

Interpréter le rapport de classification

La moyenne macro du classification_report traite toutes les classes à égalité (bien quand les classes rares comptent) ; la moyenne weighted reflète la fréquence des classes (bien quand la performance de la majorité domine). Choisissez votre stratégie de moyenne selon le coût métier de rater chaque classe. Pour un déséquilibre sévère, complétez avec PR-AUC et le rappel par classe — l'exactitude et même le F1 peuvent masquer un modèle qui ne fait que prédire la classe majoritaire.

machine-learning
from sklearn.metrics import classification_report

report = classification_report(y_test, y_pred, output_dict=True)

# Per-class metrics + macro/weighted averages
import pandas as pd
df_report = pd.DataFrame(report).T
print(df_report[["precision", "recall", "f1-score", "support"]])

# 'macro' avg     = unweighted mean across classes (treats all equally)
# 'weighted' avg  = support-weighted mean (reflects class imbalance)
# Focus on:
# - macro F1 if all classes matter equally (e.g. digit recognition)
# - weighted F1 if rare classes matter less
# - recall of the positive class if it's the costly one (fraud, disease)

# For imbalanced classification, also report:
# - Precision-Recall AUC
# - Brier score (probability calibration)

Métriques de régression en profondeur

Choisissez les métriques de régression selon le coût métier. RMSE si les grandes erreurs sont disproportionnellement mauvaises (pénalité au carré) ; MAE si toutes les erreurs de même taille sont aussi mauvaises. R2 est sans unité et comparable entre jeux de données. Max error montre votre pire cas. Des pertes asymétriques personnalisées (ex. pénaliser davantage la sous-prédiction) collent aux coûts réels : le coût de rupture de stock diffère du coût de surstock.

machine-learning
from sklearn.metrics import (mean_squared_error, mean_absolute_error,
    r2_score, explained_variance_score, max_error)

# RMSE — penalizes large errors; same units as y
rmse = mean_squared_error(y_test, y_pred, squared=False)

# MAE — robust to outliers; same units as y
mae = mean_absolute_error(y_test, y_pred)

# R^2 — fraction of variance explained (1.0 = perfect, 0 = predict mean)
r2 = r2_score(y_test, y_pred)

# Explained variance — like R^2 but ignores mean offset
evs = explained_variance_score(y_test, y_pred)

# Max error — single largest absolute error (worst-case)
max_err = max_error(y_test, y_pred)

# Custom asymmetric loss: penalize under-prediction more
def asymmetric_error(y_true, y_pred, under_penalty=2.0):
    error = y_true - y_pred
    return np.where(error > 0, under_penalty * error**2, error**2).mean()
11

Stratégies de validation croisée

Variantes K-Fold

Choisir la bonne stratégie de CV est critique. KFold est le défaut. StratifiedKFold pour la classification (préserve l'équilibre des classes). GroupKFold quand les échantillons sont corrélés (plusieurs lignes par utilisateur/patient — prévient la fuite d'information entre train et val). TimeSeriesSplit pour les données temporelles (toujours entraîner sur le passé, valider sur le futur). La mauvaise stratégie de CV donne des estimations trop optimistes.

machine-learning
from sklearn.model_selection import (KFold, StratifiedKFold,
    GroupKFold, TimeSeriesSplit, RepeatedKFold)

# Standard K-fold (regression or balanced classification)
kf = KFold(n_splits=5, shuffle=True, random_state=42)

# Stratified (classification — preserves class proportions)
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# Group K-fold (when samples are not independent — e.g. multiple rows per patient)
gkf = GroupKFold(n_splits=5)  # pass groups=patient_ids to CV

# Time series split (no shuffle — preserves temporal order)
tscv = TimeSeriesSplit(n_splits=5)

# Use with cross_val_score:
scores = cross_val_score(model, X, y, cv=gkf, groups=groups, scoring="f1")

Validation croisée des séries temporelles

TimeSeriesSplit respecte l'ordre temporel : chaque fold entraîne sur le passé et valide sur le futur, jamais l'inverse. Cela colle à la prévision réelle et prévient les fuites. Employez le paramètre gap quand les échantillons voisins sont autocorrélés (ex. le prix de demain est corrélé à celui d'aujourd'hui). Un KFold mélangé standard sur des données temporelles donne des estimations sauvagement optimistes — erreur fréquente des débutants.

machine-learning
from sklearn.model_selection import TimeSeriesSplit
import matplotlib.pyplot as plt
import numpy as np

tscv = TimeSeriesSplit(n_splits=5, test_size=100)
# gap parameter (sklearn 1.0+): prevent leakage from train to test
tscv = TimeSeriesSplit(n_splits=5, test_size=100, gap=10)

for fold, (train_idx, test_idx) in enumerate(tscv.split(X)):
    X_tr, X_te = X[train_idx], X[test_idx]
    y_tr, y_te = y[train_idx], y[test_idx]
    model.fit(X_tr, y_tr)
    score = model.score(X_te, y_te)
    print(f"Fold {fold}: train={len(train_idx)}, test={len(test_idx)}, score={score:.3f}")

# NEVER shuffle time-series data for CV — that leaks future into past
# Use gap to avoid leakage from autocorrelated near-future points

CV consciente des groupes

Quand vos données ont des groupes (plusieurs échantillons par patient, utilisateur ou session), les découpages aléatoires standard fuient l'information — le modèle voit la même entité dans train et test, gonflant les scores. GroupKFold garde chaque groupe entièrement dans un fold. Scénarios typiques : données médicales (plusieurs examens par patient), systèmes de recommandation (plusieurs notes par utilisateur), données d'images (plusieurs frames par scène). Ne pas employer de CV consciente des groupes est l'un des bugs silencieux les plus courants du ML.

machine-learning
from sklearn.model_selection import GroupKFold, GroupShuffleSplit

# When the same entity appears in multiple rows (e.g. multiple X-rays per patient),
# random splits leak: the model memorizes patient-specific features
# instead of learning generalizable patterns.

# Solution: keep all rows of a group in the same split
gkf = GroupKFold(n_splits=5)
scores = cross_val_score(model, X, y, cv=gkf, groups=df["patient_id"])

# GroupShuffleSplit: random train/test split respecting groups
gss = GroupShuffleSplit(n_splits=5, test_size=0.2, random_state=42)
for train_idx, test_idx in gss.split(X, groups=df["patient_id"]):
    ...

# Always pass the groups argument to CV functions
# Common scenarios: patients, users, sessions, image batches

CV imbriquée (réglage d'hyperparamètres sans biais)

Le score de CV rapporté par un GridSearchCV standard est optimiste — il a choisi les meilleurs hyperparamètres avec les mêmes folds employés pour scorer. La CV imbriquée corrige cela : une boucle de CV externe évalue toute la procédure de réglage sur des folds vraiment retenus. Le résultat est une estimation sans biais de la performance de votre pipeline complet de modélisation (réglage compris) sur de nouvelles données. Employez-la pour un référencement honnête, surtout en comparant des modèles.

machine-learning
from sklearn.model_selection import (GridSearchCV, cross_val_score,
    StratifiedKFold)

# Outer loop: estimate generalization performance
# Inner loop: tune hyperparameters
# Without nesting, GridSearchCV's CV score is optimistic (it selected the best
# hyperparameters using the same data)

inner_cv = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)
outer_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

grid = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid={"max_depth": [3, 5, 10], "n_estimators": [50, 100]},
    cv=inner_cv, scoring="f1", n_jobs=-1,
)

nested_scores = cross_val_score(grid, X, y, cv=outer_cv, scoring="f1")
print(f"Nested CV F1: {nested_scores.mean():.3f} +/- {nested_scores.std():.3f}")

# Fit the final model on all data
grid.fit(X, y)
best_model = grid.best_estimator_

CV avec prétraitement (Pipelines)

Le prétraitement doit être ajusté sur le fold d'entraînement seulement — sinon vous fuyez les statistiques du fold de test (moyennes, médianes, facteurs d'échelle) vers l'entraînement, donnant des scores de CV optimistes. La solution est de tout envelopper dans un Pipeline : scikit-learn garantit que chaque fold de CV ajuste son propre prétraitement sur la partie entraînement. C'est la meilleure pratique la plus importante pour une évaluation ML honnête. N'ajustez jamais le prétraitement sur tout le jeu de données avant la CV.

machine-learning
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score
from sklearn.impute import SimpleImputer

# RIGHT: wrap preprocessing in a Pipeline so each fold fits
# its own scaler/imputer on the training portion only
pipe = Pipeline([
    ("impute",  SimpleImputer(strategy="median")),
    ("scale",   StandardScaler()),
    ("model",   RandomForestClassifier(random_state=42)),
])

scores = cross_val_score(pipe, X, y, cv=5, scoring="f1")

# WRONG: fit scaler on the whole dataset, then CV
# (leaks test-fold statistics into training)
# scaler.fit(X)              # NO - includes future test folds
# X_scaled = scaler.transform(X)
# cross_val_score(model, X_scaled, y, cv=5)  # optimistic scores

# Pipelines also make deployment easier (one object, no leakage)
12

Réglage des hyperparamètres

Recherche en grille

GridSearchCV évalue exhaustivement chaque combinaison — minutieux mais coûteux (explosion combinatoire). Employez-le avec une petite grille de paramètres bien choisie. Passez toujours une métrique de scoring appropriée (le défaut est l'exactitude, fausse pour la classification déséquilibrée). refit=True ré-entraîne le meilleur modèle sur toutes les données d'entraînement pour que l'estimateur renvoyé soit prêt à l'emploi.

machine-learning
from sklearn.model_selection import GridSearchCV

# Exhaustive search over all combinations
param_grid = {
    "n_estimators": [50, 100, 200],
    "max_depth":    [3, 5, 10, None],
    "min_samples_leaf": [1, 5, 10],
}
# 3 * 4 * 3 = 36 combinations, * 5 folds = 180 fits

grid = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid=param_grid,
    cv=5,
    scoring="f1",
    n_jobs=-1,
    refit=True,         # refit best model on full data
    return_train_score=True,
)
grid.fit(X_train, y_train)

print("Best params: ", grid.best_params_)
print("Best CV F1:  ", grid.best_score_)
best_model = grid.best_estimator_

Recherche aléatoire

RandomizedSearchCV échantillonne n_iter combinaisons depuis des distributions — bien plus efficace que la recherche en grille quand beaucoup de paramètres comptent. Employez loguniform pour les taux d'apprentissage et forces de régularisation (ils s'étendent sur des ordres de grandeur). 50-100 itérations trouvent habituellement une configuration quasi optimale. L'aléatoire aide aussi à échapper aux optima locaux que la grille pourrait rater.

machine-learning
from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, loguniform

# Sample from distributions instead of enumerating all combos
# Much more efficient when the grid is large
param_dist = {
    "n_estimators":     randint(50, 500),     # discrete uniform
    "max_depth":        [3, 5, 10, None],
    "min_samples_leaf": randint(1, 20),
    "learning_rate":    loguniform(1e-3, 1e0),  # log-uniform
}

rand_search = RandomizedSearchCV(
    GradientBoostingClassifier(random_state=42),
    param_distributions=param_dist,
    n_iter=50,           # number of parameter settings sampled
    cv=5,
    scoring="f1",
    n_jobs=-1,
    random_state=42,
)
rand_search.fit(X_train, y_train)
print("Best params:", rand_search.best_params_)

Optimisation bayésienne (Optuna)

Optuna emploie l'optimisation bayésienne pour échantillonner intelligemment les prochains hyperparamètres selon les résultats des essais précédents — bien plus économe en échantillons que la recherche grille/aléatoire. Elle gère aussi l'élagage (arrêt précoce des mauvais essais), les espaces de paramètres conditionnels et l'optimisation multi-objectifs. L'objet study stocke tous les essais pour visualiser l'importance des paramètres et l'historique d'optimisation. Idéal pour les modèles coûteux à beaucoup d'hyperparamètres.

machine-learning
import optuna

def objective(trial):
    # Suggest hyperparameters
    n_estimators = trial.suggest_int("n_estimators", 50, 500)
    max_depth    = trial.suggest_int("max_depth", 3, 20)
    lr           = trial.suggest_float("learning_rate", 1e-3, 1e0, log=True)
    min_samples  = trial.suggest_int("min_samples_leaf", 1, 20)

    model = GradientBoostingClassifier(
        n_estimators=n_estimators, max_depth=max_depth,
        learning_rate=lr, min_samples_leaf=min_samples,
        random_state=42,
    )
    # 5-fold CV F1
    score = cross_val_score(model, X_train, y_train, cv=5,
                            scoring="f1", n_jobs=-1).mean()
    return score  # Optuna maximizes by default

study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=100, timeout=600)

print("Best trial:", study.best_trial.params)
print("Best F1:    ", study.best_trial.value)

Recherche par halving (halving successif)

La recherche par halving est une stratégie d'allocation de ressources itérative : elle évalue beaucoup de candidats avec peu de données, puis élimine les pires et ré-évalue les survivants avec plus de données (ou d'estimateurs). Bien plus rapide qu'une grille complète et trouve souvent des solutions semblables. Employez HalvingRandomSearchCV pour des espaces encore plus grands. Le « factor » contrôle l'agressivité de l'élimination des candidats. Excellent défaut quand on a beaucoup d'hyperparamètres et peu de temps.

machine-learning
from sklearn.experimental import enable_halving_search_cv  # noqa
from sklearn.model_selection import HalvingGridSearchCV, HalvingRandomSearchCV

# Allocate more resources to promising candidates iteratively
halving = HalvingGridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid={"max_depth": [3, 5, 10, None],
                "n_estimators": [50, 100, 200]},
    cv=5,
    scoring="f1",
    factor=3,           # eliminate bottom 2/3 each round
    aggressive_elimination=False,
    n_jobs=-1,
)
halving.fit(X_train, y_train)
print("Best params:", halving.best_params_)
print("Best score: ", halving.best_score_)

# Much faster than full GridSearchCV — evaluates many candidates
# cheaply first, then invests more resources in the promising ones.

Bonnes pratiques de réglage

Les plus grands péchés de réglage : optimiser sur le jeu de test, régler jusqu'à sur-apprendre le jeu de validation, et rapporter des scores de CV comme performance finale. Réglez via la CV sur les données d'entraînement, puis évaluez le modèle final une seule fois sur un jeu de test propre retenu. Inspectez le cv_results_ complet pour vérifier que les hyperparamètres choisis sont robustes (petit écart-type entre folds) et pas juste une graine aléatoire chanceuse. Commencez grossier et affinez — la plupart des gains viennent de quelques paramètres clés.

machine-learning
# 1. Tune on a VALIDATION set or via CV — never on the test set
# 2. Use the metric you actually care about (scoring=...)
# 3. Set random_state for reproducibility
# 4. Start coarse (randomized, few iterations), then refine around the best
# 5. Don't over-tune — small improvements may be noise

# Inspect full results to understand hyperparameter sensitivity
import pandas as pd
results = pd.DataFrame(grid.cv_results_)
cols = ["param_max_depth", "param_n_estimators",
        "mean_test_score", "std_test_score", "rank_test_score"]
print(results[cols].sort_values("rank_test_score").head(10))

# Refit the best model on the FULL training set (automatic with refit=True)
# Then evaluate ONCE on the held-out test set
test_score = grid.best_estimator_.score(X_test, y_test)
print(f"Test score: {test_score:.3f}")
13

Apprentissage en ensemble

Bagging (bootstrap aggregating)

Le bagging entraîne beaucoup de modèles sur des échantillons bootstrap (tirage avec remise) et moyenne les prédictions — réduit la variance sans augmenter le biais. Random Forest ajoute de l'aléatoire sur les caractéristiques à chaque scission pour des arbres plus divers. Le score Out-of-Bag (OOB) évalue chaque arbre sur les ~37% d'échantillons qu'il n'a pas entraînés — une estimation de validation gratuite sans jeu séparé. OOB est parfait pour les petits jeux de données où l'on ne peut sacrifier un jeu de validation.

machine-learning
from sklearn.ensemble import BaggingClassifier, RandomForestClassifier

# Bagging: train multiple models on bootstrap samples (with replacement)
bag = BaggingClassifier(
    estimator=DecisionTreeClassifier(),  # any base estimator
    n_estimators=100,
    max_samples=1.0,         # fraction of samples per bootstrap
    max_features=1.0,        # fraction of features per estimator
    bootstrap=True,
    n_jobs=-1,
    random_state=42,
)
bag.fit(X_train, y_train)

# Random Forest is bagging + random feature subsets at each split
# Out-of-bag (OOB) score: evaluate each tree on samples it didn't see
rf = RandomForestClassifier(n_estimators=200, oob_score=True,
                             random_state=42)
rf.fit(X_train, y_train)
print("OOB score:", rf.oob_score_)  # ~ validation accuracy for free

Boosting

Le boosting entraîne les modèles séquentiellement, chacun corrigeant les erreurs du précédent — réduit le biais (et une partie de la variance). AdaBoost repondère les échantillons ; le gradient boosting ajuste directement les résidus. learning_rate et n_estimators se compromettent : un learning_rate plus bas exige plus d'estimateurs mais généralise souvent mieux — employez toujours l'arrêt précoce. HistGradientBoosting est l'implémentation rapide à histogrammes de sklearn, comparable à LightGBM.

machine-learning
from sklearn.ensemble import (AdaBoostClassifier,
    GradientBoostingClassifier, HistGradientBoostingClassifier)

# AdaBoost: weight misclassified samples higher each round
ada = AdaBoostClassifier(
    estimator=DecisionTreeClassifier(max_depth=1),
    n_estimators=200, learning_rate=0.5, random_state=42,
)
ada.fit(X_train, y_train)

# Gradient Boosting: fit each new tree to the residuals of the previous
gb = GradientBoostingClassifier(
    n_estimators=200, learning_rate=0.1, max_depth=3,
    subsample=0.8,        # stochastic GB — adds randomness
    random_state=42,
)
gb.fit(X_train, y_train)

# HistGradientBoosting: faster, native NaN handling, large-data friendly
hgb = HistGradientBoostingClassifier(
    max_iter=200, learning_rate=0.1, max_leaf_nodes=31,
    l2_regularization=0.0, early_stopping=True,
    random_state=42,
)
hgb.fit(X_train, y_train)

Stacking (méta-apprentissage)

Les ensembles par vote moyennent les prédictions de modèles divers — le vote doux (probabilités) bat généralement le vote dur (majorité). Le stacking va plus loin : un méta-modèle apprend à mieux combiner les prédictions des modèles de base, en extirpant souvent de la performance supplémentaire. Le méta-modèle s'entraîne sur les prédictions hors-fold des modèles de base pour éviter les fuites (réglé via cv). Employez des modèles de base divers (algorithmes différents) pour les plus grands gains — combiner trois forêts aléatoires est inutile.

machine-learning
from sklearn.ensemble import StackingClassifier, VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC

# Voting: simple average of predictions (hard=majority, soft=probabilities)
voting = VotingClassifier(
    estimators=[
        ("rf",  RandomForestClassifier(n_estimators=100, random_state=42)),
        ("svc", SVC(probability=True, random_state=42)),
        ("lr",  LogisticRegression(max_iter=1000)),
    ],
    voting="soft",     # use predict_proba
    weights=[2, 1, 1], # weight each model
)

# Stacking: train a meta-model on base model predictions
stacking = StackingClassifier(
    estimators=[
        ("rf",  RandomForestClassifier(n_estimators=100, random_state=42)),
        ("svc", SVC(probability=True, random_state=42)),
        ("lr",  LogisticRegression(max_iter=1000)),
    ],
    final_estimator=LogisticRegression(),  # meta-model
    cv=5,            # use CV predictions to train meta-model (avoids leakage)
    n_jobs=-1,
)
stacking.fit(X_train, y_train)

Voting vs stacking vs blending

Les trois stratégies d'ensemble combinent des modèles divers, avec une sophistication croissante : voting (le plus simple, moyenne), blending (méta-modèle sur un jeu retenu), stacking (méta-modèle sur les prédictions de CV, plus robuste). Le stacking est préféré en pratique — les méta-caractéristiques basées CV emploient toutes les données d'entraînement et réduisent la variance. Le blending est plus simple et plus rapide mais emploie moins de données pour le méta-modèle. Tous exigent des modèles de base divers pour ajouter de la valeur.

machine-learning
# Voting:  simple average of predictions
# Stacking: meta-model trained on CV predictions of base models
# Blending: like stacking but meta-model trained on a single holdout set

# Blending (manual implementation):
# 1. Split train into train' and holdout
# 2. Train base models on train'
# 3. Get predictions on holdout
# 4. Train meta-model on (holdout_predictions, holdout_y)
# 5. Retrain base models on full train for final ensemble

from sklearn.model_selection import train_test_split
X_tr, X_hold, y_tr, y_hold = train_test_split(X_train, y_train, test_size=0.3,
                                               random_state=42)

# Train base models on X_tr
rf.fit(X_tr, y_tr); svc.fit(X_tr, y_tr); lr.fit(X_tr, y_tr)

# Get holdout predictions as new features
import numpy as np
holdout_preds = np.column_stack([
    rf.predict_proba(X_hold)[:, 1],
    svc.predict_proba(X_hold)[:, 1],
    lr.predict_proba(X_hold)[:, 1],
])
meta_model = LogisticRegression().fit(holdout_preds, y_hold)

Diversité et corrélation

Un ensemble ne bat ses membres que quand les modèles font des erreurs non corrélées. Si trois modèles font la même erreur, l'ensemble la fait aussi. Mesurez la corrélation des prédictions — plus basse est mieux. Boostez la diversité en mélangeant les familles d'algorithmes (arbres, linéaire, distance), en entraînant sur des sous-ensembles de caractéristiques différents, ou en employant des régimes d'hyperparamètres différents. La diversité même algorithme-graines différentes est faible ; la diversité algorithmique est forte.

machine-learning
import numpy as np
from scipy.stats import spearmanr

# An ensemble only helps if models make DIFFERENT errors
# Measure prediction correlation between base models
preds = np.column_stack([rf.predict_proba(X_test)[:, 1],
                          svc.predict_proba(X_test)[:, 1],
                          lr.predict_proba(X_test)[:, 1]])
corr = spearmanr(preds).correlation
print("Prediction correlation matrix:")
print(corr)

# Low correlation = diverse models = better ensemble
# High correlation = redundant models = no benefit

# Ways to encourage diversity:
# 1. Different algorithms (tree + linear + nearest-neighbor)
# 2. Different feature subsets
# 3. Different hyperparameters
# 4. Different training samples (bagging)
# 5. Different random seeds (weakest form of diversity)
14

Bases du deep learning

Tenseurs PyTorch et autograd

Les tenseurs PyTorch sont des tableaux façon numpy qui suivent les gradients pour la différentiation automatique. requires_grad=True active l'autograd sur un tenseur ; appeler .backward() sur un scalaire calcule les gradients de tous les tenseurs en amont. Déplacez les tenseurs vers le GPU avec .to(device) pour l'accélération. .detach() retire un tenseur du graphe de gradients (pour logger ou convertir en numpy).

machine-learning
import torch

# Tensors: like numpy arrays but on GPU and with autograd
x = torch.randn(3, 4, requires_grad=True)
y = torch.randn(4, 2, requires_grad=True)
z = x @ y               # matrix multiply
loss = z.sum()

# Automatic differentiation
loss.backward()         # populate .grad
print(x.grad.shape)     # torch.Size([3, 4])
print(y.grad.shape)     # torch.Size([4, 2])

# Move to GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = x.to(device)

# Detach from graph (e.g. for logging)
numpy_array = z.detach().cpu().numpy()

Anatomie de la boucle d'entraînement

Toute boucle d'entraînement PyTorch a la même structure : zero_grad, forward, loss, backward, step. model.train() / model.eval() basculent le comportement de dropout et batchnorm — oublier de basculer est un bug silencieux. torch.no_grad() désactive le suivi des gradients pour l'inférence (économise mémoire et calcul). Déplacez toujours les batchs sur le même appareil que le modèle. Un dataloader gère le batching et le mélange ; la boucle ne fait qu'itérer.

machine-learning
import torch
import torch.nn as nn
import torch.optim as optim

model = nn.Sequential(
    nn.Linear(784, 128), nn.ReLU(),
    nn.Linear(128, 64),  nn.ReLU(),
    nn.Linear(64, 10),
).to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(epochs):
    model.train()                            # enable dropout/batchnorm
    for X_batch, y_batch in train_loader:
        X_batch, y_batch = X_batch.to(device), y_batch.to(device)

        optimizer.zero_grad()                # clear old gradients
        logits = model(X_batch)              # forward
        loss = criterion(logits, y_batch)    # compute loss
        loss.backward()                      # backprop
        optimizer.step()                     # update weights

    # Validation
    model.eval()                             # disable dropout/batchnorm
    with torch.no_grad():                    # no gradient tracking
        val_loss, correct = 0, 0
        for X_batch, y_batch in val_loader:
            logits = model(X_batch.to(device))
            val_loss += criterion(logits, y_batch.to(device))
            correct += (logits.argmax(1).cpu() == y_batch).sum().item()
    print(f"Epoch {epoch}: val_loss={val_loss/len(val_loader):.4f}, "
          f"val_acc={correct/len(val_loader.dataset):.4f}")

Couches courantes

Linear + ReLU est la couche cachée de base. Conv2d + MaxPool pour les images ; LSTM/GRU pour les courtes séquences ; Transformer pour les longues séquences ou le texte. BatchNorm stabilise l'entraînement ; Dropout régularise. Note : CrossEntropyLoss dans PyTorch applique déjà le log-softmax, n'ajoutez donc pas de couche Softmax à la fin d'un modèle de classification — sortez les logits bruts.

machine-learning
import torch.nn as nn

# Linear (fully connected)
nn.Linear(in_features=128, out_features=64)

# Activations
nn.ReLU()        # default for hidden layers
nn.GELU()        # smoother, used in transformers
nn.Sigmoid()     # outputs in (0, 1)
nn.Softmax(dim=1)# multi-class probabilities (built into CrossEntropyLoss)

# Convolution (images)
nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, padding=1)
nn.MaxPool2d(kernel_size=2)   # downsample by 2
nn.BatchNorm2d(32)            # stabilize training
nn.Dropout(p=0.5)             # regularization

# Recurrent (sequences)
nn.LSTM(input_size=64, hidden_size=128, num_layers=2, batch_first=True)

# Transformer (attention)
nn.TransformerEncoderLayer(d_model=512, nhead=8, batch_first=True)

Optimiseurs

Adam est l'optimiseur le plus populaire — taux d'apprentissage adaptatifs par paramètre, convergence rapide, réglage minimal. AdamW corrige le bug de weight-decay d'Adam et est préféré pour les transformers. SGD avec momentum peut mieux généraliser sur les CNN mais exige plus de réglage. Les schedulers de taux d'apprentissage (recuit cosinus, one-cycle) ajoutent souvent gratuitement 1-2% d'exactitude. Le taux d'apprentissage est l'hyperparamètre le plus important — ajustez-le toujours en premier.

machine-learning
import torch.optim as optim

# SGD with momentum — robust default
optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=1e-4)

# Adam — adaptive, often faster convergence
optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-4)

# AdamW — proper weight decay (preferred over Adam for transformers)
optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.01)

# Learning rate scheduler — reduce LR over training
from torch.optim.lr_scheduler import CosineAnnealingLR, OneCycleLR
scheduler = CosineAnnealingLR(optimizer, T_max=epochs)
# or OneCycleLR for super-convergence (needs careful setup)

# In training loop:
optimizer.step()
scheduler.step()  # update LR each epoch (or batch for OneCycleLR)

Sur-apprentissage et régularisation

Sur-apprentissage : la perte d'entraînement continue de chuter pendant que la perte de validation monte. Le Dropout désactive aléatoirement des unités pendant l'entraînement, forçant la redondance. Le weight decay (L2) rétrécit les poids vers zéro. L'arrêt précoce surveille la perte de validation et s'arrête quand elle plafonne — sauvegardez toujours le meilleur checkpoint. L'augmentation de données est le régulariseur le plus fort pour les images/textes. Réduire la capacité du modèle est le correctif le plus simple quand les autres méthodes échouent.

machine-learning
# 1. Dropout — randomly zero out units during training
nn.Dropout(p=0.5)

# 2. Weight decay (L2 regularization) via optimizer
optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.01)

# 3. Early stopping — stop when validation loss stops improving
best_val, patience, counter = float("inf"), 5, 0
for epoch in range(epochs):
    val_loss = validate(model, val_loader)
    if val_loss < best_val:
        best_val, counter = val_loss, 0
        torch.save(model.state_dict(), "best.pt")  # save best
    else:
        counter += 1
        if counter >= patience:
            print("Early stopping at epoch", epoch)
            break

# 4. Data augmentation (especially for images/text)
# 5. Batch normalization (mild regularizing effect)
# 6. Reduce model capacity (fewer layers/units)
15

Métriques d'évaluation en profondeur

Précision, rappel et F1

La précision et le rappel capturent le compromis entre faux positifs et faux négatifs. Choisissez selon le coût métier : précision pour le spam (un faux positif = un email important perdu), rappel pour le dépistage du cancer (un faux négatif = un diagnostic manqué). F1 équilibre les deux également ; F-beta permet d'incliner — F2 pèse le rappel double, F0.5 la précision double. Rapportez toujours précision et rappel, pas seulement le F1.

machine-learning
from sklearn.metrics import (precision_score, recall_score,
    f1_score, fbeta_score)

# Precision: TP / (TP + FP) — of predicted positives, how many are real
# Recall:    TP / (TP + FN) — of actual positives, how many we caught
# F1:        harmonic mean of precision and recall
# F-beta:    weighted (beta > 1 favors recall, < 1 favors precision)

precision = precision_score(y_test, y_pred)
recall    = recall_score(y_test, y_pred)
f1        = f1_score(y_test, y_pred)
f2        = fbeta_score(y_test, y_pred, beta=2.0)   # recall-weighted
f05       = fbeta_score(y_test, y_pred, beta=0.5)   # precision-weighted

# When to use which:
# - Precision matters when false positives are costly (spam filter)
# - Recall matters when false negatives are costly (cancer screening)
# - F2 when recall is more important; F0.5 when precision is more important

ROC-AUC et PR-AUC

ROC-AUC mesure la qualité du classement des positifs au-dessus des négatifs — utile car indépendant du seuil. PR-AUC (average_precision_score) est l'aire sous la courbe précision-rappel et est plus informatif sur les données déséquilibrées (ROC-AUC peut paraître superbe alors que PR-AUC est affreux). En multiclasse, 'ovr' (un contre tous) et 'ovo' (un contre un) calculent l'AUC différemment ; rapportez les deux en cas de doute. Employez le J de Youden pour choisir un seuil de fonctionnement.

machine-learning
from sklearn.metrics import (roc_auc_score, average_precision_score,
    roc_curve, precision_recall_curve)

# ROC-AUC: probability that model ranks a random positive
#          above a random negative. Threshold-independent.
roc_auc = roc_auc_score(y_test, y_proba)

# PR-AUC (average precision): area under precision-recall curve.
# More informative than ROC-AUC on imbalanced data.
pr_auc = average_precision_score(y_test, y_proba)

# Multiclass ROC-AUC
roc_auc_ovr = roc_auc_score(y_test, y_proba_multi,
                            multi_class="ovr", average="macro")
roc_auc_ovo = roc_auc_score(y_test, y_proba_multi,
                            multi_class="ovo", average="macro")

# Find the optimal threshold (Youden's J = TPR - FPR)
fpr, tpr, thresholds = roc_curve(y_test, y_proba)
j_scores = tpr - fpr
best_threshold = thresholds[j_scores.argmax()]

Visualisation de la matrice de confusion

Visualisez toujours la matrice de confusion, pas seulement les métriques agrégées — elle montre quelles classes se confondent, révélant les faiblesses du modèle (ex. un classifieur de chiffres confondant 4 et 9). Normalisez par ligne (classe réelle) pour voir le rappel par classe — important quand les classes sont déséquilibrées. ConfusionMatrixDisplay le fait en une ligne. Les cellules hors diagonale sont là où se concentrent les erreurs.

machine-learning
from sklearn.metrics import (confusion_matrix,
    ConfusionMatrixDisplay)
import matplotlib.pyplot as plt

cm = confusion_matrix(y_test, y_pred)

# Display with sklearn
disp = ConfusionMatrixDisplay(confusion_matrix=cm,
                              display_labels=class_names)
fig, ax = plt.subplots(figsize=(8, 6))
disp.plot(cmap="Blues", ax=ax, values_format="d")  # or ".2%" for normalized
plt.title("Confusion matrix")
plt.show()

# Normalized per row (true class) — see per-class recall
cm_norm = cm.astype(float) / cm.sum(axis=1, keepdims=True)
disp = ConfusionMatrixDisplay(confusion_matrix=cm_norm,
                              display_labels=class_names)
disp.plot(cmap="Blues", values_format=".2%")

Récapitulatif des métriques de régression

Rapportez plusieurs métriques : RMSE pour la sensibilité aux grandes erreurs, MAE pour l'erreur typique, median AE pour la robustesse aux valeurs aberrantes, max error pour les pires cas de SLA, et R2 pour l'interprétabilité sans unité. Sur des cibles asymétriques (revenus, prix), essayez de transformer y en log et de rapporter les métriques en espace log — cela colle aux erreurs multiplicatives et stabilise la variance. Vérifiez toujours les prédictions contre les réels avec un nuage de points.

machine-learning
from sklearn.metrics import (mean_squared_error, mean_absolute_error,
    r2_score, median_absolute_error, max_error,
    explained_variance_score, d2_tweedie_score)

# RMSE (penalizes large errors, same units as y)
rmse = mean_squared_error(y_test, y_pred, squared=False)

# MAE (robust to outliers, same units as y)
mae = mean_absolute_error(y_test, y_pred)

# Median AE (extremely robust to outliers)
med_ae = median_absolute_error(y_test, y_pred)

# Max error (worst single prediction — useful for SLAs)
max_err = max_error(y_test, y_pred)

# R^2 (1=perfect, 0=mean prediction, <0=worse than mean)
r2 = r2_score(y_test, y_pred)

# Explained variance (like R^2 but ignores bias)
evs = explained_variance_score(y_test, y_pred)

Métriques alignées sur le métier

Les métriques ML (exactitude, F1, AUC) sont des proxis de ce qui vous importe réellement — les résultats métier. Traduisez les coûts métier en métriques personnalisées : un faux négatif de fraude coûte $X, un faux positif $Y, un clic publicitaire au rang k rapporte $Z. Optimisez pour l'objectif réel (profit, vies sauvées, désabonnements évités) plutôt que pour le proxi. L'optimisation personnalisée du seuil rapporte souvent plus que de grignoter 0,01 d'AUC.

machine-learning
# Sometimes the right metric isn't in sklearn — define your own.

# Example 1: Cost matrix (asymmetric costs)
def cost_weighted_error(y_true, y_pred, cost_fp=1, cost_fn=10):
    cm = confusion_matrix(y_true, y_pred)
    tn, fp, fn, tp = cm.ravel()
    return (cost_fp * fp + cost_fn * fn) / len(y_true)

# Example 2: Profit at K (top-K precision weighted by revenue)
def profit_at_k(y_true, y_proba, revenue_per_hit, k=100):
    top_k_idx = np.argsort(y_proba)[::-1][:k]
    hits = y_true[top_k_idx].sum()
    return hits * revenue_per_hit - k * cost_per_contact

# Example 3: Custom threshold optimization
def optimize_threshold_for_profit(y_true, y_proba, profit_matrix):
    best_t, best_profit = 0.5, -float("inf")
    for t in np.linspace(0.01, 0.99, 99):
        y_pred = (y_proba >= t).astype(int)
        profit = profit_matrix(y_true, y_pred)
        if profit > best_profit:
            best_t, best_profit = t, profit
    return best_t, best_profit
16

Pipelines

Pipeline de base

Un Pipeline enchaîne prétraitement et modélisation en un seul estimateur, garantissant que le prétraitement est ajusté sur le fold d'entraînement seulement pendant la CV (prévenant les fuites). Il simplifie aussi le déploiement — un objet au lieu d'un scaler, imputer et modèle séparés. Employez des étapes nommées pour la clarté. Les pipelines sont la façon la plus propre de faire du ML honnête et reproductible — faites-en votre défaut, pas une optimisation.

machine-learning
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier

pipe = Pipeline([
    ("impute", SimpleImputer(strategy="median")),
    ("scale",  StandardScaler()),
    ("clf",    RandomForestClassifier(random_state=42)),
])

# Use like any estimator
pipe.fit(X_train, y_train)
y_pred = pipe.predict(X_test)
score = pipe.score(X_test, y_test)

# Access steps
pipe.named_steps["clf"]
pipe[:-1].get_feature_names_out()  # see transformed feature names

# Pipelines prevent leakage: each CV fold fits its own preprocessing

ColumnTransformer (données hétérogènes)

ColumnTransformer applique un prétraitement différent aux colonnes numériques et catégorielles — essentiel pour les données tabulaires réelles. Chaque sous-pipeline gère sa propre imputation et son encodage. remainder='drop' jette les colonnes non listées ; 'passthrough' les garde telles quelles. Enveloppez le ColumnTransformer dans un Pipeline avec votre modèle pour obtenir une CV sans fuite avec un prétraitement hétérogène. C'est le pattern prêt pour la production du ML tabulaire.

machine-learning
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import (StandardScaler, OneHotEncoder)
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer

numeric_features     = ["age", "income", "score"]
categorical_features = ["city", "occupation"]

# Different preprocessing for different column types
preprocessor = ColumnTransformer(
    transformers=[
        ("num", Pipeline([
            ("impute", SimpleImputer(strategy="median")),
            ("scale",  StandardScaler()),
        ]), numeric_features),
        ("cat", Pipeline([
            ("impute", SimpleImputer(strategy="most_frequent")),
            ("onehot", OneHotEncoder(handle_unknown="ignore")),
        ]), categorical_features),
    ],
    remainder="drop",  # or 'passthrough' to keep other columns
)

full_pipe = Pipeline([
    ("preprocess", preprocessor),
    ("clf", RandomForestClassifier(random_state=42)),
])
full_pipe.fit(X_train, y_train)

Pipeline avec réglage

Les pipelines se composent admirablement avec GridSearchCV — on peut régler conjointement prétraitement et hyperparamètres du modèle avec la syntaxe 'etape__param'. Cela trouve la meilleure combinaison prétraitement-pour-ce-modèle, qui diffère souvent du meilleur prétraitement isolé. Réglez toujours le pipeline complet, pas seulement le modèle. Le réglage conjoint est plus honnête (pas de coup d'œil aux données de test pour choisir le prétraitement) et trouve souvent de meilleures configurations.

machine-learning
from sklearn.model_selection import GridSearchCV

# Reference nested parameters with 'step__param' syntax
param_grid = {
    "preprocess__num__impute__strategy": ["mean", "median"],
    "clf__n_estimators": [50, 100, 200],
    "clf__max_depth":    [3, 5, 10, None],
}

grid = GridSearchCV(full_pipe, param_grid, cv=5, scoring="f1", n_jobs=-1)
grid.fit(X_train, y_train)
print("Best params:", grid.best_params_)

# Tune preprocessing AND model together — finds the best combo
# e.g. median imputation + 100 trees + max_depth=10

Transformers personnalisés

Les transformers personnalisés permettent d'encapsuler le prétraitement propre au domaine (transformations log, extraction de caractéristiques de dates, nettoyage de texte) en composants réutilisables et compatibles pipeline. Héritez de BaseEstimator et TransformerMixin, implémentez fit (souvent juste renvoie self) et transform. Cela garde votre ingénierie de caractéristiques versionnée, testable et sans fuite — bien mieux que de semer la logique dans les notebooks. Pour des fonctions ponctuelles, employez FunctionTransformer.

machine-learning
from sklearn.base import BaseEstimator, TransformerMixin
import numpy as np

class LogTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, columns=None):
        self.columns = columns

    def fit(self, X, y=None):
        return self  # nothing to fit

    def transform(self, X):
        X = X.copy()
        if self.columns is None:
            return np.log1p(X)
        X[self.columns] = np.log1p(X[self.columns])
        return X

# Use in a pipeline
pipe = Pipeline([
    ("log",  LogTransformer(columns=["income", "price"])),
    ("scale", StandardScaler()),
    ("clf",   LogisticRegression()),
])

# For more complex logic, use FunctionTransformer or write a full class

Sauvegarder et charger les pipelines

joblib (pas pickle) est le standard pour sérialiser les pipelines sklearn — il traite les tableaux numpy efficacement. Épinglez votre version de sklearn en production : les modèles sauvegardés dans une version ne sont pas garantis de se charger dans une autre. Pour un déploiement inter-langages (servir un modèle Python depuis Java/Go), convertissez en ONNX avec skl2onnx. Sauvegardez toujours le pipeline complet, pas juste le modèle, pour que le prétraitement soit identique à l'inférence.

machine-learning
import joblib

# Save the entire fitted pipeline
joblib.dump(full_pipe, "model.pkl")

# Later (e.g. in a web service)
loaded = joblib.load("model.pkl")
predictions = loaded.predict(new_data)

# Why joblib over pickle?
# - More efficient for numpy arrays (which sklearn models contain)
# - Handles objects with large numerical arrays via compression

# Version compatibility:
# - sklearn versions must match between save and load in production
# - Pin sklearn in requirements.txt: scikit-learn==1.4.2

# For cross-language deployment, use ONNX:
# import skl2onnx
# onx = skl2onnx.convert_sklearn(full_pipe, ...)
17

Persistance des modèles

joblib vs pickle

Employez joblib pour les modèles sklearn — optimisé pour les tableaux numpy et avec compression intégrée. pickle est le repli pour les objets Python arbitraires. Tous deux partagent la même réserve de sécurité : ne chargez JAMAIS de fichiers pickle/joblib non fiables — ils peuvent exécuter du code arbitraire à la désérialisation. Pour servir des modèles à des environnements non fiables, employez ONNX ou un serveur de modèles avec validation des entrées.

machine-learning
import joblib
import pickle

# joblib — preferred for sklearn (efficient with numpy arrays)
joblib.dump(model, "model.joblib", compress=3)
model = joblib.load("model.joblib")

# pickle — standard library, works for any picklable object
with open("model.pkl", "wb") as f:
    pickle.dump(model, f)
with open("model.pkl", "rb") as f:
    model = pickle.load(f)

# Compress to save disk space (joblib supports it natively)
joblib.dump(model, "model.joblib", compress=("xz", 3))

# Load partially for inspection without full deserialize
# (advanced, not commonly needed)

Versionner les modèles

Versionnez toujours vos modèles avec des métadonnées : versions des frameworks (sklearn, python), liste des caractéristiques, hachage des données d'entraînement, métriques, commit git et horodatage. Cela rend le débogage des problèmes de production praticable — quand un modèle se comporte différemment, on compare les métadonnées pour voir ce qui a changé. Employez le versionnage sémantique : patch pour ré-entraîner, minor pour de nouvelles caractéristiques, major pour les changements cassants (nouveau prétraitement cassant les vieilles prédictions).

machine-learning
# Save metadata alongside the model artifact
import joblib, json
from datetime import datetime

metadata = {
    "model_type": "RandomForestClassifier",
    "sklearn_version": sklearn.__version__,
    "python_version": sys.version,
    "features": list(X_train.columns),
    "target": "churn",
    "metrics": {"f1": 0.842, "roc_auc": 0.913},
    "trained_at": datetime.utcnow().isoformat(),
    "data_hash": hashlib.md5(pd.util.hash_pandas_object(X_train).values).hexdigest(),
    "git_commit": subprocess.check_output(["git", "rev-parse", "HEAD"]).decode().strip(),
}

joblib.dump({"model": model, "metadata": metadata}, "model_v1.2.0.joblib")

# Convention: semantic versioning
# v1.0.0 -> initial release
# v1.1.0 -> retrained on new data (backward compatible)
# v2.0.0 -> breaking change (new features, new preprocessing)

Export ONNX

ONNX est un format de modèle multiplateforme — convertissez votre pipeline sklearn une fois, exécutez-le partout (Python, C++, Java, JavaScript, Go) sans dépendances Python. Idéal en production : l'environnement d'entraînement (Python) et l'environnement de service (ex. un microservice Go) peuvent différer. Le runtime ONNX est aussi plus rapide que sklearn pour beaucoup de modèles. Réserve : tous les transformers et modèles sklearn n'ont pas d'équivalent ONNX — vérifiez le support skl2onnx avant de vous engager.

machine-learning
# pip install skl2onnx onnxruntime
from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType
import onnxruntime as rt

# Convert sklearn pipeline to ONNX
initial_type = [("float_input", FloatTensorType([None, X_train.shape[1]]))]
onnx_model = convert_sklearn(full_pipe, initial_types=initial_type,
                              target_opset=15)

with open("model.onnx", "wb") as f:
    f.write(onnx_model.SerializeToString())

# Run inference in any language (Python, C++, Java, JS, Go, ...)
sess = rt.InferenceSession("model.onnx")
input_name = sess.get_inputs()[0].name
predictions = sess.run(None, {input_name: X_test.astype(np.float32)})[0]

# Benefits: no Python at inference, fast, cross-platform

Bases de la surveillance des modèles

Les modèles se dégradent en production à mesure que le monde change — surveillez la dérive. Dérive de données : les caractéristiques d'entrée changent de distribution (ex. les démographies d'utilisateurs glissent). Dérive de concept : la relation entre caractéristiques et cible change (ex. les motifs de fraude évoluent). PSI (Population Stability Index) est une métrique de dérive simple et interprétable — des valeurs > 0,25 justifient un ré-entraînement. Combinez les alertes de dérive avec des plannings de ré-entraînement périodiques. Journalisez toujours les prédictions pour permettre l'analyse a posteriori.

machine-learning
# After deployment, monitor for:
# 1. Data drift: input distribution changes
# 2. Concept drift: P(y|X) changes
# 3. Prediction drift: output distribution changes
# 4. Performance degradation: metric drops over time

# Simple data drift check: PSI (Population Stability Index)
def psi(expected, actual, bins=10):
    expected_pct = np.histogram(expected, bins=bins)[0] / len(expected)
    actual_pct   = np.histogram(actual,   bins=bins)[0] / len(actual)
    # Avoid log(0)
    expected_pct = np.clip(expected_pct, 1e-4, None)
    actual_pct   = np.clip(actual_pct,   1e-4, None)
    return np.sum((actual_pct - expected_pct) * np.log(actual_pct / expected_pct))

# PSI < 0.1: stable, 0.1-0.25: minor drift, > 0.25: significant drift
for col in X.columns:
    score = psi(X_train[col], X_new[col])
    if score > 0.25:
        print(f"Drift detected in {col}: PSI={score:.3f}")

Stratégies de ré-entraînement

Choisissez une stratégie de ré-entraînement selon la vitesse de changement de vos données. Planifiée (la plus simple, prévisible). Déclenchée par la performance (réactive, ne ré-entraîne qu'au besoin). Déclenchée par la dérive (avertissement précoce avant chute de performance). Apprentissage en ligne (mises à jour continues pour les données changeant vite comme la fraude ou les recommandations). Validez toujours un nouveau modèle contre l'actuel sur des données récentes, déployez en ombre pour comparer les prédictions en direct, et prévoyez un rollback automatique si les métriques régressent.

machine-learning
# 1. Scheduled retraining (simplest)
#    Retrain weekly/monthly regardless of performance
schedule = "0 2 * * 0"  # every Sunday at 2am

# 2. Performance-triggered retraining
#    Retrain when a metric drops below threshold
if current_f1 < production_f1 * 0.95:  # 5% drop
    trigger_retrain()

# 3. Drift-triggered retraining
#    Retrain when PSI exceeds threshold
if max_psi > 0.25:
    trigger_retrain()

# 4. Online learning (incremental updates)
from sklearn.linear_model import SGDClassifier
model = SGDClassifier()
for X_batch, y_batch in stream:
    model.partial_fit(X_batch, y_batch, classes=[0, 1])

# Always:
# - Validate new model beats old on recent data before promoting
# - Shadow deploy: run new model in parallel, compare predictions
# - Roll back automatically if metrics regress
# - Keep training data fresh (drop old samples)
18

Régularisation

L1 (Lasso) vs L2 (Ridge)

L1 (Lasso) ajoute une pénalité de valeur absolue poussant certains coefficients à exactement zéro — sélection de caractéristiques intégrée, idéale quand beaucoup de caractéristiques sont sans pertinence. L2 (Ridge) ajoute une pénalité quadratique rétrécissant les coefficients en douceur — mieux quand beaucoup de caractéristiques contribuent chacune un peu. ElasticNet mélange les deux et est préféré quand les caractéristiques sont corrélées (le Lasso seul en choisit une au hasard et annule les autres). Mettez toujours les caractéristiques à l'échelle d'abord pour une pénalité équitable.

machine-learning
from sklearn.linear_model import Lasso, Ridge, ElasticNet
import numpy as np

# L1 (Lasso): penalty = alpha * sum(|coef|)
# Drives some coefficients to exactly 0 -> sparse -> feature selection
lasso = Lasso(alpha=0.1)
lasso.fit(X_train_scaled, y_train)
print("Non-zero coefs:", (lasso.coef_ != 0).sum(), "/", len(lasso.coef_))

# L2 (Ridge): penalty = alpha * sum(coef^2)
# Shrinks coefficients smoothly toward 0, keeps all features
ridge = Ridge(alpha=1.0)
ridge.fit(X_train_scaled, y_train)

# ElasticNet: mix of L1 and L2
# penalty = alpha * (l1_ratio * L1 + (1 - l1_ratio) * L2)
en = ElasticNet(alpha=0.1, l1_ratio=0.5)
en.fit(X_train_scaled, y_train)

# Rule of thumb:
# - L1: many features, only a few matter (sparse)
# - L2: many features, all matter a little
# - ElasticNet: correlated features (Lasso picks one randomly)

Régularisation des arbres

Pour les arbres, max_depth et min_samples_leaf sont les régulariseurs les plus forts — ils empêchent l'arbre de mémoriser des échantillons individuels. ccp_alpha fait l'élagage coût-complexité (un élagage a posteriori plus fondé). Pour les forêts aléatoires, max_features et bootstrap ajoutent de la régularisation par l'aléatoire. Pour le gradient boosting, learning_rate et early_stopping sont critiques (LR bas + arrêt précoce + assez d'arbres gagne habituellement). Subsample et colsample_bytree ajoutent davantage de régularisation par stochasticité.

machine-learning
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier

# Decision tree regularization hyperparameters
tree = DecisionTreeClassifier(
    max_depth=5,             # limit tree depth (strongest lever)
    min_samples_split=20,    # min samples to split a node
    min_samples_leaf=10,     # min samples per leaf
    max_leaf_nodes=20,       # cap total leaves
    max_features="sqrt",     # features considered per split
    ccp_alpha=0.01,          # cost-complexity pruning
)

# Random forest adds more regularization via:
rf = RandomForestClassifier(
    n_estimators=200,
    max_depth=None,
    min_samples_leaf=5,
    max_features="sqrt",     # random feature subset per split
    bootstrap=True,          # bagging
    max_samples=0.8,         # subsample ratio
)

# For boosting (XGBoost), also use:
# - learning_rate (smaller = more regularization)
# - subsample, colsample_bytree (randomness)
# - reg_lambda, reg_alpha (L2/L1 on leaf weights)
# - gamma (minimum loss reduction to split)
# - early_stopping_rounds

Dropout et BatchNorm (deep learning)

Le Dropout met aléatoirement à zéro des activations pendant l'entraînement, forçant le réseau à apprendre des représentations redondantes — un fort régulariseur. Plus élevé dans les grandes couches, plus bas dans les petites, souvent zéro en sortie. BatchNorm normalise les activations par batch, stabilisant l'entraînement et ajoutant un léger effet régularisant (les stats du batch ajoutent du bruit). Rappelez-vous : dropout et batchnorm se comportent différemment en train vs eval — appelez toujours model.eval() pour l'inférence et model.train() pour reprendre l'entraînement.

machine-learning
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(784, 256),
    nn.BatchNorm1d(256),     # normalize activations -> faster, stable training
    nn.ReLU(),
    nn.Dropout(0.5),         # randomly zero 50% of activations during training

    nn.Linear(256, 128),
    nn.BatchNorm1d(128),
    nn.ReLU(),
    nn.Dropout(0.3),         # less dropout closer to output

    nn.Linear(128, 10),      # no dropout before output (or use very low)
)

# IMPORTANT: dropout is OFF during inference (model.eval())
# BatchNorm uses batch stats in training and running stats in eval

# Common patterns:
# - Higher dropout in big layers, lower in small layers
# - No dropout right after input or right before output
# - BatchNorm before activation (debated; try both)

Arrêt précoce

L'arrêt précoce interrompt l'entraînement quand la perte de validation cesse de s'améliorer, prévenant le sur-apprentissage et économisant le calcul. Sauvegardez toujours le meilleur modèle (perte de val la plus basse), pas le final — le modèle final peut avoir sur-appris. patience contrôle combien d'époques sans amélioration tolérer. Pour le gradient boosting, early_stopping_rounds fait la même chose au niveau des arbres. L'arrêt précoce est l'un des régulariseurs au plus haut rapport valeur/effort — employez-le toujours en deep learning.

machine-learning
import torch

best_val_loss = float("inf")
patience, counter = 5, 0
best_state = None

for epoch in range(max_epochs):
    train_loss = train_one_epoch(model, train_loader, optimizer, criterion)
    val_loss   = validate(model, val_loader, criterion)

    if val_loss < best_val_loss:
        best_val_loss = val_loss
        counter = 0
        best_state = {k: v.clone() for k, v in model.state_dict().items()}
    else:
        counter += 1
        if counter >= patience:
            print(f"Early stopping at epoch {epoch}")
            break

# Restore the best model
model.load_state_dict(best_state)

# For XGBoost/LightGBM, use early_stopping_rounds:
# model.fit(X_train, y_train,
#           eval_set=[(X_val, y_val)],
#           early_stopping_rounds=20)

Augmentation de données

L'augmentation de données est le régulariseur le plus fort quand les données étiquetées sont rares — elle étend synthétiquement le jeu de données avec des transformations préservant les étiquettes. Pour les images : retournements, recadrages, jitter de couleur, rotations (adaptées au domaine — ne retournez pas de radiographies médicales, retournez les images naturelles). Pour le texte : remplacement de synonymes, rétro-traduction, suppression aléatoire. Pour le tabulaire : SMOTE (déséquilibré) ou mixup (régression). L'augmentation vous donne effectivement des données étiquetées gratuites.

machine-learning
# Images (torchvision)
import torchvision.transforms as T

train_transform = T.Compose([
    T.RandomResizedCrop(224),
    T.RandomHorizontalFlip(),
    T.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
    T.RandomRotation(10),
    T.ToTensor(),
    T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

# Text (NLPAug or simple Python)
import random
def augment_text(text):
    # Synonym replacement, random deletion, back-translation
    words = text.split()
    if random.random() < 0.3:
        idx = random.randrange(len(words))
        words[idx] = synonym(words[idx])
    if random.random() < 0.2:
        words = [w for w in words if random.random() > 0.1]
    return " ".join(words)

# Tabular (SMOTE for imbalance, mixup for regression)
# mixup: X_mix = alpha*X1 + (1-alpha)*X2, y_mix = alpha*y1 + (1-alpha)*y2

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.