Taux d'apprentissage et optimiseurs

Ce que vous saurez faire

Lisez une courbe d’entraînement et dites si le taux d’apprentissage est trop petit, trop grand ou à peu près correct. Vous éviterez ainsi de perdre un après-midi sur un entraînement qui ne peut pas fonctionner. Choisissez ensuite un optimiseur pour le routeur de billets de soutien, avec une raison à l’appui. Vérifiez ce choix avec deux entraînements supplémentaires.

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

Le carnet (notebook) Jupyter contient tous les blocs de code, les tâches et les vérifications de cette leçon. Il entraîne le routeur à sac de mots avec cinq taux d’apprentissage et trois optimiseurs, puis trace les courbes. Ses cellules de préparation téléchargent les billets et le fichier ticketnet.py du cours. Aucune installation locale n’est donc nécessaire. Comptez environ 30 minutes; les entraînements prennent environ 1 minute sur un processeur gratuit de Colab.

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, et pourquoi un routeur non entraîné a une perte proche de ln 5 = 1,609, dans La perte : à quel point le réseau se trompe-t-il?.
• La descente de gradient : un pas vaut le taux d’apprentissage multiplié par la pente, dans La descente de gradient.
• Les cinq étapes de la boucle d’entraînement et la fonction train() du cours, dans La boucle d’entraînement.
• Les mini-lots, les époques et les courbes d’entraînement et de validation, dans Lots, époques et validation.

Ce qu’il vous faut sur votre ordinateur (seulement pour travailler localement; le carnet n’en a pas besoin)

• Le dossier ticket-router avec data/ et ticketnet.py, et son environnement virtuel avec PyTorch, dans Installer PyTorch. Si python -c "import torch" échoue, activez de nouveau l’environnement. Si un fichier de données manque ou a changé, supprimez le dossier data et téléchargez-le de nouveau comme dans cette leçon.

Tous les nombres de cette page proviennent d’entraînements réels, avec PyTorch 2.14.1 sur un processeur.

Descendre une colline avec des pas différents

Vous êtes sur une colline dans un brouillard épais et vous voulez atteindre le fond de la vallée. Vous ne voyez pas la vallée. Vous pouvez seulement sentir dans quelle direction le sol descend sous vos pieds. C’était la descente de gradient dans La descente de gradient. Cette leçon porte sur une question que l’histoire du brouillard laissait ouverte : quelle est la longueur de chaque pas?

Avec de minuscules pas, vous descendez toujours, mais la nuit arrive avant vous. Avec d’immenses bonds, vous dépassez le fond de la vallée et atterrissez haut sur l’autre versant. Le bond suivant vous ramène de l’autre côté, peut-être encore plus haut. Seule une longueur de pas intermédiaire vous permet de descendre vite et sans danger.

Le problème : le même réseau, cinq résultats différents

Priya entraîne cinq fois le routeur à sac de mots du module 3. Tout reste pareil : les billets, le réseau, les poids de départ (graine 0) et les 15 époques. Seul le taux d’apprentissage change. Elle utilise la descente de gradient simple sur des mini-lots, soit l’optimiseur "sgd" de train().

Elle charge d’abord les billets et les transforme en tenseurs de sacs de mots, comme dans le module 3 :

learning_rates.py

import torch
from torch import nn
from ticketnet import *       # the course's code: Vocab, bag_of_words, BagOfWordsNet, train() ...

train_rows, valid_rows = load_split("data/train.csv"), load_split("data/valid.csv")
vocab = Vocab([r["text"] for r in train_rows])          # words from the training tickets only
x_train, x_valid = bag_of_words(train_rows, vocab), bag_of_words(valid_rows, vocab)
y_train, y_valid = labels(train_rows), labels(valid_rows)
print("x_train", tuple(x_train.shape), " x_valid", tuple(x_valid.shape))

La sortie :

x_train (4696, 2864)  x_valid (600, 2864)

Puis viennent les cinq entraînements. set_seed(0) avant chaque réseau donne les mêmes poids de départ à chaque entraînement. Le taux d’apprentissage est donc la seule différence.

learning_rates.py

runs = {}
for learning_rate in [0.00001, 0.001, 0.1, 1, 10]:
    set_seed(0)                                      # the same starting weights for every run
    model = BagOfWordsNet(len(vocab))
    runs[learning_rate] = train(model, x_train, y_train, x_valid, y_valid, epochs=15,
                                lr=learning_rate, optimizer="sgd", log=None)
    first, last = runs[learning_rate][0], runs[learning_rate][-1]
    print(f"lr {learning_rate:<6g} train loss {first['train_loss']:.3f} -> {last['train_loss']:.3f}"
          f"   valid accuracy {last['valid_acc']:.1%}")

