La descente de gradient

Ce que vous saurez faire

Réduisez la perte d’un réseau en modifiant ses poids par petits pas, chacun vers le bas. Tous les réseaux de ce cours apprennent ainsi, d’un seul poids aux 183 685 poids du routeur de billets.

Carnet JupyterFaites cette leçon dans un carnet JupyterColab · Kaggle · GitHub · en anglais

Le carnet (notebook) Jupyter contient chaque cellule de code, tâche et vérification de cette leçon. Il construit le réseau à quatre billets de soutien en Python pur. Il mesure la pente par de petites variations et exécute la descente de gradient à la main. Ensuite, il ajoute un deuxième paramètre et exécute cinq pas sur le vrai réseau de billets. Environ 25 minutes.

Ouvrir dans ColabOuvrir dans KaggleVoir sur GitHub

Le carnet est en anglais. Colab et Kaggle ouvrent votre propre copie. Il faut un compte Google ou Kaggle gratuit. Vous êtes bloqué ? Consultez le carnet de solution.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 50 minutes

Ce que vous devez savoir

• La perte, −ln p de la bonne équipe, et pourquoi l’entraînement l’utilise, dans La perte : à quel point le réseau se trompe-t-il?
• La pente d’une courbe de perte et la règle de mise à jour, dans Perte et gradients, du cours de mathématiques. Cette leçon rappelle les deux en deux phrases.
• La fonction logistique (appelée ici sigmoïde), dans Comprendre la classification, du cours d’apprentissage automatique.

Ce qu’il vous faut sur votre ordinateur

• Rien pour travailler dans le carnet ou utiliser les outils interactifs de cette page.
• Pour travailler en local : PyTorch et le dossier ticket-router, dans Installer PyTorch. L’exemple à quatre billets utilise seulement Python pur.

Testé avec Python 3.12 et PyTorch 2.14.1 sur un processeur.

Descendre une colline dans le brouillard

Vous êtes sur le flanc d’une colline dans un brouillard épais. Vous voulez atteindre le fond de la vallée. Vous ne voyez pas la vallée. Mais vous sentez le sol sous vos pieds : il descend vers la gauche ou vers la droite. Vous faites donc un pas vers le bas, sentez de nouveau le sol, puis faites un autre pas. Là où la pente est forte, vous faites un grand pas; là où elle est presque nulle, un petit. Quand le sol est plat dans toutes les directions, vous êtes au fond.

Le problème : 183 685 nombres aléatoires

Le réseau de billets non entraîné possède 183 685 paramètres : ses poids et ses biais, tous initialisés à de petits nombres aléatoires. Sa perte de validation est de 1,624, la perte d’une prédiction qui donne la même probabilité à chaque équipe. L’entraînement doit trouver de meilleures valeurs pour tous ces paramètres. Mais dans quel sens chacun doit-il changer, et de combien?

Une idée consiste à essayer des valeurs et à garder les meilleures. Calculez ce que cela coûte. Si chaque paramètre ne peut prendre que 100 valeurs, un paramètre exige 100 essais. Deux paramètres exigent 100 × 100 = 10 000 essais. Le réseau exige 100^{183 685} essais : un nombre de 367 371 chiffres. Aucun ordinateur ne peut faire cela, aujourd’hui ou à l’avenir. L’entraînement doit utiliser le sol sous ses pieds : la pente.

L’idée : avancer contre la pente

Le cours de mathématiques présentait les deux éléments. La pente de la perte indique combien la perte change quand un paramètre augmente un peu. La règle de mise à jour modifie le paramètre contre sa pente : nouvelle valeur = valeur − taux d’apprentissage × pente. (Perte et gradients donne les détails, avec un modèle à un paramètre des temps de traitement.)

Pour un réseau, la liste de toutes les pentes, une par paramètre, forme le gradient. Répéter la règle de mise à jour jusqu’à ce que la perte cesse de diminuer s’appelle la descente de gradient. On dit « descente » parce que chaque pas fait baisser la perte. Le taux d’apprentissage est le nombre qui fixe la taille de chaque pas. C’est un réglage que vous choisissez; le réseau ne l’apprend pas.

Un réseau avec un seul poids

Commencez avec le plus petit réseau possible : un neurone, une entrée, quatre billets inventés. Le neurone répond à une question : « Ce billet est-il pour l’équipe des paiements? » Son entrée x est le nombre de fois où le billet contient le mot « remboursement ».

