Architectures des LLM

Les architectures des grands modèles de langage (LLM) sont les principes fondamentaux et les structures qui déterminent la manière dont les grands modèles de langage sont construits, entraînés et fonctionnent. Les LLM modernes, capables de comprendre et de générer du langage humain, sont presque entièrement basés sur l'architecture Transformer, mais intègrent de nombreuses améliorations et approches diverses visant à accroître l'efficacité, la scalabilité et les capacités.

Familles d'architectures de LLM (Transformers)

Les grands modèles de langage modernes sont basés sur l'architecture Transformer, mais l'utilisent différemment selon l'objectif : comprendre un texte, générer une suite, ou transformer un texte en un autre. En pratique, on distingue trois familles qui conservent les principes de base du Transformer.

1. Encoder-only (encodeur seul)

Le modèle utilise uniquement une pile d'encodeurs et traite l'ensemble du texte d'entrée de manière bidirectionnelle. Le pré-entraînement est généralement basé sur le masked-language modeling (MLM) : une partie des tokens est masquée, et le modèle apprend à les reconstituer à partir de leur contexte. Grâce à ce contexte bidirectionnel, de tels modèles excellent dans les tâches de compréhension et de scoring : classification, reconnaissance d'entités nommées, reclassement de documents et QA extractif. Ils ne sont pas conçus pour la génération autorégressive « à partir de zéro ».

En pratique, d'autres objectifs de pré-entraînement sont également utilisés pour la famille encoder-only : la replaced token detection (RTD) dans ELECTRA (un modèle discriminateur identifie les tokens remplacés) et l' apprentissage contrastif de bi-encodeurs pour la recherche sémantique/récupération (InfoNCE/softmax-loss sur des paires « requête-document », comme dans Dense Passage Retrieval). Dans le cadre d'un système RAG, les modèles encoder-only agissent soit comme bi-encodeur (encodage séparé de la requête et du document pour une recherche rapide par ANN), soit comme cross-encoder (encodage conjoint de la paire pour un reclassement précis).

Avantages :

• Haute qualité de compréhension de texte grâce au contexte bidirectionnel : classification, NER, extraction de faits, reclassement, QA extractif.
• Traitement parallèle et débit élevé : une seule passe directe sans auto-régression ; pratique pour le scoring par lots de masse.
• Intégration naturelle avec la recherche et le RAG : en tant que bi-encodeur pour une recherche sémantique rapide ; en tant que cross-encoder pour un reclassement précis.
• Adaptation efficace : les variantes relativement compactes (≈100–300 millions de paramètres ; BERT-base ≈110 millions) offrent une haute qualité après un fine-tuning ciblé.
• Latence stable, indépendante de la longueur de la réponse générée (pas de décodage pas à pas) ; bien adapté pour le scoring hors ligne de grandes collections.
• Possibilité d'augmenter la fenêtre de contexte des encodeurs grâce à des positions relatives/rotationnelles et/ou une attention locale-creuse (par ex., Longformer/BigBird), ce qui est utile pour les documents longs.

Inconvénients :

• Pas de capacités génératives natives : pour les dialogues et les réponses détaillées, un décodeur ou un module génératif externe est nécessaire.
• Limité dans les scénarios interactifs : pas de génération étape par étape avec conservation de l'état.
• Inadéquation de l'objectif de pré-entraînement avec les tâches de génération libre : le MLM est moins adapté à la génération que la modélisation causale.
• Fenêtre de contexte historiquement limitée (souvent 512 tokens dans les configurations de base avec des positions absolues) ; l'extension nécessite des schémas de position/attention spécifiques et/ou un fine-tuning.
• Pour les tâches de récupération, un fine-tuning contrastif distinct du bi-encodeur et/ou du cross-encoder est requis ; sans cela, la qualité de la recherche/reclassement est généralement inférieure à celle des modèles spécialisés.

