Modèles de Langage : Défis et Stratégies pour Ingénieurs LLM

Les Fondamentaux des Modèles de Langage de Grande Taille

Les Modèles de Langage de Grande Taille (LLMs) sont devenus la pierre angulaire des systèmes d'intelligence artificielle modernes, utilisés dans des applications aussi variées que les chatbots, les copilotes, la recherche, la programmation et l'automatisation. Cependant, pour les ingénieurs qui se lancent dans ce domaine, la courbe d'apprentissage peut sembler abrupte et fragmentée. Des concepts tels que la tokenisation, l'attention, le fine-tuning et l'évaluation sont souvent expliqués de manière isolée, ce qui rend difficile la formation d'un modèle mental cohérent de la manière dont tout s'assemble.

J'ai personnellement rencontré ces défis en passant de la vision par ordinateur aux LLMs. En peu de temps, j'ai dû comprendre non seulement la théorie derrière les transformers, mais aussi les réalités pratiques : les compromis d'entraînement, les goulets d'étranglement d'inférence, les défis d'alignement et les pièges d'évaluation. Cet article est conçu pour combler cette lacune. Plutôt que de plonger profondément dans un seul composant, il fournit une carte structurée du paysage de l'ingénierie LLM, couvrant les éléments clés que vous devez comprendre pour concevoir, entraîner et déployer des systèmes LLM dans le monde réel.

Nous passerons des fondamentaux de la représentation du texte, à travers les architectures de modèles et les stratégies d'entraînement, jusqu'à l'optimisation de l'inférence, l'évaluation, et des considérations pratiques telles que l'ingénierie des prompts et la réduction des hallucinations.

Conversion des Lettres en Nombres

Lorsque nous alimentons des données à un modèle, nous ne pouvons pas simplement lui donner des lettres ou des mots directement ; nous avons besoin d'un moyen de convertir le texte en nombres. Intuitivement, nous pourrions penser à attribuer à chaque mot de la langue un numéro unique et à alimenter ces numéros au modèle. Cependant, il y a des centaines de milliers de mots dans la langue anglaise, et s'entraîner sur un vocabulaire aussi vaste serait peu pratique en termes de mémoire et d'efficacité.

Que peut-on faire à la place ? Nous pourrions essayer de coder les lettres, puisqu'il n'y en a que 26 dans l'alphabet anglais. Mais cela poserait également des problèmes : les modèles auraient du mal à saisir le sens des mots à partir de lettres individuelles, et les séquences deviendraient inutilement longues, rendant l'entraînement difficile.

Une solution pratique est la tokenisation. Au lieu de représenter la langue au niveau des mots ou des caractères, nous divisons le texte en unités de sous-mots les plus fréquentes et utiles. Ces sous-mots agissent comme les éléments constitutifs du vocabulaire du modèle : les mots courants apparaissent sous forme de tokens entiers, tandis que les mots rares peuvent être représentés comme des combinaisons de sous-mots plus petits.

Un algorithme courant pour cela est le Byte-Pair-Encoding (BPE). Le BPE commence avec des caractères individuels comme tokens, puis fusionne de manière répétée les paires de tokens les plus fréquentes en nouveaux tokens, construisant progressivement un vocabulaire d'unités de sous-mots jusqu'à atteindre une taille de vocabulaire souhaitée.

À ce stade, chaque token se voit attribuer un numéro unique — son ID dans le vocabulaire.

Après avoir tokenisé les données et attribué des IDs de tokens, nous devons attacher une signification sémantique à ces IDs. Cela se fait par le biais des embeddings de texte — des correspondances entre des IDs de tokens discrets et des espaces vectoriels continus. Dans cet espace, les mots ou tokens ayant des significations similaires sont placés proches les uns des autres, et même des opérations algébriques peuvent capturer des relations sémantiques (par exemple : embedding(queen) - embedding(woman) + embedding(man) ≈ embedding(king)).

En général, les couches d'embedding sont entraînées pour prendre des IDs de tokens en entrée et produire des vecteurs denses en sortie. Ces vecteurs sont optimisés conjointement avec l'objectif d'entraînement du modèle (par exemple, la prédiction du prochain token). Au fil du temps, le modèle apprend des embeddings qui encodent à la fois des informations syntaxiques et sémantiques sur les mots, sous-mots ou tokens. Les modèles d'embedding populaires incluent : word2vec, glove, BERT.

Encodage Positionnel

En général, les LLMs ne sont pas intrinsèquement conscients de la structure de la langue. La langue naturelle a une nature séquentielle — l'ordre des mots compte — mais en même temps, des tokens éloignés dans une phrase peuvent être fortement liés. Pour capturer à la fois l'ordre local et les dépendances à long terme, nous injectons des informations positionnelles des tokens dans chaque embedding.

Il existe plusieurs approches courantes pour l'encodage positionnel :

• Encodages positionnels absolus — Des motifs fixes, tels que des fonctions sinusoïdales et cosinusoïdales à différentes fréquences, sont ajoutés aux embeddings de tokens. Cela est simple et efficace mais peut avoir du mal à représenter des séquences très longues, car cela ne modélise pas explicitement les distances relatives.

• Encodages positionnels relatifs — Ceux-ci représentent la distance entre les tokens au lieu de leurs positions absolues. Une méthode populaire est le RoPE (Rotary Positional Embeddings), qui encode la position sous forme de rotations vectorielles. Cette approche s'adapte mieux aux longues séquences et capture les relations entre des tokens distants de manière plus naturelle.

