Gradient stochastique

gradient stochastique

Gradient stochastique

contenu

resources

Descente de Gradient Stochastique

1. Méthode du Gradient

Objectif : Trouver le minimum d’une fonction dérivable $f(x)$

Principe : Itération selon la direction opposée au gradient

\[x_{n+1} = x_n - \eta \nabla f(x_n)\]

où $\eta$ est le taux d’apprentissage (learning rate)

2. Démonstration : Fonction Polynomiale

Exemple : Minimiser $f(x) = x^2 - 4x + 5$

Dérivée : $f’(x) = 2x - 4$

Algorithme :

Résultat : $f(2) = 1$ est le minimum global

3. Gradient Stochastique : Idée Générale

Problème : Fonction inconnue ou coûteuse à calculer

Solution : Approximer le gradient par des estimations non biaisées

Principe clé : \(\mathbb{E}[\nabla_{\text{estimé}}] = \nabla_{\text{vrai}}\)

L’espérance des estimations du gradient égale le gradient réel

4. Pourquoi “Stochastique” ?

Le gradient calculé sur un seul échantillon d’entraînement est une approximation stochastique du gradient du coût total

Gradient complet (batch) : \(\nabla E = \frac{1}{n}\sum_{i=1}^n \nabla L_i\)

Gradient stochastique (un échantillon) : \(\nabla \tilde{E} = \nabla L_k \quad \text{(échantillon aléatoire } k\text{)}\)

5. Estimation du Gradient

Méthodes d’estimation :

  1. Différences finies : \(\frac{\partial f}{\partial x} \approx \frac{f(x + h) - f(x)}{h}\)

  2. Sous-échantillonnage : Utiliser un sous-ensemble aléatoire des données

  3. Gradient exact sur échantillon : Calculer le gradient analytique sur un point

6. Fonction de Coût : Forme Générale

\[E(w, b) = L(y, f(x; w, b)) + \alpha R(w)\]

Composantes :

7. Exemple : Erreur Quadratique

Fonction de perte : \(L = \frac{1}{2}(y - \hat{y})^2\)

Gradient : \(\frac{\partial L}{\partial w} = -(y - \hat{y}) \cdot \frac{\partial \hat{y}}{\partial w}\)

⚠️ Important : Normaliser les features pour améliorer la convergence

\[x_{\text{norm}} = \frac{x - \mu}{\sigma}\]

8. Brève Histoire du SGD

9. Implémentation Moderne

Frameworks optimisés :

Optimisations :

10. Apprentissage en Ligne (Online Learning)

Principe : Mise à jour après chaque observation

Avantages :

Application :

11. SGDRegressor : Paramètres Clés

from sklearn.linear_model import SGDRegressor

model = SGDRegressor(
    loss='squared_error',      # Fonction de perte
    penalty='l2',              # Régularisation
    alpha=0.0001,              # Force régularisation
    learning_rate='invscaling', # Stratégie LR
    eta0=0.01,                 # LR initial
    max_iter=1000,             # Nb itérations
    tol=1e-3,                  # Critère arrêt
    early_stopping=True        # Arrêt anticipé
)

12. Influence du Taux d’Apprentissage

\[w_{t+1} = w_t - \eta \nabla L(w_t)\]

$\eta$ trop grand :

$\eta$ trop petit :

$\eta$ optimal : Convergence rapide et stable

13. Stratégies de Learning Rate

1. Constant : $\eta_t = \eta_0$

2. Décroissance temporelle : \(\eta_t = \frac{\eta_0}{1 + t \cdot d}\)

3. Inverse scaling : \(\eta_t = \frac{\eta_0}{t^\alpha}\)

4. Adaptatif : Ajustement selon performance validation

14. Learning Rate Adaptatif

Méthodes avancées :

AdaGrad : Adapte $\eta$ par paramètre \(\eta_t^{(i)} = \frac{\eta_0}{\sqrt{\sum_{\tau=1}^t (g_\tau^{(i)})^2 + \epsilon}}\)

RMSprop : Moyenne mobile des gradients

Adam : Combine momentum + adaptation

15. Batch vs Mini-Batch vs Stochastique

Type Taille échantillon Caractéristiques
Batch GD Tous ($n$) Stable, lent, grande mémoire
Stochastic GD 1 Rapide, bruité, converge
Mini-Batch GD $m$ (ex: 32-256) Optimal : vectorisation + stabilité

Formule mini-batch : \(w_{t+1} = w_t - \eta \frac{1}{m}\sum_{i=1}^m \nabla L_i(w_t)\)

16. Mini-Batch : Out-of-Core Learning

Problème : Dataset trop large pour la RAM

Solution : Charger les données par batch

for epoch in range(n_epochs):
    for batch in data_loader:
        gradient = compute_gradient(batch)
        weights -= learning_rate * gradient

Applications : Big Data, streaming

17. Régularisation L1 (Lasso)

\[R(w) = \|w\|_1 = \sum_{i=1}^d |w_i|\]

Effet : Sélection de variables (sparsité)