Modèles représentatifs : BERT et ses dérivés, ainsi que RoBERTa et DeBERTa (variantes étendues d'encoder-only) ; parmi les objectifs de pré-entraînement alternatifs — ELECTRA (RTD).

2. Decoder-only (décodeur seul)

Seule la pile de décodeurs avec une attention causale (de gauche à droite) est utilisée : le modèle prédit le token suivant à partir du préfixe déjà fourni. Ce mode d'entraînement — causal language modeling (CLM) — fait de ces modèles le choix naturel pour la génération : dialogues, réponses détaillées, textes créatifs, code de programmation. Le compromis est une augmentation de la latence et de la taille du cache KV pour les prompts longs. En pratique, pour les modèles decoder-only, des techniques d'ingénierie sont largement appliquées : réduction du cache KV grâce à MQA et GQA, accélération de l'inférence via le décodage spéculatif et des optimisations de serveur (PagedAttention/vLLM, continuous batching, chunked prefill).

Avantages :

• Génération de texte naturelle (CLM) : fortes capacités zero-shot et few-shot ; se met bien à l'échelle.
• Polyvalence d'application : un seul modèle résout de nombreuses tâches via des instructions et des exemples dans le prompt ; se combine naturellement avec le RAG et l'appel d'outils (tool use).
• Écosystème mature : pratiques de fine-tuning par instructions et d'alignement du comportement (RLHF, DPO) ; implémentations open source et commerciales disponibles.
• Riche pile d'optimisations d'inférence : MQA/GQA réduisent la taille du cache KV et augmentent le débit ; le décodage spéculatif accélère l'inférence sans altérer la distribution ; PagedAttention/vLLM avec continuous batching et chunked prefill améliorent l'utilisation globale du GPU.
• Prise en charge de la génération structurée pour des formats de réponse stricts (JSON/SQL/DSL), ce qui simplifie l'intégration avec les SI et les API.

Inconvénients :

• Latence de génération accrue : sortie séquentielle ; le coût d'un nouveau token augmente avec la longueur du contexte déjà « lu » (cache KV).
• Moins avantageux pour le profil « entrée longue – sortie courte » (résumé, traduction) par rapport à un encodeur-décodeur, où l'entrée est encodée une seule fois.
• Limitation par un contexte unidirectionnel : pour les tâches de compréhension, il est parfois inférieur aux modèles avec une représentation bidirectionnelle (encoder-only / encoder-décodeur).
• La mémoire pour le cache KV peut être un goulot d'étranglement avec des prompts longs et de grands lots.
• La quantification des activations/KV (INT8/FP8) accélère l'inférence, mais peut dégrader la qualité sur les contextes longs/le code ; nécessite une validation minutieuse (surtout avec des SLA stricts).

Modèles représentatifs : GPT-3, GPT-4 (détails de l'architecture et du jeu de données non divulgués publiquement), LLaMA et Llama 3 (8B/70B, 2024).

3. Encodeur-décodeur

Cette architecture combine les deux composants. L'encodeur fonctionne en mode bidirectionnel, tandis que le décodeur fonctionne de manière causale. L'encodeur analyse l'entrée une seule fois et en forme une représentation ; le décodeur génère la sortie en accédant à cette représentation via une cross-attention. Cette approche séparée est particulièrement utile lorsqu'il faut transformer un long texte d'entrée en une sortie courte : traduction automatique, résumé, réponses basées sur des documents. Bien que cette méthode nécessite des coûts de calcul globaux plus élevés (deux piles et une cross-attention), son avantage réside dans une génération contrôlée basée sur une analyse complète du texte source ; de plus, l'encodage est effectué une seule fois et réutilisé tout au long du processus d'inférence.

Avantages :

• Génération conditionnelle : le décodeur utilise la cross-attention sur la représentation de l'entrée.
• Efficace dans le scénario « entrée longue → sortie courte » : l'entrée est encodée une seule fois.
• Adapté au format « text-to-text » et à la sortie contrôlée (préfixes de tâche, instructions spéciales).
• Stabilité et efficacité avec une source longue : dans la phase de décodage, seule la self-attention sur la sortie augmente, tandis que la cross-attention réutilise les clés/valeurs fixes de l'encodeur (l'entrée n'est pas « relue » à chaque étape).

Inconvénients :

• Deux piles augmentent les besoins en mémoire et en calculs lors de l'entraînement et de l'utilisation.
• Sur des séquences très longues, la latence finale est comparable à celle des modèles decoder-only ; l'auto-régression reste un goulot d'étranglement.
• Moins de modèles de dialogue universels que parmi les decoder-only ; plus souvent utilisés comme moteurs seq2seq de haute qualité pour des tâches spécifiques.
• Avec une entrée très longue, la mémoire pour les clés/valeurs de la cross-attention dans chaque couche du décodeur augmente (sur l'ensemble de la source), ce qui nécessite une planification minutieuse du déploiement.

Modèles représentatifs : T5 (y compris T5 v1.1 et la pratique du fine-tuning par instructions dans FLAN-T5) et BART.

Transformers denses

L'architecture la plus classique et la plus répandue pour les LLM : lors du traitement de chaque token, la quasi-totalité des paramètres du modèle est sollicitée. Contrairement aux approches creuses (par exemple, Mixture-of-Experts), il n'y a pas d'activation sélective de sous-réseaux — chaque bloc fonctionne pour chaque token.

Principe de fonctionnement et architecture

Structure de base. Le modèle est une pile de N blocs Transformer identiques. Chaque bloc comprend :

1. Auto-attention multi-têtes (Multi-Head Self-Attention). Pour chaque token, trois vecteurs sont calculés : Q (query), K (key), V (value) ; l'attention est définie comme $\mathrm{softmax}\left(\frac{Q{K}^{\mathrm{\top }}+M}{\sqrt{d_k}}\right)\cdot V$, où $M$ est un masque (masque causal et/ou de padding) qui exclut les positions non autorisées. Plusieurs « têtes » d'attention traitent en parallèle différents aspects du contexte (H têtes, généralement $d_{\mathrm{h}\mathrm{e}\mathrm{a}\mathrm{d}}=\frac{d_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}}{H}$) ; leur nombre augmente avec l'échelle du modèle.
2. Réseau feed-forward (Feed-Forward Network, FFN). Deux couches linéaires avec une non-linéarité entre elles (généralement GELU/SiLU ; dans plusieurs modèles modernes, SwiGLU). La dimension intermédiaire est généralement $\approx 4d_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}$ ; avec SwiGLU, on prend souvent $\approx \frac{8}{3}{d}_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}$ pour conserver un nombre de paramètres comparable. Le FFN contient une part importante des paramètres.