La sortie :

lr 1e-05  train loss 1.624 -> 1.623   valid accuracy 18.3%
lr 0.001  train loss 1.619 -> 1.569   valid accuracy 39.7%
lr 0.1    train loss 1.188 -> 0.097   valid accuracy 98.0%
lr 1      train loss 1.051 -> 0.024   valid accuracy 97.8%
lr 10     train loss 1.579 -> 2.509   valid accuracy 27.5%

Les résultats vont de 18,3 % à 98,0 % de bonnes réponses. Rien n’a planté, et aucune ligne n’a affiché d’erreur. Avec 0,00001, la perte reste à 1,623, près de ln 5 : le routeur devine encore. Avec 10, la perte finit plus haut qu’au départ, et le routeur donne 27,5 % de bonnes réponses. C’est exactement la proportion de billets delivery (livraison) dans les données de validation. Il répond donc probablement delivery pour presque tous les billets. Un mauvais taux d’apprentissage est un échec silencieux. Seuls les nombres le révèlent; vous devez donc apprendre à les lire.

L’idée : la longueur du pas détermine le trajet

Dans le module 3, vous avez vu la règle d’un pas. Le nouveau poids vaut l’ancien poids moins le taux d’apprentissage multiplié par la pente. La pente indique la direction de la descente. Le taux d’apprentissage indique la distance à parcourir. Vous choisissez ce nombre avant l’entraînement; le réseau ne l’apprend pas. On l’appelle un taux parce qu’il ajuste la taille de chaque pas demandé par la pente.

Prenez le plus petit exemple possible : un poids w et la perte w × w. Le fond de la vallée se trouve à w = 0. À chaque point, la pente de w × w vaut 2 × w. Partez de w = 3 et faites quatre pas avec quatre taux d’apprentissage :

tiny_descent.py

def descend(learning_rate, w=3.0, steps=4):
    """Walk downhill on the loss w * w, starting at w = 3."""
    path = [w]
    for _ in range(steps):
        slope = 2 * w                     # the slope of w * w at this w
        w = w - learning_rate * slope     # one step: learning rate x slope
        path.append(round(w, 3))
    return path

for learning_rate in [0.1, 0.4, 0.9, 1.1]:
    print(f"learning rate {learning_rate}: w = {descend(learning_rate)}")

La sortie :

learning rate 0.1: w = [3.0, 2.4, 1.92, 1.536, 1.229]
learning rate 0.4: w = [3.0, 0.6, 0.12, 0.024, 0.005]
learning rate 0.9: w = [3.0, -2.4, 1.92, -1.536, 1.229]
learning rate 1.1: w = [3.0, -3.6, 4.32, -5.184, 6.221]

Vérifiez le premier pas de chacun à la main. À w = 3, la pente vaut 6. Avec un taux d’apprentissage de 0,1, le pas vaut 0,6; w passe donc à 2,4. Avec 0,4, le pas vaut 2,4; w passe donc à 0,6. Avec 0,9, le pas vaut 5,4 : il dépasse 0 et arrive à −2,4. Avec 1,1, le pas vaut 6,6; w arrive donc à −3,6, plus loin de 0 qu’au départ.

• taux d'apprentissage 0,1
• taux d'apprentissage 0,4
• taux d'apprentissage 0,9
• taux d'apprentissage 1,1

Le poids après chacun des quatre pas sur la perte w × w, à partir de w = 3. Les petits pas approchent lentement de 0; un bon taux y arrive. Un grand taux oscille autour de 0; un taux trop grand s'en éloigne davantage à chaque pas.

Description textuelle du graphique

Un graphique en courbes avec les pas de 0 à 4 à l’horizontale et le poids w à la verticale, de −6 à 7. Les quatre courbes partent de 3. Le taux d’apprentissage 0,1 descend lentement : 2,4, 1,92, 1,536, 1,229. Le taux d’apprentissage 0,4 descend vite : 0,6, 0,12, 0,024, 0,005. Le taux d’apprentissage 0,9 zigzague autour de 0 avec des oscillations qui diminuent : −2,4, 1,92, −1,536, 1,229. Le taux d’apprentissage 1,1 zigzague avec des oscillations qui augmentent : −3,6, 4,32, −5,184, 6,221.

Quatre comportements apparaissent, et vous les verrez tous avec les billets :

