Bientôt disponibleL'Entraînement de modèles sera bientôt disponible dans Scalata Enterprise. Apprenez à un modèle à répondre comme votre équipe.Découvrir les nouveautés

Ressources/Entraînement du modèle/Ce qui se passe lors de l'entraînement

Concept

Gradient checkpointing

Le gradient checkpointing économise de la mémoire en ne conservant que certains résultats intermédiaires de la passe avant et en recalculant le reste lorsque la passe arrière en a besoin. Il utilise beaucoup moins de mémoire et ralentit l'entraînement d'environ 20 à 30 %.

Chapitre 65 min de lecture4 références

Ce que c'est

Une étape d'entraînement se divise en deux parties. Lors de la passe avant, chaque couche transforme son entrée en une sortie, produisant au passage un ensemble de résultats intermédiaires : les activations. La passe arrière parcourt ensuite les couches en sens inverse pour calculer les gradients, et les gradients de chaque couche nécessitent les activations de cette même couche. L'approche simple consiste à toutes les conserver en mémoire jusqu'à ce que la passe arrière les atteigne. Avec des exemples longs, les activations peuvent occuper plus de mémoire que les poids du modèle eux-mêmes.

Le gradient checkpointing, également appelé activation checkpointing ou recalcul, ne conserve que certaines activations (les points de contrôle) et supprime les autres. Lorsque la passe arrière a besoin d'une activation supprimée, elle relance la passe avant à partir du point de contrôle le plus proche pour la recréer. Chen et al. (2016) ont montré que cela réduit la mémoire d'activation d'un réseau à n couches à l'ordre de √n, au prix d'environ une passe avant supplémentaire par lot. Lors de leurs expériences, un réseau de 1 000 couches est passé de 48 Go à 7 Go pour un temps d'exécution allongé d'environ 30 %.

SANS CHECKPOINTINGL1L2L3L4L5L6L7L88 ensembles d'activations conservés jusqu'à la passe arrièreAVEC CHECKPOINTINGL1L2L3L4L5L6L7L8recalculées à partir du dernier ensemble conservé si nécessaireconservées en mémoireeffacées, recalculées
Huit couches, une étape d'entraînement. Normalement, les activations de chaque couche restent en mémoire jusqu'à ce que la passe arrière les utilise. Avec le checkpointing, seules quelques-unes sont conservées ; lorsque la passe arrière atteint un vide, elle relance la passe avant à partir de la plus proche conservée. Moins de mémoire, environ une passe avant de calcul supplémentaire.

Comment cela fonctionne dans un modèle de langage

Dans les bibliothèques de transformers, les points de contrôle se situent généralement aux limites des couches. L'entrée de chaque couche est conservée ; tout ce qui est calculé à l'intérieur de la couche est supprimé et reconstruit lorsque la passe arrière y parvient. Ainsi, seul l'ensemble complet des activations d'une seule couche existe à un instant donné, au lieu de la totalité d'entre elles.

Mémoire d'activation, conservée et avec points de contrôle (approximatif)
activations per GPT-style layer, 16-bit, efficient attention   (Korthikanti et al., 2022)
  ≈ 34 × batch × tokens × hidden size   bytes

illustrative 2B-class model: hidden size 2,048 · 28 layers · batch 2 × 1,024 tokens
  all kept                 34 × 2 × 1,024 × 2,048 × 28   ≈ 4.0 GB
  checkpointed, inputs      2 × 2 × 1,024 × 2,048 × 28   ≈ 0.23 GB
  + one layer rebuilt at a time                          ≈ 0.14 GB

Le nombre de points de contrôle à conserver est un paramètre ajustable. En conserver davantage signifie moins de recalculs mais plus de mémoire ; en conserver moins implique l'inverse. Placer un point de contrôle à chaque limite de couche est le paramètre par défaut habituel car il est simple et supprime déjà la majeure partie de la mémoire d'activation : il ne reste qu'une petite entrée par couche, plus la couche en cours de reconstruction.

Le coût se situe au niveau du calcul. La passe avant s'exécute en réalité deux fois : une fois normalement, et une fois par fragments lors de la passe arrière. La passe arrière coûtant déjà environ deux fois plus cher que la passe avant, le travail supplémentaire représente tout au plus un tiers d'étape ; en pratique, l'entraînement est environ 20 à 30 % plus lent. Le résultat ne change pas : les valeurs recalculées sont identiques, la courbe de perte correspond donc à celle d'une exécution sans points de contrôle, à de minuscules différences numériques près.

Pourquoi les grands vocabulaires le rendent plus important

Tout à la fin du modèle, chaque position dans chaque exemple obtient un score pour chaque token du vocabulaire : les logits. Leur taille ne dépend pas de la profondeur du modèle, mais uniquement du nombre de positions entraînées et de la taille du vocabulaire. Les modèles plus récents possèdent des vocabulaires de 150 000 à 250 000 tokens, les logits seuls peuvent donc occuper plusieurs gigaoctets.

Mémoire pour les logits
logits = batch × tokens × vocabulary size × bytes per number