Composants supplémentaires. Des connexions résiduelles (residual) et une normalisation de couche sont utilisées ; dans les LLM modernes, la Pre-LN (normalisation avant les sous-blocs) est plus fréquente — cela améliore la stabilité de l'entraînement pour les grandes profondeurs. En plus de la LayerNorm classique, la RMSNorm est de plus en plus utilisée (elle réduit les coûts de calcul et fonctionne bien dans les grands modèles) ; dans certaines familles, une normalisation dans l'espace d'attention est également appliquée (par ex., normalisation de Q/K avant le softmax). Les représentations positionnelles peuvent être absolues ou relatives ; pour les contextes longs, RoPE est devenu le standard de facto.

Exemples de modèles et échelle

• BERT-Large : 24 couches, dimension 1024, 16 têtes d'attention, ≈340 millions de paramètres.
• GPT-3 (175B) : 96 couches, dimension 12288, 96 têtes d'attention, ≈175 milliards de paramètres.
• LLaMA-65B : 80 couches, dimension 8192, 64 têtes d'attention, ≈65 milliards de paramètres.
• PaLM-540B : 118 couches, dimension d'environ 18432, ≈540 milliards de paramètres.

Avantages

• Blocs uniformes, modes d'entraînement bien étudiés et comportement prévisible lors de la mise à l'échelle.
• La qualité s'améliore selon une loi de puissance avec l'augmentation des paramètres et des données ; le régime compute-optimal suppose une augmentation conjointe de la taille du modèle et du volume de tokens d'entraînement.
• Une même architecture, après fine-tuning, couvre un large éventail de tâches sans modification au niveau des couches.

Inconvénients

• L'auto-attention complète a une complexité quadratique par rapport à la longueur de la séquence ($O(n^2)$), ce qui limite la fenêtre de contexte.
• Activation complète des paramètres à chaque étape de génération : dans un décodeur sans MoE, le coût d'inférence par token augmente à peu près proportionnellement au nombre de paramètres.
• Le goulot d'étranglement est la bande passante mémoire (memory-bound) : le chargement des poids depuis la HBM limite souvent la vitesse d'inférence.

Limites de la scalabilité et du contexte

• La mémoire pour les paramètres augmente linéairement avec la taille du modèle ; la mémoire d'entraînement augmente en raison des gradients et des états de l'optimiseur.
• Les configurations de base étaient historiquement limitées à 2-4 mille tokens. Les schémas positionnels modernes (RoPE) et les techniques d'extension (Position Interpolation, YaRN, etc.) permettent d'augmenter la fenêtre d'un ordre de grandeur ou plus, mais au prix d'une charge de calcul/mémoire supplémentaire.