• Trop petit (0,1 ici) : chaque pas descend, mais il faut beaucoup de pas pour arriver.
• Bon (0,4) : quelques pas atteignent le fond.
• Instable (0,9) : chaque pas dépasse le fond. Ici, les oscillations diminuent, mais lentement, et le trajet zigzague.
• Trop grand (1,1) : chaque pas dépasse le fond davantage que le précédent; le poids s’éloigne donc du fond. C’est ce qu’on appelle la divergence : l’entraînement s’éloigne d’une solution au lieu de s’en approcher.

Pourquoi 1 est-il la limite pour cette perte? Chaque pas multiplie w par 1 − 2 × taux d’apprentissage. Avec 0,1, ce facteur vaut 0,8; avec 1,1, il vaut −1,2. La grandeur de w augmente donc de 20 % à chaque pas. Un vrai réseau a des milliers de poids et une vallée courbe et bosselée. Personne ne peut donc calculer sa limite ainsi. Vous la trouvez à partir des courbes.

Lire les courbes : trois formes

Revenons aux billets. Les courbes d’entraînement et de validation vous indiquent ce qui a mal tourné, comme les zigzags ci-dessus. Voici trois formes provenant d’entraînements réels du routeur. Apprenez à les reconnaître, car vous les retrouverez dans chaque projet.

• Perte d'entraînement
• Perte de validation

Trop petit, donc le réseau est en sous-apprentissage : SGD avec un taux d'apprentissage de 0,001. Les deux pertes baissent un peu à chaque époque et restent bien au-dessus de zéro.

Description textuelle du graphique

Les deux courbes partent près de 1,62 et descendent en ligne droite, sur une pente douce, jusqu’à 1,569 après 15 époques. Elles se superposent. Le routeur classe correctement 39,7 % des billets de validation.

Sous-apprentissage causé par un taux d’apprentissage trop petit. Les deux pertes se superposent et sont élevées. Le réseau n’a pas encore assez appris. Il ne fait donc pas mieux sur ses billets d’entraînement que sur de nouveaux billets. Le sous-apprentissage signifie que le modèle n’a pas appris le motif présent dans les données. Le cours Apprentissage automatique : du problème à un modèle fiable l’illustrait avec un arbre de décision qui pose une seule question. Ici, le réseau est assez grand. Ce sont les pas qui sont trop courts. Que faire : multipliez le taux d’apprentissage par 10, ou entraînez beaucoup plus longtemps.

• Perte d'entraînement
• Perte de validation

Instable : SGD avec un taux d'apprentissage de 1. La perte baisse vite, puis remonte brusquement, plusieurs fois.

Description textuelle du graphique

Les deux courbes passent d’environ 1,05 à environ 0,15 en trois époques. Elles font ensuite des bonds : environ 0,35 à l’époque 4, environ 0,09 à l’époque 5 et environ 0,25 à l’époque 6. À l’époque 7, elles atteignent 1,43, presque un retour aux réponses au hasard. Puis elles redescendent, avec de plus petits bonds. Elles finissent à 0,024 (entraînement) et 0,087 (validation) à l’époque 15.

Instabilité causée par un taux d’apprentissage trop grand. La perte baisse vite, puis remonte brusquement. Les nombres par époque montrent à quel point un bond peut être mauvais :

for row in runs[1][:8]:                               # SGD with learning rate 1, first 8 epochs
    print(f"epoch {row['epoch']}: train loss {row['train_loss']:.3f}, valid accuracy {row['valid_acc']:.1%}")

La sortie :

epoch 1: train loss 1.051, valid accuracy 50.8%
epoch 2: train loss 0.363, valid accuracy 88.2%
epoch 3: train loss 0.160, valid accuracy 96.2%
epoch 4: train loss 0.323, valid accuracy 85.5%
epoch 5: train loss 0.085, valid accuracy 97.7%
epoch 6: train loss 0.236, valid accuracy 88.8%
epoch 7: train loss 1.433, valid accuracy 28.3%
epoch 8: train loss 0.216, valid accuracy 94.2%

À l’époque 7, le routeur passe de 88,8 % à 28,3 % de bonnes réponses. Une époque plus tard, il revient à 94,2 %. Cet entraînement finit bien, à 97,8 %. Mais si vous aviez arrêté à l’époque 7, vous auriez enregistré un routeur défectueux. Un entraînement comme celui-ci relève de la chance, pas d’un résultat fiable. Que faire : divisez le taux d’apprentissage par un facteur de 3 à 10.

• Perte d'entraînement
• Perte de validation