2 × 1,024 × 248,000 × 4 bytes (32-bit)   ≈ 2.0 GB   before their gradients
Un modèle 2B sur un GPU de 16 Go
  1. Le modèle : environ 2 milliards de paramètres, de la famille Qwen3.5, avec un vocabulaire d'environ 248 000 tokens.
  2. Les logits : lot de 2 × 1 024 tokens × 248 000 × 4 octets ≈ 2 Go, et leurs gradients nécessitent environ la même quantité.
  3. Tout le reste : les poids en 16 bits, l'état d'entraînement de l'adaptateur et les activations de chaque couche, qui se disputent l'espace restant.
  4. Sans points de contrôle, une telle exécution peut saturer la mémoire dès les premières étapes. Avec, les activations des couches sont réduites à une fraction de leur taille et la même exécution passe sans problème.
  5. Remarque : les points de contrôle ne réduisent pas la taille des logits eux-mêmes. Ils libèrent l'espace autour d'eux, ce qui permet à l'exécution de s'effectuer.

Bien l'utiliser

  • Privilégiez cette option avant de réduire les données. Activer les points de contrôle coûte du temps ; réduire la longueur maximale ampute la fin des exemples longs. Lorsque la mémoire est la limite, le ralentissement est généralement le meilleur compromis.
  • Utilisez la mémoire libérée. Un lot plus grand ou une longueur maximale plus importante peut compenser une partie de la vitesse perdue par époque.
  • Combinez-le avec QLoRA pour les modèles les plus volumineux qu'une machine puisse supporter : QLoRA réduit les poids, le checkpointing réduit les activations.
  • Sachez ce qu'il ne modifie pas. Les poids, les gradients et l'état de l'optimiseur conservent la même taille, et cela n'a aucun effet sur l'exécution du modèle finalisé.
  • Vérifiez les paramètres par défaut. De nombreuses méthodes de fine-tuning l'activent déjà. Si la mémoire est suffisante et que la vitesse est primordiale, sa désactivation rend chaque étape plus rapide.

Erreurs courantes

  • Réduire d'abord la longueur maximale, en coupant la fin des exemples longs, alors que les points de contrôle seuls auraient suffi à les faire passer.
  • S'attendre à ce qu'il réduise les poids ou l'état de l'optimiseur. Il n'affecte que les activations.
  • Interpréter le ralentissement de 20 à 30 % comme un défaut de la machine. C'est le prix à payer pour la mémoire économisée.
  • Supposer qu'il supprime le coût des logits. Avec un vocabulaire immense, un lot plus petit ou une longueur maximale réduite peut toujours être nécessaire.

Références et lectures complémentaires

Les sources externes s'ouvrent dans un nouvel onglet.

  1. 01Training Deep Nets with Sublinear Memory CostChen et al., 2016 · arXiv · arxiv.orgL'article qui a fait du recalcul une norme : une mémoire de √n pour une passe avant supplémentaire.
  2. 02Reducing Activation Recomputation in Large Transformer ModelsKorthikanti et al., 2022 · arXiv · arxiv.orgD'où provient l'estimation de l'activation par couche, et comment ne recalculer que les parties coûteuses.
  3. 03torch.utils.checkpointPyTorch docs · docs.pytorch.org
  4. 04GPU memory usageHugging Face Transformers docs · huggingface.coPoids, gradients, état de l'optimiseur et activations : où va la mémoire d'entraînement.
Bonne pratiqueLe modèle tiendra-t-il ? Mémoire pour l'entraînementL'entraînement nécessite de l'espace pour les poids du modèle, ses gradients et l'état de l'optimiseur, en plus de la mémoire de travail. Une règle empirique simple, environ 2 Go par milliard de paramètres pour LoRA et 12 Go pour un réglage fin complet, vous indique avant de commencer si un modèle tiendra sur votre machine.MéthodeQLoRA (LoRA 4 bits)QLoRA entraîne un adaptateur LoRA classique sur un modèle de base stocké en 4 bits au lieu de 16. La mémoire nécessaire à l'entraînement est réduite à environ un tiers, ce qui permet à la même machine d'ajuster finement un modèle environ trois fois plus grand, au prix d'une légère perte de vitesse.ConceptLa boucle d'entraînementLe fine-tuning est une courte procédure répétée des milliers de fois : prédire la réponse cible, mesurer l'erreur de la prédiction, déterminer dans quelle direction chaque poids doit se déplacer, et le déplacer légèrement.ParamètreLimites de jetons et troncatureChaque fournisseur limite le nombre de jetons qu'un exemple d'entraînement peut contenir. Les longues conversations dépassant cette limite sont soit tronquées — les échanges les plus anciens étant supprimés en premier — soit exclues.ConceptTokensLes fragments de texte qu'un modèle lit et écrit réellement — comment ils sont créés, pourquoi les décomptes diffèrent d'un modèle à l'autre, et pourquoi chaque limite et chaque prix lors de l'entraînement sont mesurés avec ces unités.ParamètreHyperparamètresLes hyperparamètres sont les paramètres d'entraînement que vous choisissez, tels que les époques, le taux d'apprentissage, la taille du lot et le rang de l'adaptateur, par opposition aux poids que le modèle apprend. Auto les sélectionne à partir de vos données et effectue une bonne première exécution ; cette page explique chacun d'eux afin que vous puissiez les ajuster par la suite.

Transformez des semaines de travail d'expert en quelques minutes

Découvrez comment Scalata s'adapte à votre équipe, à vos données et à vos contrôles.

Contacter le service commercial