Suivez nous sur
   Intelligence artificielle  
Comprendre les paramètres des grands modèles de langage et les besoins en mémoire : une analyse approfondie
 mm
Publié le
 Il y a 6 jours
 on
   
 Calcul des paramètres dans les LLM basés sur des transformateurs
grands modèles linguistiques (LLM) a connu des progrès remarquables ces dernières années. Des modèles comme GPT-4, Gemini de Google et Claude 3 établissent de nouvelles normes en matière de capacités et d'applications. Ces modèles améliorent non seulement la génération et la traduction de texte, mais innovent également en matière de traitement multimodal, combinant des entrées de texte, d'image, audio et vidéo pour fournir des solutions d'IA plus complètes.
Par exemple, le GPT-4 d'OpenAI a montré des améliorations significatives dans la compréhension et la génération de texte de type humain, tandis que les modèles Gemini de Google excellent dans la gestion de divers types de données, notamment le texte, les images et l'audio, permettant des interactions plus fluides et contextuellement pertinentes. 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 de s’accélérer, il devient crucial de comprendre les subtilités de ces modèles, en particulier leurs paramètres et leurs besoins en mémoire. Ce guide vise à démystifier ces aspects, en proposant une explication détaillée et facile à comprendre.
Les bases des grands modèles de langage
Que sont les grands modèles de langage ?
Les grands modèles linguistiques sont des réseaux de neurones entraînés sur des ensembles de données massifs pour comprendre et générer le langage humain. Ils s'appuient sur des architectures comme Transformers, qui utilisent des mécanismes tels que l'auto-attention pour traiter et produire du texte.
Importance des paramètres dans les LLM
Les paramètres sont les composants essentiels de ces modèles. Ils incluent des poids et des biais, que le modèle ajuste pendant la formation pour minimiser les erreurs de prédiction. Le nombre de paramètres est souvent en corrélation avec la capacité et les performances du modèle, mais influence également ses besoins en matière de calcul et de mémoire.
Comprendre l'architecture du transformateur
Architecture des transformateurs
Architecture des transformateurs
Vue d'ensemble
L'architecture Transformer, présentée dans l'article « Attention Is All You Need » de Vaswani et al. (2017), est devenu la base de nombreux LLM. Il est constitué d'un encodeur et d'un décodeur constitués chacun de plusieurs couches identiques.
Composants d'encodeur et de décodeur
  • Encoder: traite la séquence d'entrée et crée une représentation contextuelle.
  • 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.
Éléments de base clés
  1. Attention multi-têtes: Permet au modèle de se concentrer simultanément sur différentes parties de la séquence d’entrée.
  2. Réseaux de neurones à action directe: Ajoute de la non-linéarité et de la complexité au modèle.
  3. Normalisation des calques: Stabilise et accélère l'entraînement en normalisant les résultats intermédiaires.