Surapprentissage : un routeur avec 512 neurones cachés et le taux d'apprentissage par défaut d'Adam, sur 40 époques. La perte d'entraînement descend vers 0; la perte de validation baisse jusqu'à l'époque 7, puis remonte.

Description textuelle du graphique

La perte d’entraînement passe de 0,159 à l’époque 1 à 0,0001 à l’époque 40. La perte de validation passe de 0,144 à son minimum, 0,063, à l’époque 7. Elle monte ensuite lentement et régulièrement jusqu’à 0,106 à l’époque 40. L’écart entre les deux courbes grandit à chaque époque après l’époque 7.

Surapprentissage. La perte d’entraînement continue de baisser, mais la perte de validation change de direction et monte. Les deux courbes s’écartent. Le taux d’apprentissage convient ici : le réseau apprend trop bien ses billets d’entraînement, y compris leurs particularités accidentelles. Vous avez vu ce graphique dans Lots, époques et validation. La prochaine leçon, Limiter le surapprentissage, porte sur cette forme.

Lisez donc les deux courbes ensemble. Toutes deux élevées et plates : les pas sont trop petits. Des bonds : les pas sont trop grands. Toutes deux baissent, puis s’écartent : surapprentissage.

Explorer le taux d’apprentissage

L’explorateur contient les cinq taux d’apprentissage des entraînements SGD de Priya. Chaque courbe vient d’un entraînement réel, enregistré lors des essais de vérification du cours. Faites d’abord une prédiction.

Explorer

Le taux d'apprentissage de SGD et les courbes réelles

Forme de la courbe

Bon

Exactitude en validation, époque 15

98,0 %

Perte de validation minimale

0,103 (époque 14)

Perte d’entraînement, époque 1 → 15

1,188 → 0,097

SGD, taux d’apprentissage 0,1 : un bon taux d’apprentissage. La perte baisse vite dans les premières époques, puis lentement. 98,0 % des billets de validation sont bien classés après 15 époques.

• Perte d’entraînement
• Perte de validation

Le routeur à sac de mots entraîné pendant 15 époques avec SGD, des mini-lots de 64 et la graine 0. Pertes réelles d'entraînement et de validation de chaque essai (PyTorch 2.14.1, processeur). Les pertes supérieures à 2,5 sont tracées sur le bord supérieur.

Description textuelle de l’explorateur

L’explorateur a une commande : le taux d’apprentissage, avec cinq boutons : 0,00001, 0,001, 0,1, 1 et 10. Il montre la forme des courbes et l’exactitude de validation après 15 époques. Il montre aussi la perte de validation minimale et son époque, ainsi que la perte d’entraînement aux époques 1 et 15. Le graphique montre les pertes d’entraînement et de validation pour les époques 1 à 15. Une ligne pointillée à 1,61 indique la perte des réponses au hasard.

0,00001 : trop petit. Perte d’entraînement de 1,624 à 1,623, exactitude de validation de 18,3 %. Les deux courbes restent sur la ligne des réponses au hasard. 0,001 : trop petit. Perte d’entraînement de 1,619 à 1,569, exactitude de validation de 39,7 %. Les deux courbes baissent un peu. 0,1 : bon. Perte d’entraînement de 1,188 à 0,097, exactitude de validation de 98,0 %, perte de validation minimale de 0,103 à l’époque 14. 1 : instable. Perte d’entraînement de 1,051 à 0,024, exactitude de validation de 97,8 %, avec des bonds aux époques 4, 6 et 7 (jusqu’à 1,433). 10 : trop grand. Perte d’entraînement de 1,579 à 2,509, exactitude de validation de 27,5 %. La perte monte et descend au-dessus de la ligne des réponses au hasard et atteint 3,496.

Un taux 10 fois plus grand que 0,1 est instable, et un taux 100 fois plus grand diverge. Un taux 10 fois plus petit avance à peine en 15 époques. La bonne plage pour ce réseau et SGD est étroite : environ une puissance de dix.

Les optimiseurs : trois façons de faire un pas

L’optimiseur est la partie de la boucle d’entraînement qui transforme les gradients en changements de poids. C’est l’étape 5, optimizer.step(), dans La boucle d’entraînement. Jusqu’ici, vous avez utilisé Adam sans le comparer aux autres. Il existe beaucoup d’optimiseurs. Vous devez en connaître trois, car chacun ajoute une idée au précédent.

SGD : un pas à partir d’un lot

