Optimiseurs de réseaux de neurones : SGD, Momentum et Adam en Python

Le concept en termes simples

Un optimiseur est la règle qui transforme les gradients en mises à jour des poids. La descente de gradient simple n'utilise que le gradient actuel ; le momentum se souvient des directions passées, et Adam adapte en plus la taille du pas pour chaque poids.

Comparez la descente de gradient simple, le momentum et Adam en minimisant pas à pas la même fonction.

Idées clés

Le momentum garde une vitesse, ce qui lui permet de traverser les zones plates et les petites bosses.
Adam tient des moyennes mobiles du gradient et du gradient au carré.
La correction du biais (division par 1 − βᵗ) corrige ces moyennes lors des premiers pas.
Une bonne initialisation des poids et les mini-lots rendent aussi l'entraînement plus rapide et plus stable.

Quand l’utiliser ?

Comprendre ce qui se passe à l'intérieur des réseaux de neurones et des bibliothèques d'IA.
Apprendre l'idée avant de l'implémenter dans les défis correspondants.
Se préparer aux cours d'apprentissage automatique, aux entretiens et aux projets.

À vous de jouer

Appuyez sur Lecture pour faire courir trois optimiseurs dans la même vallée accidentée. Essayez un taux d'apprentissage plus grand pour voir le momentum dépasser la cible.

Code d’exemple

Exécuter le code →

main.py

import math

# Minimise f(x) = (x - 3)² with three optimizers. The gradient is 2(x - 3).
grad = lambda x: 2 * (x - 3)

def sgd(steps, lr=0.1):
    x = 0.0
    for _ in range(steps):
        x -= lr * grad(x)
    return x

def momentum(steps, lr=0.1, beta=0.9):
    x, v = 0.0, 0.0
    for _ in range(steps):
        v = beta * v + grad(x)        # remember the direction we were going
        x -= lr * v
    return x

def adam(steps, lr=0.3, b1=0.9, b2=0.999, eps=1e-8):
    x, m, v = 0.0, 0.0, 0.0
    for t in range(1, steps + 1):
        g = grad(x)
        m = b1 * m + (1 - b1) * g     # running mean of gradients
        v = b2 * v + (1 - b2) * g * g # running mean of squared gradients
        m_hat, v_hat = m / (1 - b1 ** t), v / (1 - b2 ** t)
        x -= lr * m_hat / (math.sqrt(v_hat) + eps)
    return x

for steps in (5, 20, 50):
    print(f"{steps:>2} steps  sgd={sgd(steps):.3f}  momentum={momentum(steps):.3f}  adam={adam(steps):.3f}")

Résultat attendu

5 steps  sgd=2.017  momentum=4.741  adam=1.476
20 steps  sgd=2.965  momentum=4.048  adam=3.813
50 steps  sgd=3.000  momentum=3.091  adam=3.014

Fonctionnement

Les trois minimisent (x − 3)², dont le point le plus bas est x = 3. SGD avance régulièrement, le momentum prend de la vitesse et dépasse la cible avant de se stabiliser, et Adam ajuste chaque pas avec des moyennes mobiles du gradient et de son carré. Après 50 pas, les trois sont proches de 3.

Modifiez les valeurs et exécutez le programme avec le compilateur Python en ligne CodeUtility, sans installation locale.

Exercices pratiques

Modifiez les entrées et testez les cas limites avant d’utiliser des données plus volumineuses.

Modifiez les entrées ou les poids et prédisez la sortie avant d'exécuter.
Affichez les valeurs intermédiaires pour suivre chaque étape du calcul.
Résolvez les défis liés ci-dessous pour implémenter l'idée vous-même.

Exécuter dans l’IDE Python →

S'entraîner avec un défi

Utilisez le contenu de cette leçon pour résoudre un vrai problème. Chaque défi s'exécute dans le navigateur, avec des tests instantanés et une revue par l'IA.

Tous les défis