Gradient sous-différentiel : \(\frac{\partial R}{\partial w_i} = \text{sign}(w_i)\)

Usage : Features redondantes, interprétabilité

18. Régularisation L2 (Ridge)

\[R(w) = \|w\|_2^2 = \sum_{i=1}^d w_i^2\]

Effet : Réduction de tous les poids

Gradient : \(\frac{\partial R}{\partial w_i} = 2w_i\)

Mise à jour : \(w_{t+1} = (1 - 2\eta\alpha)w_t - \eta \nabla L(w_t)\)

19. Régularisation Elastic Net

Combinaison L1 + L2 : \(R(w) = \rho \|w\|_1 + \frac{1-\rho}{2}\|w\|_2^2\)

Avantages :

SGDRegressor(penalty='elasticnet',
             l1_ratio=0.5)

20. Comment Régulariser le SGD

Paramètres Scikit-learn :

SGDRegressor(
    penalty='l2',        # 'l1', 'l2', 'elasticnet'
    alpha=0.0001,        # Force régularisation
    l1_ratio=0.15        # Si elasticnet
)

Impact :

21. Early Stopping (Arrêt Anticipé)

Principe : Arrêter l’entraînement avant la fin si pas d’amélioration

Algorithme :

  1. Diviser : train / validation
  2. À chaque époque : évaluer sur validation
  3. Si pas d’amélioration pendant $p$ époques : STOP

Implémentation :

SGDRegressor(
    early_stopping=True,
    validation_fraction=0.1,
    n_iter_no_change=5
)

22. SGDRegressor : Exemple Complet

from sklearn.linear_model import SGDRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# Normalisation
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Division
X_train, X_val, y_train, y_val = train_test_split(
    X_scaled, y, test_size=0.2
)

# Modèle
sgd = SGDRegressor(
    loss='squared_error',
    penalty='l2',
    alpha=0.001,
    learning_rate='adaptive',
    eta0=0.01,
    early_stopping=True
)

sgd.fit(X_train, y_train)

23. Vue d’Ensemble des Optimiseurs

SGD classique : $w_t = w_{t-1} - \eta \nabla L$

SGD + Momentum : \(v_t = \beta v_{t-1} + \nabla L\) \(w_t = w_{t-1} - \eta v_t\)

Nesterov : Momentum anticipé

AdaGrad : LR adaptatif par paramètre

RMSprop : Moyenne mobile du gradient carré

24. Optimiseurs Avancés

Adam (Adaptive Moment Estimation) :

AdamW : Adam avec weight decay découplé

Nadam : Nesterov + Adam

RAdam : Warmup automatique

Choisir : Adam par défaut, SGD+momentum si besoin de généralisation

25. Comparaison des Optimiseurs

Optimiseur Vitesse Stabilité Généralisation Usage
SGD ⭐⭐ ⭐⭐⭐ ⭐⭐⭐⭐ Classique
SGD+Momentum ⭐⭐⭐ ⭐⭐⭐ ⭐⭐⭐⭐ Recommandé
Adam ⭐⭐⭐⭐ ⭐⭐ ⭐⭐⭐ Deep Learning
RMSprop ⭐⭐⭐ ⭐⭐⭐ ⭐⭐⭐ RNN

26. Momentum : Intuition

Problème SGD : Oscillations dans les ravins

Solution : Accumuler la “vitesse”

\(v_t = \beta v_{t-1} + (1-\beta) \nabla L_t\) \(w_t = w_{t-1} - \eta v_t\)

Effet :

27. Diagnostic de Convergence

Courbes d’apprentissage :

Signes de problèmes :

28. Hyperparamètres : Réglage

Stratégies :

  1. Grid Search : Test exhaustif
  2. Random Search : Échantillonnage aléatoire
  3. Bayesian Optimization : Recherche intelligente

Paramètres critiques :

29. Astuces Pratiques

Toujours normaliser : StandardScaler ou MinMaxScaler

Mélanger les données : shuffle=True

Monitoring : Verbose pour suivre la convergence

Warmup : Commencer avec petit LR

Gradient clipping : Éviter explosions (Deep Learning)

Checkpointing : Sauvegarder meilleur modèle

30. Limitations du SGD

Choix du Learning Rate : Sensible, difficile à optimiser

Minima locaux : Peut rester coincé (fonctions non-convexes)

Saddle points : Ralentit près des points-selle

Scaling : Sensible à l’échelle des features

Solution : Optimiseurs adaptatifs (Adam, etc.)

31. Quand Utiliser SGD ?

SGD convient si :

Alternatives :

32. Extensions du SGD

Variance Reduction :

Second-ordre :

Distribué :

33. SGD en Deep Learning

Particularités :

Best Practices :

34. Références et Ressources

Papers fondateurs :

Documentation :

Cours :

35. Conclusion

SGD = Outil fondamental du Machine Learning

Points clés : ✓ Approximation stochastique du gradient ✓ Efficace sur grandes données ✓ Nombreux variants optimisés ✓ Toujours normaliser et régulariser ✓ Choisir l’optimiseur selon le problème

Recommandation : Commencer avec SGD+momentum ou Adam