SGD est la règle simple : pas = taux d’apprentissage × pente. Son nom signifie descente de gradient stochastique, et « stochastique » signifie « avec une part de hasard ». Chaque pas utilise la pente d’un mini-lot aléatoire de 64 billets, pas celle des 4 696 billets. Chaque pente est donc une estimation bruitée. SGD simple a deux faiblesses. Sur une longue pente douce, il avance lentement, car la pente est faible. Et un seul taux d’apprentissage doit convenir à tous les poids : ceux aux pentes fortes comme ceux aux pentes faibles.

Momentum : une balle qui continue de rouler

Faites rouler une balle sur une longue pente douce. Elle ne s’arrête pas pour repartir à chaque bosse. Elle garde sa vitesse et en prend davantage. Le momentum (momentum, ou quantité de mouvement) donne cette mémoire aux pas. L’optimiseur conserve une somme cumulative des pas récents, la vitesse. Chaque nouvelle vitesse vaut 90 % de la vitesse précédente plus la nouvelle pente. Voici ce qui se passe avec une pente constante de 1 et un taux d’apprentissage de 0,1 :

momentum_tiny.py

learning_rate, slope = 0.1, 1.0       # a long, gentle slope: the same slope at every step
velocity, sgd_total, momentum_total = 0.0, 0.0, 0.0
for step in range(1, 5):
    velocity = 0.9 * velocity + slope           # momentum keeps 90% of the last push
    sgd_total += learning_rate * slope
    momentum_total += learning_rate * velocity
    print(f"step {step}: SGD moved {sgd_total:.3f}, momentum moved {momentum_total:.3f}")

La sortie :

step 1: SGD moved 0.100, momentum moved 0.100
step 2: SGD moved 0.200, momentum moved 0.290
step 3: SGD moved 0.300, momentum moved 0.561
step 4: SGD moved 0.400, momentum moved 0.905

Après quatre pas, le momentum a parcouru plus de deux fois la distance. Sur une pente constante, la vitesse augmente vers 1 ÷ (1 − 0,9) = 10. Le momentum peut donc avancer jusqu’à 10 fois plus vite que SGD avec le même taux d’apprentissage. Cela aide sur les pentes douces. Mais un taux d’apprentissage déjà grand pour SGD devient beaucoup trop grand avec le momentum. Dans train(), optimizer="momentum" est SGD avec cette valeur de 0,9.

Adam : une longueur de pas pour chaque poids

Prenons maintenant deux poids. La perte change 1 000 fois plus vite avec w[0] qu’avec w[1] : une pente vaut 10, l’autre 0,01. Observez le premier pas de SGD et d’Adam, tous deux avec un taux d’apprentissage de 0,01 :

adam_step.py

import torch

for name in ["SGD", "Adam"]:
    w = torch.tensor([1.0, 1.0], requires_grad=True)       # two weights, both start at 1
    optimizer = torch.optim.SGD([w], lr=0.01) if name == "SGD" else torch.optim.Adam([w], lr=0.01)
    loss = 10 * w[0] + 0.01 * w[1]      # w[0] has a steep slope (10), w[1] a flat one (0.01)
    loss.backward()
    optimizer.step()
    steps = (1 - w.detach()).tolist()
    print(f"{name:<4} step of w[0]: {steps[0]:.5f}   step of w[1]: {steps[1]:.5f}")

La sortie :

SGD  step of w[0]: 0.10000   step of w[1]: 0.00010
Adam step of w[0]: 0.01000   step of w[1]: 0.01000

SGD déplace le poids à pente forte 1 000 fois plus que celui à pente faible. Adam déplace les deux de 0,01, le taux d’apprentissage. Adam divise la pente de chaque poids par la grandeur typique de ses pentes récentes. Chaque poids obtient donc sa propre longueur de pas. Le taux d’apprentissage devient approximativement « la distance qu’un poids peut parcourir en un pas ». Adam conserve aussi un momentum, comme la balle. Son nom vient de adaptive moment estimation, soit l’estimation adaptative des moments. Il adapte chaque pas aux moyennes cumulatives des pentes, que les statisticiens appellent des moments.

Cela compte pour le routeur de billets. Un mot comme « refund » (remboursement) apparaît dans des centaines de billets. Ses poids reçoivent donc une pente dans presque chaque lot. Un mot comme « hammock » (hamac) apparaît dans quelques billets; ses poids reçoivent donc rarement une pente. Adam donne aux mots rares des pas de pleine taille quand ils apparaissent.

Les trois optimiseurs sur les billets

Priya essaie chaque optimiseur avec deux taux d’apprentissage :

optimizers.py