Optimisations modernes

• FlashAttention. Attention exacte tenant compte de la hiérarchie de la mémoire du GPU ; réduit les coûts de mémoire et accélère l'entraînement/inférence sur de longues séquences.
• Réduction et gestion du cache KV. Multi-Query Attention et Grouped-Query Attention réduisent le volume du cache et le trafic mémoire ; au niveau du serveur, PagedAttention (vLLM) augmente le débit grâce à une gestion paginée du cache.
• Décodage spéculatif. Un modèle brouillon (draft) propose une continuation, et le modèle principal la vérifie rapidement ; on obtient une accélération sans modifier la distribution de la sortie.

Modèles creux (Sparse Models) et Mixture-of-Experts (MoE)

MoE est un moyen d'augmenter la capacité d'un modèle sans augmenter proportionnellement les calculs par token. Au lieu d'un seul grand bloc FFN dans une couche, un ensemble d'« experts » parallèles (plusieurs FFN indépendants) est utilisé, et un routeur entraînable (gating network) sélectionne pour chaque token les top-k experts les plus pertinents (généralement k=1–2 ; dans certains modèles k=4). Seuls les experts sélectionnés sont activés ; leurs sorties sont pondérées et additionnées. Ainsi, le nombre total de paramètres peut atteindre des centaines de milliards, voire des trillions, mais seule une petite fraction est utilisée à chaque étape.

Exemples de modèles et échelle

• Switch Transformer (Google) : jusqu'à ~1.6T de paramètres ; routage top-1 (un expert par token). A montré que les MoE permettent d'augmenter considérablement la capacité pour un coût par token comparable.
• GLaM (Google) : 1.2T de paramètres, 64 experts par couche, top-2 ; pour chaque token, ≈96.6B de paramètres sont activés (≈8%).
• Mixtral 8×7B (Mistral AI) : ~46.7B de paramètres au total, ≈12.9B actifs par token, top-2.
• Mixtral 8×22B : ~141B de paramètres au total, ≈39B actifs par token, top-2.
• DBRX (Databricks) : 132B de paramètres au total, ≈36B actifs par token ; 16 experts et routage top-4 (fine-grained MoE).

Avantages

• Le coût des calculs est déterminé par le nombre d'experts actifs k, et non par le nombre total de paramètres : il est possible d'entraîner et d'utiliser des modèles à l'échelle du trillion avec des coûts comparables à ceux de modèles denses de taille nettement inférieure.
• Spécialisation : les experts s'« ajustent » automatiquement aux langues/domaines/patterns, améliorant la qualité dans les tâches multi-domaines.
• Déploiement flexible : il est possible de garder en mémoire les experts fréquemment utilisés et de charger les plus rares (avec une infrastructure appropriée).

Limites

• Équilibrage de la charge : sans régularisation, le routeur peut « se bloquer » sur un sous-ensemble d'experts (router collapse). Des pertes auxiliaires (load-balancing) et des schémas de routage améliorés sont nécessaires.
• Complexité des calculs distribués : un parallélisme d'experts et des échanges all-to-all sont requis ; les coûts de communication et la gestion de la mémoire deviennent des goulots d'étranglement.
• Stabilité de l'entraînement : les réglages du routeur et les limites de capacité sont cruciaux, sinon des dégradations de qualité/convergence sont possibles.

Améliorations modernes

• Routage Expert-Choice : les experts « choisissent » les tokens, ce qui améliore l'équilibrage de la charge et la convergence pour des coûts comparables.
• MoE à grain fin (Fine-grained MoE) : un plus grand nombre d'experts plus petits (comme dans DBRX) offre une granularité de spécialisation plus fine.
• Sparse Upcycling : transformer un modèle dense en MoE à partir de son checkpoint permet d'augmenter considérablement la qualité à un coût modéré.

Pertinence de l'utilisation des MoE

• Grands assistants multi-domaines avec un budget de calcul limité.
• Entraînement sur de vastes corpus où la spécialisation offre un avantage.
• Scénarios avec une infrastructure distribuée développée (nombreux GPU/TPU et réseaux rapides).

Quand les modèles denses sont-ils préférables : infrastructure limitée (1-2 GPU), exigences strictes en matière de latence prévisible et de simplicité de déploiement.

