Fondements théoriques des LLM

Les fondements théoriques des grands modèles de langage (basés sur l'architecture Transformer) constituent un ensemble de principes mathématiques, statistiques et issus de la théorie de l'information qui sous-tendent le fonctionnement, l'entraînement et les capacités des grands modèles de langage (LLM) modernes. Ces fondements expliquent comment les modèles construits sur l'architecture Transformer sont capables de comprendre et de générer le langage humain avec un haut degré de cohérence.

Fondements architecturaux : l'architecture Transformer

Les LLM modernes reposent presque entièrement sur l'architecture Transformer, présentée en 2017 dans l'article « Attention Is All You Need ». Cette architecture a abandonné les couches récurrentes (comme dans les RNN et les LSTM) au profit du mécanisme d' attention, ce qui a permis de traiter efficacement de longues séquences et de paralléliser les calculs.

Mécanisme d'auto-attention (Self-Attention)

C'est le cœur de l'architecture Transformer. Le mécanisme d'auto-attention permet au modèle de pondérer l'importance de chaque mot (token) dans une séquence par rapport à tous les autres mots de cette même séquence. Pour chaque token, trois vecteurs sont créés :

• Query (Q, Requête) : le vecteur représentant le mot actuel.
• Key (K, Clé) : le vecteur avec lequel les requêtes des autres mots sont comparées.
• Value (V, Valeur) : le vecteur contenant l'information sur le mot qui sera transmise.

Le score d'attention est calculé comme un produit scalaire mis à l'échelle :

$\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)V$

où $d_k$ est la dimension des vecteurs clés. Ce mécanisme permet au modèle de capturer des dépendances contextuelles complexes, quelle que soit la distance entre les mots.

L' attention multi-têtes (Multi-Head Attention) consiste à exécuter plusieurs de ces calculs en parallèle avec différentes matrices de projection, ce qui permet au modèle de se concentrer simultanément sur différents aspects de la syntaxe et de la sémantique.

Types d'architectures basées sur le Transformer

Il existe trois principales variantes d'utilisation des composants du Transformer :

1. Encodeur-décodeur (Encoder-Decoder) : L'architecture classique pour les tâches de transformation de séquence à séquence (par exemple, la traduction automatique). L'encodeur traite la séquence d'entrée, et le décodeur génère la séquence de sortie. Exemples : T5, BART.
2. Encodeur seul (Encoder-Only) : Modèles utilisant uniquement la pile d'encodeurs. Ils sont excellents pour les tâches nécessitant une compréhension approfondie du contexte de toute la séquence (classification de texte, reconnaissance d'entités nommées). Exemple : BERT.
3. Décodeur seul (Decoder-Only) : Modèles utilisant uniquement la pile de décodeurs. Ils fonctionnent de manière autorégressive, prédisant le token suivant sur la base des précédents. C'est le standard pour les modèles génératifs. Exemples : GPT, LLaMA, Claude.

Encodage positionnel

Comme le mécanisme d'auto-attention ne prend pas en compte l'ordre des mots, un encodage positionnel est ajouté à l'architecture. Des vecteurs encodant leur position dans la séquence sont ajoutés aux embeddings des tokens. Dans le modèle original, des fonctions sinusoïdales étaient utilisées :

$\text{PE}(\text{pos},2i)=\sin (\text{pos}/10000^{2i/d_{\text{model}}})$

$\text{PE}(\text{pos},2i+1)=\cos (\text{pos}/10000^{2i/d_{\text{model}}})$

Les modèles modernes utilisent également des encodages positionnels apprenables et rotatifs (Rotary Position Embeddings, RoPE).

Principes de l'entraînement : de la probabilité à l'optimisation

La modélisation du langage comme problème probabiliste

Au cœur des LLM se trouve la tâche de modélisation du langage : prédire la probabilité d'une séquence de texte. Formellement, pour une séquence $X=(x_1,x_2,\dots ,x_T)$, le modèle estime la probabilité $P(X)$. En utilisant la règle de la chaîne des probabilités, cela se décompose en un produit de probabilités conditionnelles :

$P(X)=\prod _{t=1}^{T}P(x_t|x_1,\dots ,x_{t-1})$

Ainsi, l'entraînement du modèle se résume à prédire le prochain token $x_t$ sur la base du contexte des tokens précédents.

Fonction de perte et théorie de l'information

Pour évaluer la qualité des prédictions et entraîner le modèle, on utilise la fonction de perte d'entropie croisée. Elle mesure l'écart entre la distribution de probabilité prédite par le modèle ($q$) et la distribution réelle ($p$), où le token correct suivant a une probabilité de 1 et les autres de 0.

$H(p,q)=-\sum _{i}p(i)\log q(i)$

La minimisation de l'entropie croisée est équivalente à la maximisation de la vraisemblance des données d'entraînement.

Une métrique de qualité associée est la perplexité, définie comme l'exponentielle de l'entropie croisée : $\text{Perplexity}=2^{H(p,q)}$. Intuitivement, la perplexité indique le nombre moyen de choix parmi lesquels le modèle « décide » à chaque étape. Plus la perplexité est faible, plus le modèle est confiant et précis.

Optimisation

L'entraînement d'un LLM est un processus de minimisation de la fonction de perte par l'ajustement de milliards de paramètres du modèle. Pour ce faire, on utilise des méthodes basées sur la descente de gradient. L'optimiseur le plus courant est Adam (Adaptive Moment Estimation) et ses variantes (par exemple, AdamW), qui adaptent le taux d'apprentissage pour chaque paramètre.