for optimizer in ["sgd", "momentum", "adam"]:
    for learning_rate in [0.001, 0.1]:
        set_seed(0)
        model = BagOfWordsNet(len(vocab))
        history = train(model, x_train, y_train, x_valid, y_valid, epochs=15,
                        lr=learning_rate, optimizer=optimizer, log=None)
        print(f"{optimizer:<8} lr {learning_rate:<5g} valid accuracy after 1 epoch {history[0]['valid_acc']:.1%},"
              f" after 15 {history[-1]['valid_acc']:.1%}")

La sortie :

sgd      lr 0.001 valid accuracy after 1 epoch 20.7%, after 15 39.7%
sgd      lr 0.1   valid accuracy after 1 epoch 77.3%, after 15 98.0%
momentum lr 0.001 valid accuracy after 1 epoch 29.0%, after 15 87.7%
momentum lr 0.1   valid accuracy after 1 epoch 92.7%, after 15 97.5%
adam     lr 0.001 valid accuracy after 1 epoch 97.2%, after 15 97.7%
adam     lr 0.1   valid accuracy after 1 epoch 96.2%, after 15 94.5%

À 0,001, SGD est beaucoup trop lent, le momentum est plus rapide, et Adam donne de bons résultats après une époque. À 0,1, SGD et le momentum sont bons, et Adam fait moins bien qu’à 0,001. Le même taux d’apprentissage donne donc une longueur de pas différente pour chaque optimiseur. Chaque optimiseur a sa propre bonne plage, et leurs meilleurs résultats sont proches : 98,0 %, 97,5 % et 97,7 %. L’optimiseur change surtout la vitesse et la stabilité du trajet, plus que le point d’arrivée.

Utilisez maintenant la deuxième commande de l’explorateur pour comparer les quinze entraînements.

Explorer

Taux d'apprentissage et optimiseur ensemble

Forme de la courbe

Bon

Exactitude en validation, époque 15

97,7 %

Perte de validation minimale

0,063 (époque 12)

Perte d’entraînement, époque 1 → 15

0,534 → 0,011

Adam, taux d’apprentissage 0,001 : un bon taux d’apprentissage. La perte baisse vite dans les premières époques, puis lentement. 97,7 % des billets de validation sont bien classés après 15 époques.

• Perte d’entraînement
• Perte de validation

Le même routeur et les mêmes 15 époques, avec SGD, SGD avec un momentum de 0,9, ou Adam. Cinq taux d'apprentissage donnent 15 entraînements réels. Les pertes supérieures à 2,5 sont tracées sur le bord supérieur.

Description textuelle de l’explorateur

L’explorateur a deux commandes : le taux d’apprentissage (0,00001, 0,001, 0,1, 1, 10) et l’optimiseur (SGD, momentum, Adam). Il commence avec Adam à 0,001. Les valeurs affichées et le graphique sont comme dans le premier explorateur. Voici l’exactitude de validation après 15 époques et la forme des courbes :

SGD. À 0,00001 : 18,3 %, trop petit. À 0,001 : 39,7 %, trop petit. À 0,1 : 98,0 %, bon. À 1 : 97,8 %, instable. À 10 : 27,5 %, trop grand. Momentum. À 0,00001 : 22,3 %, trop petit. À 0,001 : 87,7 %, trop petit. À 0,1 : 97,5 %, bon. À 1 : 31,7 %, trop grand. À 10 : 14,7 %, trop grand; la perte atteint 10,1. Adam. À 0,00001 : 80,3 %, trop petit. À 0,001 : 97,7 %, bon, avec une perte de validation minimale de 0,063 à l’époque 12. À 0,1 : 94,5 %, instable. À 1 : 21,2 %, trop grand. À 10 : 30,2 %, trop grand; la perte atteint 103,5.

Le réglage par défaut et comment le vérifier

Vous n’avez pas besoin d’essayer tous les optimiseurs et tous les taux d’apprentissage. Commencez par un réglage par défaut bien connu et vérifiez-le. Pour un nouveau réseau, le réglage habituel est Adam avec un taux d’apprentissage de 0,001. C’est le réglage par défaut de train() et de la plupart des bibliothèques. Il fonctionne pour de nombreux réseaux sans modification.

Vérifiez-le ensuite avec deux autres entraînements : un taux d’apprentissage 10 fois plus petit et un autre 10 fois plus grand. Comparez la perte de validation la plus faible de chaque entraînement :

check_default.py

for learning_rate in [0.0001, 0.001, 0.01]:      # the default, 10 times smaller, 10 times larger
    set_seed(0)
    model = BagOfWordsNet(len(vocab))
    history = train(model, x_train, y_train, x_valid, y_valid, epochs=15, lr=learning_rate, log=None)
    best = min(history, key=lambda row: row["valid_loss"])
    print(f"Adam lr {learning_rate:<6g} best valid loss {best['valid_loss']:.3f} at epoch {best['epoch']:>2},"
          f" accuracy then {best['valid_acc']:.1%}")