Retrieval-Augmented Generation (RAG)

RAG est un modèle d'architecture de système autour d'un LLM, et non une architecture interne du modèle lui-même. Il combine un LLM (composant génératif) avec une base de connaissances externe (composant de récupération), ce qui permet de compenser les limites de la « mémoire paramétrique » du modèle.

• Principe de fonctionnement : Avant de générer une réponse, le LLM récupère des documents pertinents d'une source externe (wiki, base de connaissances d'entreprise, web) et s'appuie sur eux pour formuler sa réponse.
• Avantages :
  • Réduction des hallucinations et amélioration de la précision factuelle.
  • Pertinence sans réentraînement complet du modèle.
  • Citabilité et traçabilité des réponses.
• Application : Standard de facto pour les assistants d'entreprise et les systèmes nécessitant des faits vérifiables et travaillant avec des données privées/spécialisées.

Mécanismes d'attention et gestion du contexte

L'auto-attention de base a une complexité quadratique par rapport à la longueur de la séquence ($O(n^2)$), c'est pourquoi des optimisations ont été développées.

• Attention creuse (Sparse Attention) : Limitation de l'attention à des fenêtres/motifs locaux. Exemples : Longformer, BigBird.
• FlashAttention : Réorganisation des calculs en tenant compte de la hiérarchie de la mémoire du GPU ; offre un gain significatif en temps et en mémoire et est devenu le standard de facto pour l'entraînement des LLM avec un long contexte.
• MQA/GQA (accélération du décodage) : Multi-Query Attention (clés/valeurs partagées pour toutes les têtes) réduit le trafic du cache KV. Grouped-Query Attention équilibre qualité/vitesse.
• Représentations positionnelles améliorées :
  • ALiBi (Attention with Linear Biases) : Des biais linéaires ajoutés aux scores d'attention améliorent la généralisation à des longueurs plus importantes.
  • RoPE (Rotary Position Embeddings) : Information positionnelle relative via la rotation de Q/K ; largement utilisé dans les modèles modernes (par exemple, LLaMA).
  • Extension du contexte pour les modèles RoPE : Position Interpolation , YaRN , ainsi que les modifications NTK-aware, permettent d'augmenter efficacement la fenêtre de contexte sans changer l'architecture.

• Autres approches pour les longues séquences :
  • Transformer-XL : Mémoire récurrente entre les segments pour modéliser les dépendances à longue distance.
  • Reformer : LSH-attention et blocs résiduels réversibles pour économiser la mémoire.
  • Performer : Approximation linéaire de l'attention softmax (FAVOR+).
  • Linformer : Approximation de bas rang de la matrice d'attention.

Optimisations des modèles et infrastructure d'entraînement

Pour l'entraînement et le déploiement des LLM, des techniques et des frameworks spécialisés sont utilisés.

• Quantification (Quantization) : La réduction de la précision des poids diminue la mémoire et accélère l'inférence. QLoRA permet de fine-tuner efficacement des modèles 4 bits (y compris des modèles 65B) avec une qualité proche de la pleine précision.
• Distillation de connaissances (Knowledge Distillation) : Entraînement Teacher→Student pour des modèles compacts ; exemple — DistilBERT.
• Entraînement distribué :
  • DeepSpeed et ZeRO — distribution des paramètres/gradients/états de l'optimiseur pour l'entraînement de modèles de plusieurs trillions de paramètres.
  • Megatron-LM — parallélisme tensoriel et de pipeline pour les très grands transformeurs.
• Écosystème et outils : Hugging Face Transformers et Accelerate fournissent des implémentations standard de modèles et une intégration avec DeepSpeed/FSDP pour l'entraînement et l'inférence.

Lois d'échelle et entraînement compute-optimal

Les lois d'échelle empiriques montrent que l'erreur de cross-entropie diminue selon une loi de puissance avec l'augmentation des paramètres, des données et des calculs. Les travaux sur Chinchilla ont précisé les régimes compute-optimal : pour une efficacité optimale, la taille du modèle et le nombre de tokens d'entraînement doivent être mis à l'échelle conjointement (par exemple, un modèle de 70B entraîné sur ~1.4T de tokens surpasse des modèles plus grands mais sous-entraînés).

Modèles à espace d'états (State Space Models, SSM)

