Aller au contenu
ELECTRONICS ENGINEERINGelectronics-engineering.com
Apprentissage automatique et réseaux de neurones

Optimiseurs : SGD, momentum, RMSProp et Adam avec correction du biais

La descente de gradient stochastique par mini-lots, le momentum, RMSProp, Adam et la correction du biais démontrée, AdamW, le démarrage progressif et la décroissance par paliers, comparaison des méthodes sur la fonction de Rosenbrock.

https://www.electronics-engineering.com/fr/optimiseurs-sgd-momentum-adam-rosenbrock/

Pas encore de vote : soyez le premier à noter cette page.

La descente de gradient de la leçon 1 fonctionne, mais sur les réseaux de neurones elle est lente : la surface d’erreur a des vallées étroites et longues, des régions plates et des millions de dimensions de courbures très différentes. Les optimiseurs modernes modifient la règle de mise à jour pour aller plus vite et de façon plus stable. Cette leçon présente la descente de gradient stochastique par mini-lots, le momentum, RMSProp et Adam (l’optimiseur le plus utilisé), démontre pourquoi Adam a besoin de la « correction du biais », discute le choix du pas dans le temps, et compare les méthodes sur la fonction de Rosenbrock, une vallée courbe qui est le banc d’essai classique.

La descente de gradient stochastique

Le gradient de la perte est une moyenne sur les n exemples. Avec des millions d’exemples, le calculer en entier à chaque pas est un gaspillage. La descente de gradient stochastique (SGD) utilise à chaque pas un mini-lot B de quelques dizaines ou centaines d’exemples tirés au hasard :

    \[ \mathbf g_k = \frac{1}{|B|}\sum_{i\in B}\nabla\ell_i(\mathbf w_k),\qquad \mathbf w_{k+1} = \mathbf w_k - \eta\,\mathbf g_k \]

\mathbf g_k est une estimation non biaisée du vrai gradient (la moyenne d’un échantillon aléatoire a pour espérance la moyenne de la population), avec une variance qui décroît comme 1/|B|. Le bruit n’est pas seulement un défaut : il aide à sortir des régions plates et, selon de nombreuses études, conduit à des minima « plus larges » qui généralisent mieux. Un passage complet sur les données s’appelle une époque (epoch).

Le momentum

Dans une vallée étroite, le gradient pointe surtout vers les parois : la descente rebondit d’un côté à l’autre et avance lentement le long du fond. Le momentum (Polyak, 1964 : la « méthode de la bille lourde ») accumule une vitesse :

    \[ \mathbf v_{k+1} = \beta\,\mathbf v_k + \mathbf g_k,\qquad \mathbf w_{k+1} = \mathbf w_k - \eta\,\mathbf v_{k+1} \]

avec \beta \approx 0.9. Les composantes du gradient qui changent de signe à chaque pas (à travers la vallée) s’annulent dans la moyenne ; celles qui ont toujours le même signe (le long de la vallée) s’additionnent. Si le gradient était constant, la vitesse tendrait vers \mathbf g/(1 - \beta) : avec \beta = 0.9, un pas dix fois plus long dans la bonne direction.

RMSProp et Adam : un pas par paramètre

Des paramètres différents peuvent avoir des gradients d’échelles très différentes (par exemple les poids des premières couches et ceux des dernières). RMSProp (Hinton, 2012) divise le pas de chaque paramètre par une moyenne mobile de la racine de son gradient au carré : ceux qui ont de grands gradients font des pas plus courts, ceux qui en ont de petits des pas plus longs. Adam (Kingma et Ba, 2014) combine cette idée avec le momentum :

    \[ \mathbf m_k = \beta_1\mathbf m_{k-1} + (1 - \beta_1)\mathbf g_k,\qquad \mathbf s_k = \beta_2\mathbf s_{k-1} + (1 - \beta_2)\mathbf g_k^2 \]

    \[ \hat{\mathbf m}_k = \frac{\mathbf m_k}{1 - \beta_1^k},\qquad \hat{\mathbf s}_k = \frac{\mathbf s_k}{1 - \beta_2^k},\qquad \mathbf w_{k+1} = \mathbf w_k - \eta\,\frac{\hat{\mathbf m}_k}{\sqrt{\hat{\mathbf s}_k} + \epsilon} \]

avec les valeurs par défaut \beta_1 = 0.9, \beta_2 = 0.999, \epsilon = 10^{-8}. Le pas effectif est presque indépendant de l’échelle du gradient : il vaut environ \eta dans la direction du signe du gradient moyen.

Théorème (correction du biais). Si les gradients ont une moyenne constante \mathbb E[\mathbf g_i] = \mathbf g et \mathbf m_0 = 0, alors \mathbb E[\mathbf m_k] = (1 - \beta_1^k)\,\mathbf g ; donc \hat{\mathbf m}_k a exactement pour moyenne \mathbf g.