Billet	Texte	x	Paiement?
A	Mon colis n’est pas encore arrivé.	0	non (livraison)
B	Vous avez confirmé mon remboursement, mais l’argent n’est pas sur ma carte.	1	oui
C	Vous avez confirmé mon remboursement il y a deux semaines. Où est le remboursement?	2	oui
D	J’ai renvoyé la lampe. Puis-je obtenir un remboursement, ou n’y a-t-il aucun remboursement sur les articles en solde?	2	non (retours)

Le billet D est le cas difficile. Il contient « remboursement » deux fois, mais va aux retours, car le magasin n’a pas encore confirmé le retour. Les règles de routage de Grace le précisent. Donc, « plus de mentions de remboursement signifie paiement » n’est qu’en partie vrai. Le meilleur poids est un compromis.

Le neurone calcule p = sigmoid(w·x + b), la probabilité de paiement. Le biais b reste à −1 pour l’instant. Le réseau n’a donc qu’un paramètre à apprendre : le poids w. La perte est l’entropie croisée de la dernière leçon, moyennée sur les quatre billets.

À w = 0, chaque billet obtient w·x + b = −1, donc p = sigmoid(−1) = 0,269. Les billets B et C concernent les paiements, donc chacun coûte −ln 0,269 = 1,313. Les billets A et D ne concernent pas les paiements. Pour eux, la bonne réponse est « pas un paiement », dont la probabilité est 1 − p. Chacun coûte donc −ln(1 − 0,269) = 0,313. La moyenne est (0,313 + 1,313 + 1,313 + 0,313) ÷ 4 = 0,813.

La pente, par de petites variations

Comment la perte change-t-elle quand w augmente un peu? Faites varier w très légèrement de chaque côté, puis comparez. Priya écrit la perte en Python pur, pour rendre chaque nombre visible :

one_weight.py

import math

refunds = [0, 1, 2, 2]      # how many times each ticket says "refund"
is_payment = [0, 1, 1, 0]   # 1 = the payment team, 0 = another team

def loss(w, b=-1.0):
    """The mean loss of the one-neuron network on the four tickets."""
    total = 0.0
    for x, y in zip(refunds, is_payment):
        p = 1 / (1 + math.exp(-(w * x + b)))       # the neuron: sigmoid(w·x + b)
        total += -math.log(p) if y == 1 else -math.log(1 - p)
    return total / len(refunds)

def slope(w, nudge=1e-6):
    """The slope of the loss at w: nudge w both ways and compare."""
    return (loss(w + nudge) - loss(w - nudge)) / (2 * nudge)

print("slope at w = 0:", round(slope(0), 4))
print("slope at w = 2:", round(slope(2), 4))

La sortie :

slope at w = 0: -0.4138
slope at w = 2: 0.3853

À w = 0, la pente est négative : la perte diminue quand w augmente, donc la descente va vers la droite. À w = 2, la pente est positive, donc la descente va vers la gauche. Dans les deux cas, le pas va contre la pente.

Trois pas à la main

Appliquez maintenant la règle de mise à jour, avec un taux d’apprentissage de 1, à partir de w = 0 :

Pas	w	Perte	Pente	Déplacement = −1 × pente
0	0.000	0.813	−0.414	+0.414
1	0.414	0.684	−0.204	+0.204
2	0.617	0.654	−0.090	+0.090
3	0.708	0.648	−0.041

Chaque pas descend, et chaque pas est plus petit que le précédent, sans changement du taux d’apprentissage. Les pas diminuent parce que la pente devient plus faible près du fond. La perte minimale de cette courbe est de 0,6465, à w ≈ 0,78. Dans l’outil interactif ci-dessous, chaque pas est une vraie mise à jour PyTorch du même réseau. Ses pentes sont exactes. Les pentes mesurées ci-dessus par de petites variations correspondent à celles-ci à quatre décimales près.

Explorer

Descente de gradient sur un poids

Étape

3

Poids w

0,708

Perte

0,648

Pente

−0,041

Prochain pas = −taux × pente

+0,041

Descente. Chaque pas est plus petit que le précédent, car la pente diminue près du fond.

La perte du réseau à un neurone sur les quatre billets, pour chaque valeur de son poids w. Le biais reste à −1. Chaque pas est une vraie mise à jour PyTorch : w ← w − taux d'apprentissage × pente. La fine ligne noire à la boule montre la pente; la ligne pointillée marque le point le plus bas.

Description textuelle de l’explorateur