La sortie :

Adam lr 0.0001 best valid loss 0.286 at epoch 15, accuracy then 98.5%
Adam lr 0.001  best valid loss 0.063 at epoch 12, accuracy then 98.3%
Adam lr 0.01   best valid loss 0.058 at epoch  2, accuracy then 98.8%

Regardez d’abord les époques. À 0,0001, la meilleure époque est la dernière. La perte diminuait donc encore : c’est trop lent pour 15 époques. À 0,01, la meilleure époque est la deuxième. Le réseau apprend donc très vite, puis commence à faire du surapprentissage. Le réglage par défaut se situe entre les deux. Les pertes les plus faibles à 0,001 et à 0,01 diffèrent de 0,005. Leurs exactitudes diffèrent de 0,5 point, soit 3 billets de soutien sur 600. Ce n’est pas une différence réelle, donc Priya garde le réglage par défaut. Un taux d’apprentissage est bon s’il se trouve dans la bonne plage, pas s’il gagne par trois billets.

Le réglage par défaut ne convient pas toujours. Le réseau du cours qui calcule la moyenne des plongements apprend mieux avec 0,01 dans Jetons et plongements. Les deux entraînements supplémentaires repèrent rapidement ces cas.

Quand choisir quel optimiseur. Pour tout nouveau réseau, utilisez d’abord Adam avec 0,001. Utilisez SGD avec momentum lorsqu’une méthode bien testée pour votre type de réseau le recommande. Les réseaux pour les images l’utilisent souvent, avec un taux d’apprentissage qui diminue pendant l’entraînement. SGD sans momentum sert surtout à l’enseignement et aux très petits problèmes.

Le coût. Adam conserve deux nombres supplémentaires pour chaque poids : la moyenne mobile de ses pentes et celle de leurs carrés. L’optimiseur utilise donc deux fois la mémoire des poids, en plus des poids et des gradients. Pour le routeur, avec ses 183 685 poids, c’est négligeable. Pour un grand modèle de langage, c’est un coût réel, mesuré au module 7 dans Les coûts de l’inférence.

Exercice guidé : lire l’explorateur

1. Faites votre prédiction dans le premier explorateur, puis sélectionnez I have made my prediction (j’ai fait ma prédiction).
2. Sélectionnez 0.1. Vous devriez voir la forme « Good » (bonne) et 98,0 %.
3. Sélectionnez 1. Vous devriez voir « Unstable » (instable) et trois sauts dans les courbes.
4. Sélectionnez 10. Vous devriez voir « Too large » (trop grand), 27,5 %, et la note « off the chart » (hors du graphique) au-dessus du graphique.
5. Sélectionnez 0.00001. Vous devriez voir « Too small » (trop petit) et deux lignes plates au niveau du hasard.
6. Dans le deuxième explorateur, sélectionnez Adam et 0.1. Écrivez une phrase : quelle est la forme et que changeriez-vous?

Afficher un exemple de réponse

« Adam avec 0,1 est instable. La perte d’entraînement passe de 0,030 à l’époque 5 à 0,133 à l’époque 12. La perte de validation monte de 0,104 à 0,443. L’entraînement se termine à 94,5 % au lieu de 97,7 %. Je réduirais le taux d’apprentissage à 0,001, le réglage par défaut habituel d’Adam. Je vérifierais aussi 0,01 et 0,0001. »

À vous de jouer : momentum avec un taux d’apprentissage de 1

SGD avec un taux d’apprentissage de 1 est instable, mais termine à 97,8 %. Faites une prédiction : que se passe-t-il avec momentum au même taux d’apprentissage? Utilisez ce que vous avez appris sur la vitesse. Vérifiez ensuite dans le deuxième explorateur.

Afficher la réponse

Momentum à 1 diverge : la forme est « Too large » et le routeur termine à 31,7 %. Sur une pente constante, momentum produit des pas jusqu’à 10 fois plus longs que SGD au même taux d’apprentissage. Un taux d’apprentissage déjà à la limite pour SGD la dépasse largement avec momentum. Pour momentum, 0,1 convient bien (97,5 %).

Erreur courante

Un taux d'apprentissage repris pour un autre optimiseur