Paradigmes d'entraînement

1. Pré-entraînement (Pre-training) : Le modèle est entraîné sur d'énormes corpus de textes non étiquetés (Common Crawl, The Pile, C4) à l'aide de tâches auto-supervisées, telles que :
   • Modélisation causale du langage (Causal Language Modeling, CLM) : Prédiction du token suivant (utilisé dans GPT).
   • Modélisation du langage masqué (Masked Language Modeling, MLM) : Restauration de tokens masqués de manière aléatoire dans le texte (utilisé dans BERT).
2. Ajustement fin : Après le pré-entraînement, le modèle est adapté à des tâches spécifiques sur de petits ensembles de données étiquetées.
3. Alignement (Alignment) : Une étape spéciale d'ajustement fin visant à conformer le comportement du modèle aux préférences et aux valeurs humaines. La méthode clé est le RLHF (Apprentissage par renforcement à partir de retours humains), où le modèle est affiné à l'aide d'un signal de récompense provenant d'un modèle qui prédit les préférences humaines.

Lois d'échelle et capacités émergentes

Des études empiriques ont montré que les performances des LLM s'améliorent de manière prévisible avec l'augmentation de trois facteurs : la taille du modèle (nombre de paramètres, $N$), la taille de l'ensemble de données d'entraînement ($D$), et le volume de calcul ($C$). Cette dépendance est décrite par des lois de puissance (scaling laws).

La loi proposée dans les travaux d'OpenAI (Kaplan et al., 2020) montre que la fonction de perte $L$ diminue comme une fonction de puissance de $N$, $D$ et $C$. Des travaux ultérieurs de DeepMind (Hoffmann et al., 2022) ont affiné ces lois (les lois Chinchilla), montrant que pour un entraînement optimal, il est nécessaire d'augmenter de manière équilibrée à la fois la taille du modèle et le volume de données.

Une conséquence importante de la mise à l'échelle est l'apparition de capacités émergentes — des sauts qualitatifs de performance où le modèle commence à résoudre des tâches pour lesquelles il n'a pas été explicitement entraîné (par exemple, l'arithmétique, le raisonnement logique, l'écriture de code). Ces capacités sont généralement absentes dans les modèles de plus petite taille et n'apparaissent qu'après avoir atteint un certain seuil d'échelle.

Génération de texte : stratégies de décodage

Après l'entraînement, le modèle génère du texte en prédisant itérativement le token suivant. Le choix du token suivant à partir de la distribution de probabilité fournie par le modèle s'effectue à l'aide de diverses stratégies de décodage :

• Recherche gloutonne (Greedy Search) : Sélectionne toujours le token le plus probable. Rapide, mais conduit souvent à un texte répétitif et peu intéressant.
• Recherche par faisceau (Beam Search) : Conserve les $k$ séquences les plus probables à chaque étape, ce qui permet de trouver des solutions globales plus optimales.
• Échantillonnage par température : Les probabilités des tokens sont ajustées par un paramètre de température ($T$). Si $T>1$, la distribution devient plus uniforme (plus de créativité), si $T<1$, elle devient plus piquée (moins d'aléatoire).
• Échantillonnage Top-k : À chaque étape, l'échantillonnage est limité aux $k$ tokens les plus probables.
• Échantillonnage Top-p (Nucleus) : L'échantillonnage est limité au plus petit ensemble de tokens dont la probabilité cumulée dépasse un seuil $p$. Cela permet d'adapter dynamiquement la taille du pool de candidats.

Problèmes théoriques et limitations

• Hallucinations : Tendance des modèles à générer des informations factuellement incorrectes mais qui semblent plausibles. Cela est dû au fait que les modèles optimisent la probabilité du texte, et non sa véracité.
• Biais (Bias) : Les LLM héritent et amplifient les biais sociaux, culturels et autres présents dans les données d'entraînement.
• Interprétabilité (« boîte noire ») : En raison du très grand nombre de paramètres, il est extrêmement difficile de comprendre comment le modèle prend ses décisions, ce qui complique le débogage et crée des risques.
• Complexité algorithmique : Le mécanisme d'auto-attention a une complexité quadratique par rapport à la longueur de la séquence ($O(n^2)$), ce qui limite la longueur maximale du contexte pouvant être traité.

Voir aussi

• Grands modèles de langage
• BERT
• GPT

Références bibliographiques

• Vaswani, A. et al. (2017). Attention Is All You Need. arXiv:1706.03762.
• Devlin, J. et al. (2019). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. arXiv:1810.04805.
• Brown, T. B. et al. (2020). Language Models Are Few-Shot Learners. arXiv:2005.14165.
• Kaplan, J. et al. (2020). Scaling Laws for Neural Language Models. arXiv:2001.08361.
• Hoffmann, J. et al. (2022). Training Compute-Optimal Large Language Models. arXiv:2203.15556.
• Wei, J. et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. arXiv:2201.11903.
• Ouyang, L. et al. (2022). Training Language Models to Follow Instructions with Human Feedback. arXiv:2203.02155.
• Bai, Y. et al. (2022). Constitutional AI: Harmlessness from AI Feedback. arXiv:2212.08073.
• Bubeck, S. et al. (2023). Sparks of Artificial General Intelligence: Early Experiments with GPT-4. arXiv:2303.12712.
• Touvron, H. et al. (2024). The Llama 3 Herd of Models. arXiv:2407.21783.
• Bender, E. M. et al. (2021). On the Dangers of Stochastic Parrots: Can Language Models Be Too Big?. DOI:10.1145/3442188.3445922.