Comprendre les paramètres et les exigences de mémoire des grands modèles de langage : une plongée en profondeur

Les grands modèles de langage (LLM) ont connu des progrès remarquables ces dernières années. Des modèles comme GPT-4, Google’s Gemini et Claude 3 établissent de nouvelles normes en termes de capacités et d’applications. Ces modèles améliorent non seulement la génération de texte et la traduction, mais ouvrent également de nouvelles voies dans le traitement multimodal, en combinant des entrées de texte, d’image, audio et vidéo pour fournir des solutions d’IA plus complètes.

Par exemple, GPT-4 d’OpenAI a montré des améliorations significatives dans la compréhension et la génération de texte similaire à celui des humains, tandis que les modèles Gemini de Google excellent dans la gestion de divers types de données, y compris le texte, les images et l’audio, permettant des interactions plus fluides et plus pertinentes en contexte. De même, les modèles Claude 3 d’Anthropic sont réputés pour leurs capacités multilingues et leurs performances améliorées dans les tâches d’IA.

Alors que le développement des LLM continue d’accélérer, comprendre les complexités de ces modèles, en particulier leurs paramètres et leurs exigences de mémoire, devient crucial. Ce guide vise à démystifier ces aspects, offrant une explication détaillée et facile à comprendre.

Les bases des grands modèles de langage

Qu’est-ce que les grands modèles de langage ?

Les grands modèles de langage sont des réseaux de neurones formés sur des ensembles de données massifs pour comprendre et générer le langage humain. Ils s’appuient sur des architectures comme les Transformers, qui utilisent des mécanismes tels que l’auto-attention pour traiter et produire du texte.

L’importance des paramètres dans les LLM

Les paramètres sont les composants essentiels de ces modèles. Ils incluent les poids et les biais, que le modèle ajuste pendant la formation pour minimiser les erreurs de prédiction. Le nombre de paramètres est souvent corrélé à la capacité et à la performance du modèle, mais influence également ses exigences computationnelles et de mémoire.

Comprendre l’architecture Transformer

Architecture des Transformers

Présentation

L’architecture Transformer, introduite dans le document “Attention Is All You Need” par Vaswani et al. (2017), est devenue la base de nombreux LLM. Elle se compose d’un encodeur et d’un décodeur, chacun constitué de plusieurs couches identiques.

Composants de l’encodeur et du décodeur

• Encodeur : Traite la séquence d’entrée et crée une représentation sensible au contexte.
• Décodeur : Génère la séquence de sortie en utilisant la représentation de l’encodeur et les jetons générés précédemment.

Blocs de construction clés

1. Attention multi-tête : Permet au modèle de se concentrer sur différentes parties de la séquence d’entrée simultanément.
2. Réseaux de neurones à propagation avant : Ajoute de la non-linéarité et de la complexité au modèle.
3. Normalisation de couche : Stabilise et accélère la formation en normalisant les sorties intermédiaires.

Calculer le nombre de paramètres

Modèles préformés pour une formation de Transformer efficace

Calcul des paramètres dans les LLM basés sur les Transformers

Décomposons le calcul des paramètres pour chaque composant d’un LLM basé sur les Transformers. Nous allons utiliser la notation du document original, où d_model représente la dimension des états cachés du modèle.

1. Couche d’incrustation :
   • Paramètres = vocab_size * d_model
2. Attention multi-tête :
   • Pour h têtes, avec d_k = d_v = d_model / h :
   • Paramètres = 4 * d_model^2 (pour Q, K, V et projections de sortie)
3. Réseau de neurones à propagation avant :
   • Paramètres = 2 * d_model * d_ff + d_model + d_ff
   • Où d_ff est généralement 4 * d_model
4. Normalisation de couche :
   • Paramètres = 2 * d_model (pour échelle et biais)

Total des paramètres pour une couche de Transformer :

• Paramètres_couche = Paramètres_attention + Paramètres_ffn + 2 * Paramètres_layernorm

Pour un modèle avec N couches :

• Total des paramètres = N * Paramètres_couche + Paramètres_embedding + Paramètres_output

Exemple de calcul

Considérons un modèle avec les spécifications suivantes :

• d_model = 768
• h (nombre de têtes d’attention) = 12
• N (nombre de couches) = 12
• vocab_size = 50 000

1. Couche d’incrustation :
   • 50 000 * 768 = 38 400 000
