Modèles et plateformes d’IA

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

mm
Publié le
Mis à jour le
Ajouter Unite.AI à vos sources préférées sur Google

Les modèles de langage à grande échelle (LLM) ont connu des progrès remarquables ces dernières années. Des modèles comme GPT-4, Google’s Gemini et Claude 3 sont en train de définir de nouvelles normes en termes de capacités et d’applications. Ces modèles ne sont pas seulement en train d’améliorer la génération de texte et la traduction, mais ils sont également en train de faire des progrès dans le traitement multimodal, en combinant des entrées de texte, d’image, d’audio et de 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 différents types de données, notamment le texte, les images et l’audio, permettant ainsi des interactions plus fluides et plus pertinentes en termes de 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, en offrant une explication détaillée et facile à comprendre.

Les bases des modèles de langage à grande échelle

Qu’est-ce que les modèles de langage à grande échelle ?

Les modèles de langage à grande échelle 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 reposent 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 il influence également les exigences de calcul et de mémoire.

Comprendre l’architecture Transformer

Transformers-architecture

Architecture des Transformers

Vue d’ensemble

L’architecture Transformer, introduite dans le papier “Attention Is All You Need” de Vaswani et al. (2017), est devenue la base de nombreux LLM. Elle se compose d’un encodeur et d’un décodeur, chacun composé 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 consciente du contexte.
  • Décodeur: Génère la séquence de sortie en utilisant la représentation de l’encodeur et les jetons précédemment générés.

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

Transformer Training

Modèles pré-entraînés pour une formation de Transformer efficace

Calculer les 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 papier 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ê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 l’échelle et le biais)

Paramètres totaux pour une couche Transformer:

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

Pour un modèle avec N couches:

  • Paramètres totaux = 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’intégration:
    • 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

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 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.

Calculer 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

Estimer 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

Ceci 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 en régime permanent et utilisation de la mémoire en 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 efficace des ressources. Décomposons les exigences de mémoire en deux catégories principales: l’utilisation de la mémoire en régime permanent et l’utilisation de la mémoire en pointe.

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. 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 en régime permanent peut être approximée par:

  • M_steady = 16N + 8BD octets

Utilisation de la mémoire en pointe

L’utilisation de la mémoire en pointe se produit pendant la passe arrière lorsque les activations sont stockées pour le calcul des gradients. Les principaux contributeurs à l’utilisation de la mémoire en 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 Transformer.

Utilisation totale de la mémoire en pointe

L’utilisation de la mémoire en pointe pendant la formation peut être approximée en combinant la mémoire en régime permanent et la mémoire d’activation:

  • M_peak = M_steady + M_act + 4BSV octets

Le terme supplémentaire 4BSV prend en compte une allocation supplémentaire au début de la passe 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 une meilleure performance 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 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 de calcul.

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

c) Point de contrôle de gradient: Échanger le calcul pour la mémoire en recalculant certaines activations pendant la passe 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, en conservant 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, a 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 décodeur:

Paramètres totaux = 8 * 12288^2 + 8 * 12288 * 49152 + 2 * 12288 ≈ 1,1 milliard

Paramètres totaux 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 exigences de mémoire des modèles de langage à grande échelle 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 approfondir les dernières avancées dans les modèles de langage à grande échelle et leurs applications, consultez ces guides complets:

mm

J'ai passé les cinq dernières années à plonger dans le monde fascinant de l'apprentissage automatique et du deep learning. Ma passion et mon expertise m'ont conduit à contribuer à plus de 50 projets de génie logiciel divers, avec un focus particulier sur l'IA/ML. Ma curiosité continue m'a également attiré vers le traitement automatique des langues, un domaine que je suis impatient d'explorer plus en profondeur.