Démonstration. En déroulant la récurrence, \mathbf m_k = (1 - \beta_1)\sum_{i=1}^k\beta_1^{k-i}\mathbf g_i. En prenant la moyenne, \mathbb E[\mathbf m_k] = (1 - \beta_1)\,\mathbf g\sum_{j=0}^{k-1}\beta_1^j = (1 - \beta_1)\frac{1 - \beta_1^k}{1 - \beta_1}\mathbf g = (1 - \beta_1^k)\,\mathbf g. Il en va de même pour \mathbf s_k avec \beta_2. ∎

Sans correction, dans les premiers pas, \mathbf m et \mathbf s seraient très proches de zéro (ils partent de zéro) et, surtout avec \beta_2 = 0.999, le dénominateur serait sous-estimé : les premiers pas seraient énormes. Après quelques milliers de pas, \beta^k \approx 0 et la correction n’a plus d’importance. AdamW (2017) sépare la pénalité sur les poids (weight decay) du pas adaptatif, et c’est aujourd’hui le choix par défaut pour les transformers.

Le pas dans le temps

Un grand pas constant avance vite mais, à la fin, « danse » autour du minimum ; un petit pas est précis mais lent. C’est pourquoi on fait varier le pas pendant l’entraînement :

  • démarrage progressif (warm-up) : pendant quelques centaines ou milliers de pas, le pas croît de zéro à sa pleine valeur, tandis que les estimations d’Adam se stabilisent et que le réseau quitte la phase initiale chaotique ;
  • décroissance : linéaire, par paliers, ou cosinus (le pas suit une demi-période de cosinus jusqu’à presque zéro). On l’a vue aussi dans le PPO du cours d’apprentissage par renforcement : le pas qui décroît jusqu’à zéro a stabilisé la politique finale.

La comparaison sur la fonction de Rosenbrock

La fonction f(x, y) = (1 - x)^2 + 100(y - x^2)^2 a son minimum en (1, 1) au fond d’une vallée étroite, courbe, en forme de banane : au fond de la vallée, le gradient est presque nul, sur les parois énorme. En partant de (−1,5 ; 2), on compte combien de pas sont nécessaires pour atteindre f \lt  10^{-6} :

méthodepas \etapas pour f \lt  10^{-6}
descente de gradient0.00115 681
momentum (\beta = 0.9)0.0011 484
Adam0.022 286
Les trajectoires des trois méthodes sur la fonction de Rosenbrock
Les courbes de niveau grises dessinent la vallée en banane ; l’étoile est le minimum en (1, 1). Les trois trajectoires, descente de gradient en noir pointillé, momentum en bleu et Adam en orange, vont droit au fond de la vallée puis la suivent jusqu’au minimum, le point noir étant le départ. Le chemin est presque le même : ce qui change, c’est le nombre de pas pour le parcourir, près de 16 mille pour la descente de gradient, moins de 1500 pour le momentum.

Le momentum est environ dix fois plus rapide que la descente simple (15 681 / 1 484 = 10,6), comme le prédit le facteur 1/(1 - \beta) = 10. Adam, avec un pas qui ne dépend pas de l’échelle du gradient, arrive en un nombre de pas semblable. Sur de vrais réseaux de neurones, les différences sont souvent moins nettes et dépendent du problème : la SGD avec momentum est encore très utilisée pour les réseaux convolutifs, Adam et AdamW pour les transformers et les réseaux récurrents. Le choix du pas compte presque toujours plus que le choix de l’optimiseur.

import numpy as np

f = lambda p: (1 - p[0]) ** 2 + 100 * (p[1] - p[0] ** 2) ** 2
grad = lambda p: np.array([-2 * (1 - p[0]) - 400 * p[0] * (p[1] - p[0] ** 2), 200 * (p[1] - p[0] ** 2)])

def optimise(method, eta, steps=20000):
    p, v, m, s = np.array([-1.5, 2.0]), np.zeros(2), np.zeros(2), np.zeros(2)
    for k in range(1, steps + 1):
        g = grad(p)
        if method == "gradient":
            p = p - eta * g
        elif method == "momentum":
            v = 0.9 * v + g
            p = p - eta * v
        else:                                              # Adam
            m = 0.9 * m + 0.1 * g
            s = 0.999 * s + 0.001 * g * g
            m_hat, s_hat = m / (1 - 0.9 ** k), s / (1 - 0.999 ** k)     # bias correction
            p = p - eta * m_hat / (np.sqrt(s_hat) + 1e-8)
        if f(p) < 1e-6:
            return k
    return None

for method, eta in (("gradient", 1e-3), ("momentum", 1e-3), ("adam", 2e-2)):
    print(f"{method:9s}: f < 1e-6 after {optimise(method, eta)} steps")
S’abonner
Notifier de
guest
1 commentaire
Le plus ancien
Plus récent Les plus votés
1
0
Vous avez apprécié cet article ? Merci de laisser un commentaire.x