• Encodages positionnels appris — Au lieu de s'appuyer sur des fonctions mathématiques fixes, le modèle apprend directement les embeddings de position pendant l'entraînement. Cela permet une flexibilité mais peut être moins généralisable à des longueurs de séquences non vues lors de l'entraînement.

Architecture du Modèle

Après que les données ont été tokenisées, intégrées et enrichies d'encodages positionnels, elles sont passées à travers le modèle. L'architecture à la pointe de la technologie pour le traitement des données textuelles est l'architecture transformer, dont le noyau est basé sur le mécanisme d'attention. Un transformer se compose généralement d'une pile de blocs transformer :

• Attention Multi-Tête : Permet au modèle de se concentrer sur différentes parties de la séquence d'entrée simultanément, capturant un contexte diversifié. Il calcule les Requêtes (Q), Clés (K) et Valeurs (V) pour définir les relations entre les mots.

• Réseau Feed-Forward Positionnel (FFN) : Un réseau entièrement connecté appliqué à chaque position indépendamment, ajoutant de la non-linéarité.

• Connexions Résiduelles : Des connexions de raccourci qui aident les gradients à circuler pendant l'entraînement, empêchant la perte d'information.

• Normalisation de Couche : Normalise l'entrée pour stabiliser l'entraînement.

Le mécanisme d'attention, introduit dans le document intitulé "Attention Is All You Need", projette chaque token dans trois vecteurs : une requête (ce qu'il recherche), une clé (ce qu'il offre) et une valeur (les informations qu'il transporte). L'attention fonctionne en comparant les requêtes aux clés (via des scores de similarité) pour décider combien de chaque valeur agréger. Cela permet au modèle de tirer dynamiquement un contexte pertinent basé sur le contenu, et non sur la position.

L'attention multi-tête exécute plusieurs mécanismes d'attention en parallèle, chacun avec ses propres projections apprises. Pensez à chaque "tête" comme se concentrant sur une relation différente (par exemple, syntaxe, coréférence, sémantique). Les combiner donne au modèle une compréhension plus riche et nuancée qu'un seul passage d'attention.

Il existe plusieurs types de mécanismes d'attention qui varient en fonction de leur objectif : self-attention, masked self-attention et cross-attention.

• Self-attention opère au sein d'une seule séquence, permettant aux tokens de s'attendre mutuellement (par exemple, comprendre une phrase).

• Masked self-attention est similaire à la self-attention avec une différence clé : l'attention ne voit que les tokens passés, sans observer les futurs.

• Cross-attention connecte deux séquences, où l'une fournit des requêtes et l'autre fournit des clés/valeurs (par exemple, un décodeur s'occupant d'une entrée encodée dans la traduction). La différence clé réside dans le fait que le contexte provient de la même source ou d'une source externe.

L'attention standard compare chaque token avec chaque autre token, conduisant à une complexité quadratique O(n²). À mesure que la longueur de la séquence augmente, l'utilisation des calculs et de la mémoire augmente rapidement, rendant les contextes très longs coûteux et lents. C'est l'un des principaux goulets d'étranglement dans l'évolutivité des LLMs et un domaine de recherche actif — par exemple, en étant sélectif sur les tokens qui doivent prêter attention à d'autres tokens.

Types d'Architecture

Les tâches de modélisation du langage sont construites à l'aide de l'une des architectures transformer suivantes :

• Modèles uniquement encodeurs — Chaque token peut prêter attention à tous les autres tokens dans la séquence (attention bidirectionnelle). Ces modèles sont généralement entraînés avec le masked language modeling (MLM), où certains tokens dans l'entrée sont masqués, et la tâche consiste à les prédire. Cette configuration est bien adaptée aux tâches de classification et de compréhension (par exemple, BERT).

• Modèles uniquement décodeurs — Chaque token ne peut prêter attention qu'aux tokens qui le précèdent dans la séquence (attention causale ou unidirectionnelle). Ces modèles sont entraînés avec le causal language modeling, c'est-à-dire prédire le prochain token donné tous les précédents. Cette configuration est idéale pour la génération de texte (par exemple, GPT).

• Modèles encodeur-décodeur — La séquence d'entrée est d'abord traitée par l'encodeur, et les représentations résultantes sont ensuite alimentées dans le décodeur via des couches d'attention croisée. Le décodeur génère une séquence de sortie un token à la fois, conditionnée à la fois sur les représentations de l'encodeur et sur ses propres sorties précédentes. Cette configuration est courante pour les tâches de séquence à séquence comme la traduction automatique (par exemple, T5, BART).

Prédiction du Prochain Token et Décodage de Sortie

Les modèles sont entraînés pour prédire le prochain token — cela se fait en produisant une distribution de probabilité sur tous les tokens possibles dans le vocabulaire. La sortie du modèle est le logit qui est ensuite passé à travers le softmax pour prédire la probabilité du prochain token dans le vocabulaire.

Dans l'approche la plus simple, nous pourrions toujours choisir le token avec la probabilité la plus élevée (ceci est appelé décodage glouton). Cependant, cette stratégie est souvent sous-optimale, car le token localement le plus probable ne conduit pas toujours à la phrase la plus cohérente ou naturelle globalement.

Pour améliorer la génération, nous pouvons échantillonner à partir de la distribution de probabilité. Cela introduit de la diversité et permet au modèle d'explorer différentes continuations. De plus, nous pouvons ramifier le processus de génération en considérant plusieurs tokens candidats et en élargissant...