La boucle d'entraînement

De quoi s'agit-il

Un modèle de langage est une très grande fonction comportant des milliards de nombres ajustables, ses poids. À partir d'un texte donné, il génère une probabilité pour chaque token suivant possible. Le fine-tuning modifie ces poids afin que, compte tenu de votre type de contexte, le modèle attribue une forte probabilité au type de réponse que vous souhaitez. La boucle d'entraînement est la procédure qui accomplit cela. Il ne s'agit pas d'une opération complexe unique, mais d'une étape simple, répétée des milliers de fois, chaque répétition ajustant légèrement les poids.

Une étape d'entraînement. Répétez-la pour chaque lot et vous avez terminé une époque ; répétez l'époque et le modèle revoit chaque exemple.

Comment fonctionne une étape

1. Passe avant. Un lot d'exemples traverse le modèle. À chaque position de chaque réponse cible, le modèle produit une distribution de probabilité sur l'ensemble de son vocabulaire, souvent 100 000 tokens ou plus, pour ce qui suit. Étant donné que la réponse exacte est déjà connue, toutes les positions sont prédites en parallèle en une seule passe. Le modèle voit toujours les tokens précédents corrects plutôt que ses propres suppositions, une technique appelée teacher forcing.

2. Perte. Pour chaque token cible, la perte est le logarithme négatif de la probabilité que le modèle a attribuée au token correct. La perte du lot est la moyenne sur tous ses tokens cibles. Les tokens de contexte (le prompt système, les tours précédents, le message de l'utilisateur) sont lus mais masqués dans cette moyenne, de sorte que seules les réponses que vous avez choisies comme cibles sont évaluées.

Perte d'entropie croisée sur un lot

loss = − (1 / N) × Σ log p(correct token | everything before it)

N = the number of target tokens in the batch
context tokens are masked: read, never scored

Entropie croisée sur trois tokens

Le modèle attribue au token suivant correct une probabilité de 0,9 : perte = −ln 0,9 ≈ 0,11.
Une probabilité de 0,5 : perte = −ln 0,5 ≈ 0,69.
Une probabilité de 0,05 : perte = −ln 0,05 ≈ 3,00.
Moyenne sur les trois tokens : (0,11 + 0,69 + 3,00) ÷ 3 ≈ 1,26. Un seul token incorrect avec un haut niveau de confiance domine le score.
À titre de comparaison : un modèle devinant au hasard parmi 100 000 tokens obtiendrait un score de ln 100 000 ≈ 11,5. Les pertes de fine-tuning commencent bien en dessous de ce niveau, car le modèle de base est déjà performant pour deviner ; l'entraînement l'affine sur vos réponses.

3. Passe arrière. La rétropropagation calcule le gradient de chaque poids entraînable : de combien la perte changerait si ce poids se déplaçait d'une infime quantité, et dans quelle direction. Cela coûte environ deux fois plus de calcul que la passe avant, et nécessite les valeurs intermédiaires (activations) sauvegardées pendant la passe avant. C'est pourquoi des exemples plus longs et des lots plus importants nécessitent davantage de mémoire GPU.

4. Mise à jour. L'optimiseur modifie chaque poids en fonction de son gradient, mis à l'échelle par le taux d'apprentissage. Dans sa forme la plus simple, la descente de gradient classique, la règle tient en une seule ligne.

Descente de gradient

gradient  = ∂loss / ∂w        how the loss changes when w changes
w (new)   = w − learning_rate × gradient

Descente de gradient avec un seul poids. Le gradient est la pente de la perte à la valeur actuelle ; chaque mise à jour descend d'un pas équivalent au taux d'apprentissage multiplié par cette pente. Les pas rétrécissent d'eux-mêmes à mesure que la pente s'aplatit près du fond. Un modèle réel fait cela pour des milliards de poids à la fois.

L'optimiseur : Adam et AdamW

Les modèles de langage sont presque toujours entraînés avec Adam ou sa variante AdamW plutôt qu'avec une simple descente de gradient. Adam conserve deux moyennes mobiles pour chaque poids : le gradient moyen (le momentum, qui lisse le bruit d'un lot à l'autre) et le gradient au carré moyen (qui met à l'échelle l'étape de chaque poids, de sorte que les poids avec des gradients constamment élevés ne fassent pas de pas immenses et que ceux rarement mis à jour ne soient pas négligés). Le résultat est que chaque poids se déplace d'environ le taux d'apprentissage par étape, quelle que soit la taille brute de son gradient.

AdamW modifie la façon dont la décroissance des poids, une légère attraction des poids vers zéro qui décourage les valeurs extrêmes, est appliquée : elle est soustraite directement des poids au lieu d'être mélangée au gradient, ce qui fonctionne de manière plus fiable avec la mise à l'échelle par poids d'Adam. C'est l'optimiseur par défaut dans les bibliothèques d'entraînement courantes.

Une mise à jour AdamW, pour un poids

m = β1 · m + (1 − β1) · g        running average of gradients (momentum)
v = β2 · v + (1 − β2) · g²       running average of squared gradients
w = w − lr · m̂ / (√v̂ + ε)        a step scaled separately for every weight
w = w − lr · λ · w               decoupled weight decay (the "W" in AdamW)

g = gradient,  m̂ and v̂ = bias-corrected m and v
usual defaults: β1 = 0.9,  β2 = 0.999,  ε = 1e-8

Ces deux moyennes mobiles sont stockées en précision 32 bits pour chaque poids entraînable : 8 octets par poids en plus des poids et des gradients eux-mêmes. C'est la raison principale pour laquelle un fine-tuning complet nécessite autant de mémoire, et pourquoi LoRA, qui n'entraîne qu'un petit adaptateur, en nécessite si peu.

Des étapes au modèle final

Les étapes forment des époques. Un passage sur chaque exemple d'entraînement constitue une époque ; un cycle de fine-tuning compte généralement d'une à quelques époques.
Le taux d'apprentissage évolue pendant le cycle. Un programme l'augmente généralement brièvement (préchauffage) puis le diminue vers zéro, afin que les premières étapes ne déstabilisent pas le modèle et que les dernières permettent des ajustements précis.
La validation s'effectue en parallèle. Régulièrement, le modèle est évalué sur des exemples mis de côté sans mettre à jour les poids. Cette perte de validation indique s'il apprend la logique ou s'il mémorise simplement vos exemples.
Le résultat donne de nouveaux poids : soit un modèle complet mis à jour, soit un petit adaptateur appliqué par-dessus le modèle de base inchangé.

Erreurs courantes

Interpréter la perte comme un score de qualité. La perte indique dans quelle mesure le modèle prédit vos tokens cibles, et non si ses réponses sont bonnes ; c'est le rôle d'une évaluation.
Comparer les valeurs de perte entre différents modèles de base. Chacun possède son propre tokenizer, les chiffres ne sont donc pas sur la même échelle.
S'attendre à ce que l'entraînement corrige les cibles erronées. La boucle réduit fidèlement la perte sur toutes les réponses que vous marquez comme cibles, erreurs incluses.
Supposer que le modèle apprend des règles. Il apprend des tendances à partir de nombreux petits ajustements, de sorte qu'un comportement illustré dans seulement deux exemples est à peine assimilé.

Références et lectures complémentaires

Les sources externes s'ouvrent dans un nouvel onglet.