Master 1 · IA & Données

Apprentissage automatique · Statistiques · Optimisation

Machine
Learning

Le machine learning permet aux systèmes d'apprendre automatiquement depuis l'expérience, d'améliorer leurs performances et de faire des prédictions sans être explicitement programmés pour chaque tâche.

sklearn_pipeline.py
01from sklearn.pipeline import Pipeline
02from sklearn.preprocessing import StandardScaler
03from sklearn.ensemble import GradientBoostingClassifier
04
05clf = Pipeline([
06  ('scaler', StandardScaler()),
07  ('clf', GradientBoostingClassifier(
08    n_estimators=200, learning_rate=0.05))
09])
10clf.fit(X_train, y_train)
11acc = clf.score(X_test, y_test)
12print(f"Accuracy: {acc:.3f}")
—
Terme popularisé par Arthur Samuel
—
GPT-3 (2020)
—
Erreur top-5 ImageNet (AlexNet 2012)
—
Entreprises utilisant le ML
📐
01

Fondements mathématiques

Formalisation générale du ML (Tom Mitchell, 1997)
« Un programme P apprend d'une expérience E par rapport à une classe de tâches T si ses performances P s'améliorent avec E. »

Tâche T : classification, régression, clustering. Expérience E : données d'entraînement. Performance P : accuracy, RMSE, AUC...

Erreur généralisée (décomposition biais-variance)
E[(y - ŷ)²] = Biais²(ŷ) + Variance(ŷ) + σ²_irréductible

Biais : erreur systématique due aux hypothèses du modèle (underfitting). Variance : sensibilité aux fluctuations des données (overfitting). Compromis fondamental dans tout apprentissage statistique.

Algèbre

Algèbre linéaire

Vecteurs, matrices, tenseurs. Produit scalaire, norme ‖w‖. SVD (décomposition valeurs singulières). Valeurs propres (ACP). Espace d'hypothèses = espace vectoriel de fonctions.

Probabilités

Théorème de Bayes & MLE

P(θ|X) ∝ P(X|θ)·P(θ). Maximum de vraisemblance (MLE) : maximiser P(X|θ). Maximum a posteriori (MAP) : intégrer le prior. Fondement des classifieurs bayésiens naïfs et des modèles génératifs.

Calcul différentiel

Gradient & Optimisation

∇L(θ) : direction de la plus forte augmentation de la perte. Descente de gradient : θ ← θ - α∇L. Règle de la chaîne : base de la rétropropagation. Jacobien, Hessien, saddle points.

Théorie

VC Dimension & PAC Learning

Vapnik-Chervonenkis : capacité d'un espace d'hypothèses. PAC (Probably Approximately Correct) learning : garanties de généralisation. Complexité de Rademacher. No Free Lunch theorem.

🎯
02

Apprentissage supervisé

Apprendre une fonction f: X → Y depuis des paires étiquetées (xᵢ, yᵢ). Classification (y discret) ou régression (y continu).

AlgorithmeTypeAvantagesLimites
Régression linéaire / logistiqueRégression / ClassificationInterprétable, rapideRelations non-linéaires
k-NN (k plus proches voisins)Classification / RégressionSimple, pas de trainingLent en inférence, sensible aux dimensions
SVM (Support Vector Machine)ClassificationEfficace en haute dim., kernel trickLent sur grands datasets
Arbre de décisionClassification / RégressionInterprétable, robuste aux outliersOverfitting sans élagage
Random ForestEnsemble (bagging)Robuste, feature importanceMoins interprétable
Gradient Boosting (XGBoost, LightGBM)Ensemble (boosting)State-of-the-art données tabulairesHyperparamètres nombreux
Réseau de neurones (MLP)Universal approximatorScalable, expressifDonnées abondantes requises
Gaussian ProcessRégression bayésienneIncertitude quantifiéeO(n³) en temps
SVM — Hyperplan séparateur à marge maximale
min ½‖w‖² s.t. yᵢ(w·xᵢ + b) ≥ 1 ∀i   ·   Kernel trick: K(x,x') = φ(x)·φ(x')