Les State Space Models (SSM) sont une architecture alternative aux Transformers pour le traitement de longues séquences. Elle s'inspire des idées de la théorie du contrôle et du traitement numérique du signal et résout le principal problème de l'auto-attention : la croissance quadratique des calculs avec l'augmentation de la longueur du texte.

Le problème principal et sa solution

Problème des Transformers. Le principal problème des Transformers traditionnels est la complexité quadratique de l'attention : un texte 10 fois plus long nécessite environ 100 fois plus de calculs.

Approche SSM. Au lieu d'une « attention simultanée à tous les mots », le modèle parcourt le texte séquentiellement et maintient un état de mémoire interne compact, qui est mis à jour à chaque étape. En conséquence, le temps et la consommation de mémoire augmentent de manière à peu près linéaire avec la longueur du texte. Cependant, l'entraînement peut être effectué en parallèle — via une représentation convolutionnelle du noyau (débit élevé sur de longues séquences).

Principe de fonctionnement

Un SSM discret est décrit par les équations d'état et de sortie :

$x_t=A{x}_{t-1}+B{u}_t,y_t=C{x}_t+D{u}_t$

où $x_t$ est l'état de la mémoire, $u_t$ est l'entrée (token), et $y_t$ est la sortie. Dans les SSM profonds, les matrices $A,B,C,D$ sont paramétrées pour assurer la stabilité et des calculs efficaces sur de longues séquences. La même couche peut être considérée comme :

• récurrente (balayage par étapes) — inférence économe en mémoire sans cache KV ;
• convolutionnelle — entraînement parallèle avec un noyau précalculé.

Architectures principales et hybrides

• S4 (Structured State Spaces). La ligne de base des SSM avec une paramétrisation stable de la matrice d'état ; démontre son efficacité sur de très longues séquences.
• Mamba. SSM sélectifs : les règles de mise à jour de la mémoire dépendent de l'entrée actuelle (le modèle décide lui-même ce qu'il faut « garder en mémoire » et ce qu'il faut « oublier »). L'implémentation est orientée vers la hiérarchie de la mémoire du GPU ; selon les auteurs, elle atteint une augmentation multiple du débit d'inférence avec une complexité linéaire par rapport à la longueur.
• RetNet. Mécanisme de rétention avec trois modes : entraînement parallèle, inférence récurrente et inférence bloc-récurrente. L'objectif est de combiner un entraînement rapide (comme les Transformers) avec une inférence économe (mémoire O(1) par token).
• Hybrides Attention+SSM. Exemple — Jamba (alternance de couches Transformer et Mamba plus MoE) : rapporte la prise en charge de contextes de l'ordre de ~256K tokens avec des besoins en mémoire nettement inférieurs par rapport aux modèles purement Transformer de classe similaire.

Avantages

• Complexité linéaire et économie de mémoire à l'inférence. Pas d'auto-attention globale ni de cache KV ; seul un état compact est conservé.
• Entraînement parallèle sur de longues séquences. Le mode convolutionnel augmente le débit de l'entraînement.
• Efficacité matérielle. Les implémentations sont orientées vers la hiérarchie de mémoire moderne (HBM/SRAM).
• Contextes longs et streaming. Les hybrides SSM+Attention sont pratiques pour des centaines de milliers de tokens avec des ressources modérées.

Limites et pratiques actuelles

• Maturité de l'écosystème. Les outils et les « recettes » de mise à l'échelle (instructions, RLHF/DPO) sont encore en retard par rapport à la pile Transformer.
• Qualité et stabilité. Sur certaines tâches, les hybrides (Attention+SSM) montrent un compromis « qualité/vitesse/mémoire » plus stable que les SSM « purs ».

Comparaison des approches (généralisée)

Caractéristique	Transformers	SSM	Hybrides (Attention+SSM)
Complexité par rapport à la longueur	Quadratique (self-attention)	Linéaire (scan/convolution)	Proche de linéaire
Mémoire par token (inférence)	Le cache KV croît avec le contexte	État en O(1)	Croissance modérée
Contextes longs	Nécessite des optimisations spécifiques	Support natif	Praticables jusqu'à ~256 K
Maturité de l'écosystème	Élevée	En développement	En développement

Applications pratiques

• Analyse de documents très longs (livres, rapports, revues scientifiques).
• Traitement en flux continu et scénarios de chat avec un long historique sans augmentation du coût mémoire.
• Environnements aux ressources limitées (appareils mobiles/edge).
• Séries temporelles et autres données séquentielles.