Symptôme : Tomás remplace SGD par Adam dans le script de Priya, « parce qu’Adam est meilleur ». Il garde son taux d’apprentissage de 0,1. Le routeur fait moins bien : 94,5 % au lieu de 98,0 %. La perte de validation monte de 0,104 à l’époque 2 à 0,443 à l’époque 13. Il conclut qu’Adam est moins bon pour les billets.

Cause : un taux d’apprentissage est propre à un optimiseur. Pour SGD, 0,1 signifie « un pas de 0,1 fois la pente ». Pour Adam, cela signifie « un pas allant jusqu’à environ 0,1 pour chaque poids », ce qui est énorme. Les courbes ont la forme instable.

Correction : quand vous changez d’optimiseur, repartez de son réglage par défaut, soit 0,001 pour Adam. Vérifiez-le avec un entraînement à un taux 10 fois plus petit et un autre à un taux 10 fois plus grand. Adam à 0,001 atteint 97,7 %. Ne comparez jamais deux optimiseurs avec un seul taux d’apprentissage commun. Comparez chacun à son propre taux d’apprentissage qui convient bien.

Ce que cela signifie pour un vrai service d’IA : un « meilleur » optimiseur, modèle ou réglage peut sembler moins bon simplement parce qu’un autre réglage n’a pas changé. Avant d’abandonner une option, vérifiez qu’elle a fonctionné dans sa propre bonne plage.

Vérification des connaissances

Vérifiez votre compréhension

Vous voyez une courbe d'entraînement où la perte d'entraînement et la perte de validation se superposent. Elles diminuent très peu en 15 époques, de 1,62 à 1,57. Quelle est la cause la plus probable et qu'essayez-vous d'abord?

Afficher la réponse

Le taux d’apprentissage est trop petit, donc le réseau fait du sous-apprentissage : il n’a pas encore assez appris. Une perte près de 1,61 signifie que le routeur choisit encore presque au hasard parmi cinq équipes. Multipliez le taux d’apprentissage par 10 et regardez de nouveau la courbe, ou entraînez pendant beaucoup plus d’époques. Un réseau plus grand n’aiderait pas. Le problème vient de la taille des pas, pas de celle du réseau.

Vérifiez votre compréhension

Faites une prédiction : pour la perte w × w, avec w = 3 au départ, que vaut w après un pas avec un taux d'apprentissage de 0,5? Pourquoi est-ce particulier?

Afficher la réponse

La pente à 3 est 2 × 3 = 6, et le pas vaut 0,5 × 6 = 3. Donc w = 3 − 3 = 0 : le fond, en un seul pas. Chaque pas multiplie w par 1 − 2 × 0,5 = 0. Les vrais réseaux n’ont jamais une vallée aussi simple. Aucun taux d’apprentissage n’y produit donc cet effet. Cela montre que la meilleure taille de pas dépend de la forme de la perte.

Vérifiez votre compréhension

Omar demande : Adam a atteint 97,7 % et SGD, 98,0 %. SGD est-il le meilleur optimiseur pour le routeur? Répondez-lui en deux ou trois phrases.

Afficher la réponse

Non. La différence est de 0,3 point, soit 2 billets de validation sur 600. Ce n’est donc pas une différence réelle. Chaque optimiseur a atteint environ la même exactitude à son propre taux d’apprentissage qui convient bien. Adam y est arrivé après une époque et n’a nécessité aucune recherche du taux d’apprentissage. C’est pourquoi il est habituellement le premier choix.

Récapitulatif

• Le taux d’apprentissage fixe la taille du pas : pas = taux d’apprentissage × pente. Un mauvais taux échoue sans avertissement : SGD a donné 18,3 % à 0,00001 et 27,5 % à 10, contre 98,0 % à 0,1.
• Trois formes de courbes. Deux pertes élevées et plates : trop petit, sous-apprentissage. Des sauts vers le haut et le bas : trop grand, instabilité ou divergence. La perte d’entraînement baisse tandis que celle de validation monte : surapprentissage, le sujet de la prochaine leçon.
• L’optimiseur transforme les gradients en pas. SGD utilise la pente de chaque mini-lot. Momentum conserve une vitesse, donc les pas s’allongent sur les longues pentes. Adam donne à chaque poids sa propre taille de pas.
• Chaque optimiseur a sa propre plage de taux d’apprentissage qui convient bien. Commencez avec Adam à 0,001, puis vérifiez un taux 10 fois plus petit et un autre 10 fois plus grand. Les différences de quelques billets ne justifient pas d’ajuster le réglage.

Ensuite, la troisième forme : un routeur qui apprend trop bien ses billets d’entraînement, et quatre façons de l’en empêcher.

Leçon suivante : Limiter le surapprentissage