Le kernel trick projette implicitement les données dans un espace de features de dimension infinie. Kernels communs : RBF (Gaussien), polynomial, sigmoïde.

Python · Comparaison classifieurs sur données synthétiques
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
import xgboost as xgb

X, y = make_classification(n_samples=5000, n_features=20, n_informative=10)

models = {
    'Random Forest': RandomForestClassifier(n_estimators=200),
    'XGBoost':       xgb.XGBClassifier(n_estimators=200, eval_metric='logloss'),
    'GBM':           GradientBoostingClassifier(n_estimators=200),
    'SVM (RBF)':     SVC(kernel='rbf', C=10, probability=True),
}

for name, clf in models.items():
    auc = cross_val_score(clf, X, y, cv=5, scoring='roc_auc').mean()
    print(f"{name:25s} AUC = {auc:.4f}")
🔮
03

Apprentissage non-supervisé

Clustering

K-Means & DBSCAN

K-Means : minimise l'inertie intra-cluster. Algorithme EM. Sensible aux outliers. DBSCAN : découvre des clusters de forme arbitraire, gère les outliers. HDBSCAN : version hiérarchique robuste.

Réduction dim.

ACP & t-SNE & UMAP

ACP (PCA) : projection linéaire sur axes de variance maximale. Eigenvectors de la covariance. t-SNE : préserve la structure locale (2D/3D visualisation). UMAP : plus rapide, préserve la structure globale.

Génératif

GMM & VAE

Gaussian Mixture Model : mélange de gaussiennes, algo EM. VAE (Variational Autoencoder) : encode dans un espace latent continu + décode. Génération de nouveaux échantillons, interpolation latente.

Représentation

Auto-encodeurs

Encodeur : X → z (bottleneck). Décodeur : z → X'. Apprend une représentation compressée non-supervisée. Applications : débruitage, détection d'anomalies, compression, features pour d'autres tâches.

🎮
04

Apprentissage par renforcement

Processus de décision markovien (MDP)
(S, A, P, R, γ)   ·   V*(s) = max_a [R(s,a) + γ Σ P(s'|s,a) V*(s')]

S : états, A : actions, P : transitions, R : récompenses, γ : facteur d'actualisation. L'équation de Bellman est la base de tous les algorithmes RL.

Model-free

Q-Learning & DQN

Q(s,a) ← Q(s,a) + α[r + γ max Q(s',a') - Q(s,a)]. Deep Q-Network (DeepMind) : Q-table remplacée par un CNN. Experience replay + target network. A joué à Atari (2013).

Policy gradient

PPO & A3C

Optimise directement la politique π(a|s). PPO (Proximal Policy Optimization) : clip de ratio pour stabilité. A3C : acteur-critique asynchrone. REINFORCE, SAC. Base d'AlphaGo et des LLMs (RLHF).

RLHF

Reinforcement Learning from Human Feedback

Fine-tuning des LLMs via feedback humain. Étapes : SFT (supervised fine-tuning) → Reward Model → PPO. Base de ChatGPT, Claude, Gemini. Alternative : DPO (Direct Preference Optimization).

🧬
05

Deep Learning

CNN

Réseaux convolutifs

Convolution : détecte des features locales (bords, textures, formes). Pooling : réduction spatiale. Architecture : Conv → BN → ReLU → Pool → FC. ResNet (He 2016) : skip connections pour les réseaux très profonds (152 couches).

RNN/LSTM

Réseaux récurrents

Séquences temporelles. LSTM (Long Short-Term Memory) : cellule de mémoire, portes d'oubli/entrée/sortie. GRU : version simplifiée. Gradient vanishing → solution : transformers. Encore utilisés : séries temporelles, audio.

Transformer

Self-Attention & Multi-Head

Attention(Q,K,V) = softmax(QKᵀ/√d)V. Capture les dépendances longue portée. Multi-head : plusieurs têtes d'attention parallèles. Architecture encoder-decoder ou decoder-only (GPT). Positional encoding.