L’outil interactif montre la courbe de perte d’un poids w, de −1,5 à 6. La courbe forme une vallée : la perte est de 1,38 à w = −1 et de 0,813 à w = 0. Elle atteint son minimum (0,6465) vers w = 0,78, puis vaut 0,93 à w = 2 et 1,36 à w = 3. Le taux d’apprentissage peut être de 0,1, 0,3, 1, 3 ou 10. Chaque pas modifie w de −taux d’apprentissage × pente, à partir de w = 0.

Avec 0,1, les pas sont minuscules : w vaut 0,04, 0,08, 0,12 après trois pas. Après 30 pas, la perte reste au-dessus du minimum. Avec 0,3, w atteint 0,32 après trois pas. Avec 1 : 0,414, 0,617, 0,708, puis 0,748, 0,767… La perte est de 0,6466 après cinq pas. Avec 3, w dépasse le fond, puis revient : 1,242, 0,626, 0,882, 0,732, 0,815… Un zigzag qui se stabilise. Avec 10, le premier pas saute à w = 4,14 et la perte monte de 0,813 à 1,908. Ensuite, w saute à −0,75, 5,62, 0,65, 1,39, −1,15, et ainsi de suite. La perte oscille entre 0,65 et 2,7 et ne se stabilise jamais.

Le taux d’apprentissage : trop petit, bon, trop grand

L’outil interactif montre les trois types de taux d’apprentissage. Trop petit (0,1) : chaque pas descend, mais les pas sont si petits que 30 pas n’atteignent pas le fond. Bon (1) : quelques pas atteignent le fond. Trop grand (10) : le premier pas dépasse largement le fond. Il atteint un point où la perte est plus élevée qu’au départ, et les pas ne se stabilisent jamais. Entre les deux (3), les pas dépassent le fond, puis reviennent. Mais les sauts diminuent, donc l’exécution se stabilise quand même.

Le comportement de l’optimisation, dans le cours de mathématiques, montre les trois mêmes cas sur une autre courbe. Taux d’apprentissage et optimiseurs les montre sur le vrai réseau de billets et explique comment choisir un taux.

Deux paramètres : le poids et le biais

Laissez maintenant le biais b apprendre aussi. La perte dépend désormais de deux nombres : c’est donc un paysage, pas une courbe. Une carte de courbes de niveau le représente d’en haut, comme une carte de randonnée. Chaque ligne relie les points qui ont la même perte. La descente de gradient fonctionne de la même façon. Chaque paramètre a sa propre pente : faites varier l’un légèrement, en gardant l’autre fixe. Chaque pas modifie les deux paramètres en même temps.

Explorer

Descente de gradient sur deux paramètres

Étape

3

Poids w

−0,4

Biais b

0,908

Perte

0,777

Pentes (w; b)

−0,067; 0,098

Descente, mais lente : avec ce taux d’apprentissage, chaque pas est petit.

La perte du réseau à un neurone selon son poids w et son biais b, sur une carte de courbes de niveau. Chaque ligne relie les points qui ont la même perte. La croix marque le point le plus bas. Chaque pas est une vraie mise à jour PyTorch des deux paramètres, à partir de w = −1, b = 1.

Description textuelle de l’explorateur

La carte montre w de −1,5 à 3 à l’horizontale et b de −3,5 à 1,5 à la verticale. Les courbes de niveau forment de longs ovales autour du point le plus bas, à w = 0,77 et b = −0,97 (perte de 0,6465). Les ovales sont inclinés : la vallée va donc du coin supérieur gauche au coin inférieur droit. Le départ est à w = −1, b = 1, avec une perte de 0,908.

Avec un taux d’apprentissage de 1, le trajet descend d’abord le côté abrupt, puis tourne et suit le fond de la vallée. La perte est de 0,666 après 20 pas, de 0,649 après 40 et de 0,647 après 60. À ce stade, w = 0,71 et b = −0,87. C’est près de la croix, mais pas dessus, car le fond de la vallée est presque plat. Avec 0,3, le trajet a la même forme, mais avance plus lentement : après 60 pas, la perte est encore de 0,671. Avec 3, le trajet zigzague à travers la vallée; la perte est de 0,687 après 60 pas. Avec 10, les pas sautent à travers toute la carte, la perte atteint 4,2 et le trajet ne se stabilise pas.