2. Attention multi-tête :
   • 4 * 768^2 = 2 359 296
3. Réseau de neurones à propagation avant :
   • 2 * 768 * (4 * 768) + 768 + (4 * 768) = 4 719 616
4. Normalisation de couche :
   • 2 * 768 = 1 536

Total des paramètres par couche :

• 2 359 296 + 4 719 616 + (2 * 1 536) = 7 081 984

Total des paramètres pour 12 couches :

• 12 * 7 081 984 = 84 983 808

Total des paramètres du modèle :

• 84 983 808 + 38 400 000 = 123 383 808

Ce modèle aurait environ 123 millions de paramètres.

Types d’utilisation de la mémoire

Lorsque nous travaillons avec les LLM, nous devons considérer deux principaux types d’utilisation de la mémoire :

1. Mémoire du modèle : La mémoire requise pour stocker les paramètres du modèle.
2. Mémoire de travail : La mémoire nécessaire pendant l’inférence ou la formation pour stocker les activations intermédiaires, les gradients et les états de l’optimiseur.

Calcul de la mémoire du modèle

La mémoire du modèle est directement liée au nombre de paramètres. Chaque paramètre est généralement stocké comme un nombre à virgule flottante 32 bits, bien que certains modèles utilisent une formation à précision mixte avec des nombres à virgule flottante 16 bits.

Mémoire du modèle (octets) = Nombre de paramètres * Octets par paramètre

Pour notre exemple de modèle avec 123 millions de paramètres :

• Mémoire du modèle (32 bits) = 123 383 808 * 4 octets = 493 535 232 octets ≈ 494 Mo
• Mémoire du modèle (16 bits) = 123 383 808 * 2 octets = 246 767 616 octets ≈ 247 Mo

Estimation de la mémoire de travail

Les exigences de mémoire de travail peuvent varier considérablement en fonction de la tâche spécifique, de la taille du lot et de la longueur de la séquence. Une estimation approximative de la mémoire de travail pendant l’inférence est :

Mémoire de travail ≈ 2 * Mémoire du modèle

Cela prend en compte le stockage des paramètres du modèle et des activations intermédiaires. Pendant la formation, les exigences de mémoire peuvent être encore plus élevées en raison de la nécessité de stocker les gradients et les états de l’optimiseur :

Mémoire de formation ≈ 4 * Mémoire du modèle

Pour notre exemple de modèle :

• Mémoire de travail d’inférence ≈ 2 * 494 Mo = 988 Mo ≈ 1 Go
• Mémoire de formation ≈ 4 * 494 Mo = 1 976 Mo ≈ 2 Go

Utilisation de la mémoire à l’état stable et utilisation de la mémoire de pointe

Lors de la formation de grands modèles de langage basés sur l’architecture Transformer, la compréhension de l’utilisation de la mémoire est cruciale pour une allocation de ressources efficace. Décomposons les exigences de mémoire en deux catégories principales : utilisation de la mémoire à l’état stable et utilisation de la mémoire de pointe.

Utilisation de la mémoire à l’état stable

L’utilisation de la mémoire à l’état stable comprend les composants suivants :

1. Poids du modèle : Copies FP32 des paramètres du modèle, nécessitant 4N octets, où N est le nombre de paramètres.
2. États de l’optimiseur : Pour l’optimiseur Adam, cela nécessite 8N octets (2 états par paramètre).
3. Gradients : Copies FP32 des gradients, nécessitant 4N octets.
4. Données d’entrée : En supposant des entrées int64, cela nécessite 8BD octets, où B est la taille du lot et D est la dimension d’entrée.

L’utilisation totale de la mémoire à l’état stable peut être approximée par :

• M_stable = 16N + 8BD octets

Utilisation de la mémoire de pointe

L’utilisation de la mémoire de pointe se produit pendant le passage arrière lorsque les activations sont stockées pour le calcul des gradients. Les principaux contributeurs à l’utilisation de la mémoire de pointe sont :

1. Normalisation de couche : Nécessite 4E octets par normalisation de couche, où E = BSH (B : taille du lot, S : longueur de la séquence, H : taille cachée).
2. Bloc d’attention :
   • Calcul QKV : 2E octets
   • Matrice d’attention : 4BSS octets (S : longueur de la séquence)
   • Sortie d’attention : 2E octets
3. Bloc de propagation avant :
   • Première couche linéaire : 2E octets
   • Activation GELU : 8E octets
   • Deuxième couche linéaire : 2E octets
