Descente de gradient : apprendre à petits pas

Dans la leçon précédente, une formule nous a donné la meilleure droite d’un seul coup. Mais un réseau de neurones à plusieurs millions de poids n’a pas de telle formule. Comment un ordinateur peut-il trouver de bonnes valeurs pour des millions de boutons de réglage quand personne ne peut lui dire où se trouve le meilleur réglage ? La réponse est d’une simplicité presque gênante : il sent de quel côté ça descend et fait un petit pas. Puis il recommence.

À vous de jouer

• Choisissez un petit taux d’apprentissage et cliquez quelques fois sur Pas. Regardez la droite bouger un peu à chaque pas et la courbe de perte descendre lentement.
• Cliquez sur Lancer et laissez tourner. La droite finit-elle près de la droite des moindres carrés de la leçon précédente ?
• Recommencez avec le plus grand taux d’apprentissage et cliquez de nouveau sur « Pas ». Regardez la courbe de perte : au lieu de baisser, elle monte, et la droite oscille dans tous les sens. C’est la divergence.
• Essayez les taux intermédiaires et trouvez le plus grand qui fait encore baisser la perte régulièrement.

L’idée en quelques mots

Voyons maintenant ce que vous venez de manipuler, en termes simples.

Imaginez-vous sur le flanc d’une colline dans un épais brouillard. Vous voulez rejoindre la vallée, mais vous ne voyez qu’à un mètre autour de vous. Une stratégie raisonnable : tâter le sol du pied, trouver la direction où la pente descend le plus fort, faire un pas dans cette direction et recommencer. Vous ne voyez jamais tout le paysage, et pourtant, pas à pas, vous descendez.

En apprentissage automatique, le « paysage » est l’erreur du modèle. Chaque couple possible de pente et d’ordonnée à l’origine est une position sur la carte, et l’altitude à cette position est l’erreur quadratique moyenne de la leçon 3. Le fond de la vallée, c’est la meilleure droite. La descente de gradient est la marche dans le brouillard : partir de quelque part, mesurer dans quelle direction l’erreur diminue, déplacer un peu les paramètres dans cette direction, et recommencer jusqu’à ce que l’erreur cesse de baisser.

Pourquoi ça marche

La direction de plus forte montée d’une fonction est donnée par son gradient – une liste de dérivées, une par paramètre, qui indique de combien l’erreur augmenterait si l’on poussait légèrement ce paramètre vers le haut. Allez dans le sens opposé et l’erreur diminue. Pour chaque paramètre w, un pas s’écrit :

w ← w − η · ∂L/∂w

Ici, L est la perte (l’erreur que l’on minimise), ∂L/∂w indique à quel point la perte réagit à w, et η (la lettre grecque êta) est le taux d’apprentissage, qui fixe la taille du pas. Là où la pente est raide, les pas sont grands ; près du fond, la pente s’adoucit et les pas raccourcissent d’eux-mêmes.

Tout dépend du taux d’apprentissage. S’il est trop petit, chaque pas est minuscule et la marche prend une éternité. S’il est juste, l’erreur baisse vite et se stabilise près du minimum. S’il est trop grand, chaque pas dépasse la vallée et atterrit plus haut sur le versant opposé ; le pas suivant dépasse encore davantage, et l’erreur croît sans limite. C’est ce qu’on appelle la divergence, et c’est la raison la plus courante pour laquelle un entraînement « explose ».

La beauté de la méthode, c’est qu’elle n’a besoin que d’une chose : pouvoir calculer le gradient à la position actuelle. Elle n’a pas besoin d’une formule pour la réponse, et elle fonctionne de la même façon pour deux paramètres que pour deux milliards. C’est pourquoi elle est le moteur de presque tous les réseaux de neurones, y compris les modèles de langage de la leçon 12. En pratique, on estime généralement le gradient sur un petit lot aléatoire d’exemples (mini-batch) plutôt que sur tous, ce qui rend chaque pas moins coûteux et plus bruité, mais fonctionne remarquablement bien.

Erreur fréquente

Quand la perte s’envole soudain ou devient « NaN » (not a number, pas un nombre), les débutants soupçonnent souvent un bug dans leur code. Bien plus souvent, le taux d’apprentissage est tout simplement trop grand. Le remède est de le réduire, pas de réécrire le modèle. L’erreur inverse est moins visible : un taux si petit que la perte baisse encore quand l’entraînement s’arrête, si bien que le modèle paraît moins bon qu’il ne pourrait l’être. Un piège voisin, ce sont des variables à des échelles très différentes – par exemple l’âge en années à côté du revenu en euros –, qui transforment la vallée en un long canyon étroit où aucun taux d’apprentissage unique ne convient à toutes les directions. Normaliser les variables d’abord rend la marche bien plus facile.

Nous avons maintenant les deux moitiés de la recette d’apprentissage : une note et un moyen de l’améliorer. Dans la prochaine leçon, nous les utilisons pour un nouveau type de question – non plus « combien ? », mais « lequel ? ».

import numpy as np
from sklearn.datasets import load_diabetes

X, y = load_diabetes(return_X_y=True, as_frame=True, scaled=False)
bmi = X["bmi"].to_numpy()
z = (bmi - bmi.mean()) / bmi.std()  # IMC standardisé, comme dans le lab
mse = lambda w, b: np.mean((y - (b + w * z)) ** 2)
for lr in [0.01, 0.1, 0.8, 1.1]:
    w, b = 0.0, 0.0  # départ à l'origine
    for _ in range(5):  # cinq pas en batch complet
        r = y - (b + w * z)
        w, b = w + lr * 2 * np.mean(r * z), b + lr * 2 * np.mean(r)
    print(f"lr {lr}: loss after 5 steps {mse(w, b):.0f}")
w_best, b_best = np.polyfit(z, y, 1)
print(f"minimum: {mse(w_best, b_best):.0f}")

lr 0.01: loss after 5 steps 24468
lr 0.1: loss after 5 steps 6595
lr 0.8: loss after 5 steps 4043
lr 1.1: loss after 5 steps 159823
minimum: 3890