Le trajet descend d’abord tout droit sur le côté abrupt, perpendiculairement aux courbes de niveau : c’est la descente la plus raide. Puis il tourne et suit le fond de la vallée, où la pente est faible. Les pas sont donc petits aussi. Après 60 pas, la perte est de 0,647, proche du minimum de 0,6465, mais ne l’atteint pas. Une longue vallée plate comme celle-ci est courante dans les vrais réseaux. C’est une raison pour laquelle les réseaux du cours utilisent un meilleur optimiseur que la simple descente de gradient. Ils le font à partir de La boucle d’entraînement.

Le réseau de billets : tous les poids à la fois

Le réseau de billets fonctionne de la même façon, avec 183 685 paramètres au lieu de deux. Son gradient est une liste de 183 685 pentes. Chaque pas modifie chaque paramètre contre sa propre pente. Priya exécute 30 pas de simple descente de gradient avec un taux d’apprentissage de 0,5 sur les 4 696 billets d’entraînement. Le code utilise un outil PyTorch de la prochaine leçon, qui calcule toutes les pentes à la fois. Vous écrirez cette boucle vous-même dans La boucle d’entraînement.

Simple descente de gradient sur les 183 685 paramètres du réseau de billets, avec un taux d'apprentissage de 0,5. Tous les billets d'entraînement sont utilisés à chaque pas. Exécution réelle, PyTorch 2.14.1 sur un processeur.

Description textuelle du graphique

La perte commence à 1,624 et diminue à chaque pas pendant 27 pas : 1,599, 1,578, 1,558, 1,538 aux premiers pas. Elle diminue plus vite au milieu (1,389 au pas 10, 0,967 au pas 20), jusqu’à 0,708 au pas 27. Puis elle remonte brusquement : 0,793 au pas 28 et 1,143 au pas 29.

La perte diminue à chaque pas pendant 27 pas, de 1,624 à 0,708. Puis elle remonte brusquement, à 1,143. Près de ce point, un pas de 0,5 était trop grand pour ce réseau. C’était aussi le cas du taux d’apprentissage de 10 pour les quatre billets. La simple descente de gradient avec un seul taux d’apprentissage pour chaque poids est fragile. Taux d’apprentissage et optimiseurs présente les solutions.

Quand utiliser la descente de gradient, et ce qu’elle coûte

Les réseaux de neurones apprennent toujours avec la descente de gradient ou une de ses variantes. Aucune autre méthode ne convient à des milliers ou des milliards de paramètres. Une fois les pentes obtenues, le coût d’un pas reste à peu près le même, quel que soit le nombre de paramètres.

Ce qu’elle coûte :

• Un taux d’apprentissage à choisir. Trop petit, il fait perdre du temps; trop grand, il dépasse le fond. Vous en trouvez un bon en essayant quelques valeurs et en comparant les courbes de perte.
• Aucune garantie d’atteindre le point le plus bas. La descente de gradient s’arrête là où le sol est plat. Sur une courbe avec plusieurs vallées, cela peut être une vallée plus haute, un minimum local. Le cours de mathématiques en montre un. Pour les grands réseaux, cela compte moins que vous pourriez le penser. Mais le point de départ et la graine aléatoire modifient un peu le résultat.
• Les pentes elles-mêmes. Faire varier chaque paramètre pour mesurer sa pente exige un calcul de perte supplémentaire par paramètre. Cela représente 183 686 calculs pour un pas du réseau de billets. La prochaine leçon montre comment PyTorch obtient plutôt toutes les pentes en une seule propagation arrière.

Exercice guidé : un taux d’apprentissage de 3

1. Dans le premier outil interactif, faites votre prédiction, puis sélectionnez I have made my prediction (j’ai fait ma prédiction).
2. Sélectionnez le taux d’apprentissage 3.
3. Sélectionnez Step (pas) trois fois. Notez w après chaque pas. Vous devriez voir 1,242, 0,626 et 0,882.
4. Regardez la pente après chaque pas. Notez son signe : + ou −.
5. Expliquez en une phrase pourquoi les pas vont à droite, à gauche, puis à droite.

Afficher un exemple de réponse

Les pentes après les trois pas sont +0,205, −0,085 et +0,050 : le signe change à chaque pas. Chaque pas est si grand qu’il dépasse le fond (w ≈ 0,78). La pente de l’autre côté pointe donc vers l’arrière. Les sauts diminuent chaque fois, parce que la pente près du fond est faible. Cette exécution se stabilise donc quand même : w vaut 0,767 après six pas.

À vous de jouer : partir de l’autre côté