4. Perte d’entropie croisée :
   • Logits : 6BSV octets (V : taille du vocabulaire)

La mémoire totale d’activation peut être estimée à :

• M_act = L * (14E + 4BSS) + 6BSV octets

Où L est le nombre de couches de Transformer.

Utilisation totale de la mémoire de pointe

L’utilisation de la mémoire de pointe pendant la formation peut être approximée en combinant la mémoire à l’état stable et la mémoire d’activation :

• M_peak = M_stable + M_act + 4BSV octets

Le terme supplémentaire 4BSV prend en compte une allocation supplémentaire au début du passage arrière.

En comprenant ces composants, nous pouvons optimiser l’utilisation de la mémoire pendant la formation et l’inférence, garantissant une allocation de ressources efficace et améliorant les performances des grands modèles de langage.

Lois d’échelle et considérations d’efficacité

Lois d’échelle pour les LLM

Les recherches ont montré que les performances des LLM tendent à suivre certaines lois d’échelle à mesure que le nombre de paramètres augmente. Kaplan et al. (2020) ont observé que les performances du modèle s’améliorent comme une loi de puissance du nombre de paramètres, du budget de calcul et de la taille de l’ensemble de données.

La relation entre les performances du modèle et le nombre de paramètres peut être approximée par :

Performance ∝ N^α

Où N est le nombre de paramètres et α est un exposant d’échelle généralement autour de 0,07 pour les tâches de modélisation de langage.

Cela implique que pour améliorer les performances de 10 %, nous devons augmenter le nombre de paramètres d’un facteur de 10^(1/α) ≈ 3,7.

Techniques d’efficacité

Alors que les LLM continuent de grandir, les chercheurs et les praticiens ont développé diverses techniques pour améliorer l’efficacité :

a) Formation à précision mixte : Utiliser des nombres à virgule flottante 16 bits ou même 8 bits pour certaines opérations pour réduire l’utilisation de la mémoire et les exigences computationnelles.

b) Parallélisme de modèle : Distribuer le modèle sur plusieurs GPU ou TPU pour gérer des modèles plus grands que ceux qui peuvent tenir sur un seul appareil.

c) Point de contrôle des gradients : Échanger le calcul pour la mémoire en recalculant certaines activations pendant le passage arrière au lieu de les stocker.

d) Élagage et quantification : Supprimer les poids moins importants ou réduire leur précision après la formation pour créer des modèles plus petits et plus efficaces.

e) Distillation : Former des modèles plus petits pour imiter le comportement de modèles plus grands, préservant potentiellement une grande partie des performances avec moins de paramètres.

Exemple pratique et calculs

GPT-3, l’un des plus grands modèles de langage, comporte 175 milliards de paramètres. Il utilise la partie décodeur de l’architecture Transformer. Pour comprendre son ampleur, décomposons le nombre de paramètres avec des valeurs hypothétiques :

• d_model = 12288
• d_ff = 4 * 12288 = 49152
• Nombre de couches = 96

Pour une couche de décodeur :

Total des paramètres = 8 * 12288^2 + 8 * 12288 * 49152 + 2 * 12288 ≈ 1,1 milliard

Total pour 96 couches :

1,1 milliard * 96 = 105,6 milliards

Les paramètres restants proviennent de l’incrustation et d’autres composants.

Conclusion

Comprendre les paramètres et les exigences de mémoire des grands modèles de langage est crucial pour concevoir, former et déployer efficacement ces outils puissants. En décomposant les composants de l’architecture Transformer et en examinant des exemples pratiques comme GPT, nous acquérons une compréhension plus approfondie de la complexité et de l’amplitude de ces modèles.

Pour mieux comprendre les dernières avancées dans les grands modèles de langage et leurs applications, consultez ces guides complets :

• Explorez le guide complet sur Gemma 2 : le nouveau modèle de langage ouvert de Google pour des informations sur ses performances améliorées et ses fonctionnalités innovantes.
• Apprenez-en davantage sur la construction d’agents LLM pour RAG à partir de zéro et au-delà : un guide complet qui discute des défis et des solutions dans la génération augmentée de récupération.
• Découvrez les complexités de la configuration de la formation, de l’ajustement fin et de l’inférence des LLM avec les GPU NVIDIA et CUDA pour l’optimisation des systèmes d’IA.