Calcul du nombre de paramètres
Formation de transformateur
Modèles pré-entraînés pour une formation efficace des transformateurs
Calcul des paramètres dans les LLM basés sur des transformateurs
Décomposons le calcul des paramètres pour chaque composant d'un LLM basé sur Transformer. Nous utiliserons la notation de l'article original, où d_model représente la dimension des états cachés du modèle.
  1. Couche d'intégration:
    • Paramètres = vocab_size * d_model
  2. Attention multi-têtes:
    • Pour h têtes, avec d_k = d_v = d_model / h:
    • Paramètres = 4 * d_model^2 (pour les projections Q, K, V et de sortie)
  3. Réseau à réaction:
    • Paramètres = 2 * d_model * d_ff + d_model + d_ff
    • Où d_ff est généralement 4 * d_model
  4. Normalisation des calques:
    • Paramètres = 2 * d_model (pour l'échelle et le biais)
Paramètres totaux pour une couche de transformateur :
  • Parameters_layer = Parameters_attention + Parameters_ffn + 2 * Parameters_layernorm
Pour un modèle avec N couches:
  • Paramètres totaux = N * Parameters_layer + Parameters_embedding + Parameters_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'intégration:
    • 50,000 * 768 = 38,400,000
  2. Attention multi-têtes:
    • 4 * 768 ^ 2 = 2,359,296
  3. Réseau à réaction:
    • 2 * 768 * (4 * 768) + 768 + (4 * 768) = 4,719,616 XNUMX XNUMX
  4. Normalisation des calques:
    • 2 * 768 = 1,536
Paramètres totaux par couche :
  • 2,359,296 + 4,719,616 + (2 * 1,536) = 7,081,984
Paramètres totaux pour 12 couches :
  • 12 * 7,081,984 = 84,983,808
Paramètres totaux 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 des LLM, nous devons considérer deux principaux types d’utilisation de la mémoire :
  1. Mémoire de modèle: La mémoire nécessaire pour stocker les paramètres du modèle.
  2. Mémoire de travail: La mémoire nécessaire lors de l'inférence ou de l'entraînement 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é sous la forme d'un nombre à virgule flottante de 32 bits, bien que certains modèles utilisent un entraînement à précision mixte avec des flottants de 16 bits.
Mémoire 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 493,535,232 * 494 octets = XNUMX XNUMX XNUMX octets ≈ XNUMX Mo
  • Mémoire du modèle (16 bits) = 123,383,808 2 246,767,616 * 247 octets = XNUMX XNUMX XNUMX octets ≈ XNUMX Mo
Estimation de la mémoire de travail
Les besoins en 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 modèle
Cela représente le stockage à la fois des paramètres du modèle et des activations intermédiaires. Pendant l'entraînement, les besoins en mémoire peuvent être encore plus élevés en raison de la nécessité de stocker les gradients et les états de l'optimiseur :
Mémoire d'entraînement ≈ 4 * Mémoire de modèle
Pour notre exemple de modèle :
  • Mémoire de travail d'inférence ≈ 2 * 494 Mo = 988 Mo ≈ 1 Go
  • Mémoire d'entraînement ≈ 4 * 494 Mo = 1,976 2 Mo ≈ XNUMX Go
Utilisation de la mémoire en régime permanent et utilisation maximale de la mémoire
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 efficace des ressources. Décomposons les besoins en mémoire en deux catégories principales : l'utilisation de la mémoire en régime permanent et l'utilisation maximale de la mémoire.
Utilisation de la mémoire en régime permanent
L'utilisation de la mémoire en régime permanent 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. Dégradés: copies FP32 des dégradés, nécessitant 4N octets.
  4. Des données d'entrée: En supposant des entrées int64, cela nécessite 8 octets BD, où B est la taille du lot et D est la dimension d'entrée.
L'utilisation totale de la mémoire en régime permanent peut être estimée par :
  • M_steady = 16N + 8BD octets
Utilisation de la mémoire crête
L'utilisation maximale de la mémoire se produit lors du passage en arrière lorsque les activations sont stockées pour le calcul du gradient. Les principaux contributeurs au pic de mémoire sont :
  1. Normalisation des calques: Nécessite 4E octets par norme de couche, où E = BSH (B : taille du lot, S : longueur de la séquence, H : taille cachée).
  2. Blocage de l'attention:
    • Calcul QKV : 2E octets
    • Matrice d'attention : 4BSS octets (S : longueur de séquence)
    • Sortie Attention : 2E octets
  3. Bloc de rétroaction:
    • 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 d'activation totale peut être estimée comme suit :
  • M_act = L * (14E + 4BSS) + 6BSV octets
Où L est le nombre de couches de transformateur.
Utilisation maximale totale de la mémoire
L'utilisation maximale de la mémoire pendant l'entraînement peut être estimée en combinant la mémoire stable et la mémoire d'activation :
  • M_peak = M_steady + M_act + 4BSV octets
Le terme 4BSV supplémentaire représente une allocation supplémentaire au début du passage en arrière.
En comprenant ces composants, nous pouvons optimiser l'utilisation de la mémoire pendant la formation et l'inférence, garantissant ainsi une allocation efficace des ressources et de meilleures performances des grands modèles de langage.
Lois de mise à l’échelle et considérations d’efficacité
 Mise à l'échelle des lois pour les LLM
La recherche a montré que les performances des LLM ont tendance à suivre certaines lois d'échelle à mesure que le nombre de paramètres augmente. Kaplan et coll. (2020) ont observé que les performances du modèle s'améliorent en tant que 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 :
Performances ∝ 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 obtenir une amélioration des performances de 10 %, nous devons augmenter le nombre de paramètres d'un facteur 10^(1/α) ≈ 3.7.
Techniques d'efficacité
Alors que les LLM continuent de croître, les chercheurs et les praticiens ont développé diverses techniques pour améliorer l'efficacité :
a) Entraînement de précision mixte: Utilisation de nombres à virgule flottante 16 bits ou même 8 bits pour certaines opérations afin de réduire l'utilisation de la mémoire et les exigences de calcul.
b) Parallélisme du modèle: distribution du modèle sur plusieurs GPU ou TPU pour gérer des modèles plus grands que ceux pouvant contenir sur un seul appareil.
c) Points de contrôle de dégradé: Échanger le calcul contre de la mémoire en recalculant certaines activations lors du passage en arrière au lieu de les stocker.
d) Élagage et quantification: Supprimer les poids moins importants ou réduire leur précision après l'entraînement pour créer des modèles plus petits et plus efficaces.
e) Distillation: Entraîner 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, compte 175 milliards de paramètres. Il utilise la partie décodeur de l’architecture Transformer. Pour comprendre son échelle, 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 :
Paramètres totaux = 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'intégration et d'autres composants.
Conclusion
Comprendre les paramètres et les besoins en 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 tels que GPT, nous obtenons un aperçu plus approfondi de la complexité et de l'échelle de ces modèles.
Pour mieux comprendre les dernières avancées en matière de grands modèles de langage et leurs applications, consultez ces guides complets :
       
 Rubriques connexes:
 mm
J'ai passé les cinq dernières années à m'immerger dans le monde fascinant du Machine Learning et du Deep Learning. Ma passion et mon expertise m'ont amené à contribuer à plus de 50 projets de génie logiciel divers, avec un accent particulier sur l'IA/ML. Ma curiosité continue m'a également attiré vers le traitement automatique du langage naturel, un domaine que j'ai hâte d'explorer davantage.