Partez de w = 2 au lieu de 0, avec un taux d’apprentissage de 1. La pente à w = 2 est de +0,385 (d’après le code ci-dessus). Faites d’abord une prédiction : w augmente-t-il ou diminue-t-il? Puis calculez un pas à la main et vérifiez la perte après ce pas avec loss(...) dans le carnet.

Afficher la réponse

La pente est positive, donc w diminue : nouveau w = 2 − 1 × 0,385 = 1,615. La perte diminue de 0,931 à w = 2 à 0,795 à w = 1,615. La règle fonctionne des deux côtés. Le signe de la pente pointe toujours vers le haut, et le pas va dans l’autre sens.

Erreur courante

Un pas vers le haut

Symptôme : Tomás écrit la règle de mise à jour ainsi : w = w + rate * slope(w). La perte augmente à chaque pas : 0,813, 1,018, 1,369, 1,837. Un taux d’apprentissage plus petit la fait augmenter plus lentement, mais elle augmente quand même.

Cause : un signe plus fait avancer avec la pente, donc chaque pas monte. La pente pointe dans la direction où la perte augmente.

Solution : soustrayez : w = w - rate * slope(w). Dans PyTorch, les optimiseurs de La boucle d’entraînement font la soustraction pour vous, ce qui élimine cette erreur.

Ce que cela signifie pour un vrai service d’IA : une perte qui augmente régulièrement dès le premier pas indique un bogue, pas de la malchance. Vérifiez la mise à jour avant de changer les données ou le réseau.

Vérification des connaissances

Vérifiez votre compréhension

Dans vos mots : que fait une étape de descente de gradient, et qu'est-ce qui détermine sa taille?

Afficher la réponse

Elle mesure la pente de la perte pour chaque paramètre, puis déplace chaque paramètre dans le sens opposé à sa pente : nouvelle valeur = valeur − taux d’apprentissage × pente. La taille du pas correspond au taux d’apprentissage multiplié par la pente. Une pente forte donne donc un grand pas, et une pente faible, un petit pas. Le taux d’apprentissage, que vous choisissez, ajuste la taille de tous les pas.

Vérifiez votre compréhension

Prédisez : à w = 1,5, la pente de la perte pour les quatre billets est de +0,286. Avec un taux d'apprentissage de 1, quelle est la prochaine valeur de w? Et avec un taux de 10?

Afficher la réponse

Avec un taux d’apprentissage de 1, le pas est de −1 × 0,286 = −0,286. La prochaine valeur de w est donc 1,214. Elle est plus près du fond, situé vers 0,78, et la perte passe de 0,760 à 0,691. Avec un taux d’apprentissage de 10, le pas est de −2,86. La prochaine valeur de w est donc −1,36. Elle dépasse largement le fond, de l’autre côté, où la perte est d’environ 1,6 : plus élevée qu’au départ. Voilà ce que fait un taux d’apprentissage trop élevé.

Vérifiez votre compréhension

Tomás dit : « Pourquoi utiliser les pentes? On pourrait essayer chaque valeur pour chaque poids et garder la meilleure. » Que lui répondez-vous?

Afficher la réponse

Comptez les essais. Avec seulement 100 valeurs par paramètre, deux paramètres exigent 10 000 essais. Les 183 685 paramètres du réseau de billets exigent 100 à la puissance 183 685 : un nombre de 367 371 chiffres. Aucun ordinateur ne peut faire cela. La descente de gradient utilise seulement les pentes au point actuel. Une seule étape déplace tous les paramètres à la fois.

Récapitulatif

• La descente de gradient modifie chaque paramètre dans le sens opposé à sa pente : nouvelle valeur = valeur − taux d’apprentissage × pente. Le gradient est la liste de toutes les pentes.
• Les pas diminuent d’eux-mêmes près du fond, car la pente devient plus faible.
• Un taux d’apprentissage trop faible ralentit la progression. Un taux trop élevé fait dépasser le fond. La perte peut alors devenir plus élevée qu’au départ (0,813 → 1,908 pour les quatre billets).
• Avec deux paramètres, la perte forme un paysage. La descente de gradient suit la pente la plus forte, puis le fond de la vallée.
• Dans le réseau de billets, une étape déplace les 183 685 paramètres. La descente de gradient simple avec un taux de 0,5 a réduit la perte de 1,624 à 0,708 en 27 étapes. Ensuite, la perte a bondi.

À suivre : comment PyTorch trouve les 183 685 pentes à la fois, sans modifier légèrement chaque poids.

Leçon suivante : La rétropropagation et autograd