GAN

Generative Adversarial Networks

min_G max_D V(D,G) = E[log D(x)] + E[log(1-D(G(z)))]. Générateur vs Discriminateur. Mode collapse. Améliorations : WGAN, StyleGAN, CycleGAN. Remplacés par les modèles de diffusion pour la génération d'images.

Diffusion

Modèles de diffusion

Processus de débruitage en T étapes. q(xₜ|xₜ₋₁) = N(√(1-βₜ)xₜ₋₁, βₜI). Génération : débruite depuis un bruit gaussien pur. DDPM, DDIM, Stable Diffusion. Score matching. État de l'art génération image/vidéo/audio.

Fine-tuning

Transfer Learning & PEFT

Réutiliser des features pré-entraînées sur de grands datasets. PEFT : Parameter-Efficient Fine-Tuning. LoRA : fine-tune de faibles matrices de rang pour économiser la mémoire. QLoRA : quantification 4-bit. Adapter layers.

📊
06

Évaluation des modèles

MétriqueFormuleUsageQuand l'utiliser
Accuracy(TP+TN)/(TP+TN+FP+FN)ClassificationClasses équilibrées
PrécisionTP/(TP+FP)ClassificationCoût élevé des faux positifs
Rappel (Sensibilité)TP/(TP+FN)ClassificationCoût élevé des faux négatifs (médecine)
F1-Score2·(P·R)/(P+R)ClassificationClasses déséquilibrées
AUC-ROCAire sous la courbe ROCClassification binairePerformance globale, seuil indépendant
RMSE√(Σ(yᵢ-ŷᵢ)²/n)RégressionErreurs grandes pénalisées
MAEΣ|yᵢ-ŷᵢ|/nRégressionRobuste aux outliers
R² (coefficient)1 - SS_res/SS_totRégressionProportion de variance expliquée
Validation croisée k-fold
CV_k = (1/k) Σᵢ₌₁ᵏ L(fᵢ, Dᵢ_test)

Découpe les données en k plis, entraîne sur k-1, teste sur 1, répète k fois. Réduit la variance de l'estimation de performance. k=5 ou k=10 en pratique. Leave-One-Out CV : k=n.

⚙️
07

Optimisation & Régularisation

Optimiseurs

SGD, Adam, AdaGrad

SGD : descente de gradient stochastique (mini-batch). Momentum : accumule le gradient passé. Adam (Kingma 2015) : moments adaptatifs du 1er et 2ème ordre. AdamW : Adam + weight decay découplé. Lion : plus efficace en mémoire.

Régularisation

L1, L2, Dropout, BatchNorm

L1 (Lasso) : sparsité, sélection de features. L2 (Ridge) : pénalise les grands poids. Dropout : désactive aléatoirement des neurones à l'entraînement. BatchNorm : normalise les activations, accélère la convergence.

Hyperparamètres

Grid Search, Random Search, Bayesian

Grid search : exhaustif. Random search : plus efficace en haute dimension. Optimisation bayésienne (Optuna, Hyperopt) : modélise la fonction objectif et guide la recherche. AutoML : NAS, BOHB.

Learning Rate

Scheduling & Warmup

Cosine annealing, step decay, polynomial decay. Warmup : augmentation graduelle du LR au début (stabilise les Transformers). OneCycleLR (fastai). Cyclical LR pour échapper aux minima locaux.

🔧
08

Pipeline ML en production

📊
Données

Collecte, annotation, stockage

🧹
Prétraitement

Nettoyage, features, normalisation

🏋️
Entraînement

Modèle, GPU, tracking

📏
Évaluation

Métriques, validation

🚀
Déploiement

API, serving, monitoring

Écosystème

Scikit-learnPyTorchTensorFlow / Keras XGBoost / LightGBMPandas / NumPyWeights & Biases MLflowHugging FaceRay / Dask BentoML / TorchServeONNXTriton Inference Server