Modèles représentatifs : S4, Mamba, RetNet ; hybrides Attention+SSM (Jamba).

Évolution des architectures

• 2017 — Publication de l'article « Attention Is All You Need ». L'architecture Transformer est présentée : l'auto-attention multi-têtes et les encodages positionnels permettent d'entraîner des modèles sans récurrence ni convolution ; cependant, l'attention a une complexité quadratique par rapport à la longueur du contexte.

• 2018 — Présentation de GPT-1 et BERT. GPT-1 utilise une pile de décodeurs seuls avec attention causale pour la génération et le fine-tuning ultérieur ; BERT introduit un encodeur bidirectionnel et un pré-entraînement MLM pour les tâches de compréhension de texte.

• 2019 — Des méthodes pour traiter les longues séquences sont proposées et le decoder-only est mis à l'échelle. Transformer-XL ajoute une « mémoire » et des positions relatives pour dépasser la fenêtre fixe ; GPT-2 montre une augmentation des capacités zero-shot avec l'échelle ; BART démontre l'efficacité du pré-entraînement par débruitage pour le seq2seq.

• 2020 — Le format « text-to-text » est unifié et des méthodes pour les documents longs sont démontrées. T5 formule une approche unifiée encodeur-décodeur pour différentes tâches ; Longformer et BigBird utilisent une attention creuse/structurée pour les textes longs ; GPT-3 confirme l'efficacité de la mise à l'échelle d'un decoder-only dense.

• 2021 — Les représentations positionnelles sont améliorées et la creusité des paramètres (MoE) est démontrée. RoPE et ALiBi améliorent la généralisation sur de grandes longueurs ; Switch Transformer et GLaM n'activent qu'une partie des experts par token, augmentant la capacité sans une augmentation proportionnelle du coût d'inférence.

• 2022 — Le régime compute-optimal est précisé et l'inférence sur de longs prompts est accélérée. Chinchilla montre l'avantage d'un plus grand nombre de tokens d'entraînement pour une taille de modèle modérée ; PaLM avec Multi-Query Attention réduit le volume du cache KV ; FlashAttention accélère l'attention sur GPU.

• 2023 — Les fenêtres de contexte sont augmentées sans modification des couches et le service côté serveur est amélioré. La gamme LLaMA consolide les pratiques (RMSNorm, SwiGLU, RoPE) ; Position Interpolation et YaRN étendent le contexte ; vLLM/PagedAttention gère plus efficacement le cache KV.

• 2023 — GPT-4 et Gemini montrent le traitement et la génération multi-modaux au sein d'une même famille de modèles.

• 2023 — Des modèles à espace d'états (SSM) sont proposés. Mamba et RetNet réintroduisent le traitement séquentiel avec un état compact au lieu du cache KV et jettent les bases des architectures hybrides.

• 2024 — Des modèles MoE open source et des hybrides Attention+SSM sont publiés ; l'attention sur les nouveaux GPU est accélérée. Mixtral 8×7B/8×22B et DBRX confirment la praticité des MoE ; Jamba combine Transformer et Mamba pour des contextes très longs ; FlashAttention-3 augmente le débit.

Liens

• https://jalammar.github.io/illustrated-transformer/ The Illustrated Transformer — une explication visuelle

Bibliographie

• Vaswani, A. et al. (2017). Attention Is All You Need. NIPS. https://arxiv.org/abs/1706.03762
• Devlin, J. et al. (2019). BERT. NAACL. https://arxiv.org/abs/1810.04805
• Brown, T. et al. (2020). Language Models are Few‑Shot Learners. NeurIPS. https://arxiv.org/abs/2005.14165
• Raffel, C. et al. (2020). Exploring the Limits of Transfer Learning with a Unified Text‑to‑Text Transformer (T5). JMLR. https://jmlr.org/papers/volume21/20-074/20-074.pdf
• Lewis, M. et al. (2019). BART: Denoising Sequence‑to‑Sequence Pre‑training. https://arxiv.org/abs/1910.13461
• Touvron, H. et al. (2023). LLaMA. https://arxiv.org/abs/2302.13971
• Chowdhery, A. et al. (2022). PaLM: Scaling Language Modeling with Pathways. https://arxiv.org/abs/2204.02311
• Dao, T. et al. (2022–2024). FlashAttention (1/2/3). https://arxiv.org/abs/2205.14135 ; https://arxiv.org/abs/2307.08691 ; https://arxiv.org/abs/2407.08608
• Shazeer, N. (2019). MQA. https://arxiv.org/abs/1911.02150
• Ainslie, J. et al. (2023). GQA. https://arxiv.org/abs/2305.13245
• Kwon, W. et al. (2023). PagedAttention / vLLM. https://arxiv.org/abs/2309.06180
• Leviathan, Y. et al. (2023). Speculative Decoding. https://arxiv.org/abs/2211.17192
• Fedus, W.; Zoph, B.; Shazeer, N. (2021/2022). Switch Transformers. https://arxiv.org/abs/2101.03961
• Du, N. et al. (2022). GLaM. https://proceedings.mlr.press/v162/du22c/du22c.pdf
• Jiang, A.Q. et al. (2024). Mixtral of Experts. https://arxiv.org/abs/2401.04088
• Databricks (2024). Introducing DBRX. https://www.databricks.com/blog/introducing-dbrx-new-state-art-open-llm
• NVIDIA (2024). Applying Mixture of Experts in LLM Architectures. https://developer.nvidia.com/blog/applying-mixture-of-experts-in-llm-architectures/
• Zhou, Y. et al. (2022). Expert Choice Routing. https://arxiv.org/abs/2202.09368
• Komatsuzaki, A. et al. (2022). Sparse Upcycling. https://arxiv.org/abs/2212.05055
• Lewis, P. et al. (2020). RAG. https://arxiv.org/abs/2005.11401
• Beltagy, I. et al. (2020). Longformer. https://arxiv.org/abs/2004.05150
• Zaheer, M. et al. (2020). BigBird. https://arxiv.org/abs/2007.14062
• Press, O. et al. (2022). ALiBi. https://arxiv.org/abs/2108.12409
• Su, J. et al. (2021). RoFormer (RoPE). https://arxiv.org/abs/2104.09864
• Chen, S. et al. (2023). Position Interpolation. https://arxiv.org/abs/2306.15595
• Peng, B. et al. (2023). YaRN. https://arxiv.org/abs/2309.00071
• Dettmers, T. et al. (2023). QLoRA. https://arxiv.org/abs/2305.14314
• Rajbhandari, S. et al. (2020). ZeRO. https://www.microsoft.com/en-us/research/publication/zero-memory-optimizations-toward-training-trillion-parameter-models/
• Shoeybi, M. et al. (2019). Megatron‑LM. https://arxiv.org/abs/1909.08053
• Kaplan, J. et al. (2020). Scaling Laws. https://arxiv.org/abs/2001.08361
• Hoffmann, J. et al. (2022). Chinchilla / Compute‑Optimal. https://arxiv.org/abs/2203.15556
• Gemini Team (2023). Gemini. https://arxiv.org/abs/2312.11805
• Bai, Y. et al. (2022). Constitutional AI. https://arxiv.org/abs/2212.08073
• OpenAI (2023). GPT‑4 Technical Report. https://arxiv.org/abs/2303.08774
• OpenAI (2023). DevDay: GPT‑4 Turbo 128k. https://openai.com/index/new-models-and-developer-products-announced-at-devday/
• Zhang, B.; Sennrich, R. (2019). RMSNorm. https://arxiv.org/abs/1910.07467
• Shazeer, N. (2020). GLU Variants / SwiGLU. https://arxiv.org/abs/2002.05202
• Gu, A.; Goel, K.; Ré, C. (2021). S4: Structured State Spaces. https://arxiv.org/abs/2111.00396
• Gu, A.; Dao, T. (2023/2024). Mamba: Selective State Spaces. https://arxiv.org/abs/2312.00752
• Sun, Y. et al. (2023). RetNet. https://arxiv.org/abs/2307.08621
• Lieber, O. et al. (2024). Jamba: Hybrid Transformer‑Mamba. https://arxiv.org/abs/2403.19887
• Dai, Z. et al. (2019). Transformer‑XL. https://arxiv.org/abs/1901.02860
• Kitaev, N.; Kaiser, L.; Levskaya, A. (2020). Reformer. https://arxiv.org/abs/2001.04451
• Choromanski, K. et al. (2021). Performer. https://arxiv.org/abs/2009.14794
• Wang, S. et al. (2020). Linformer. https://arxiv.org/abs/2006.04768