Retour au blog
Articles

De 512 à un million de tokens : comment le contexte des LLM s’est agrandi

Quelques zéros suffiraient pour lire tout un roman ? Il faut encore gérer les positions, terminer les calculs et réussir le contrôle de lecture. Un million de tokens, cela fait plusieurs factures.

Au départ, rien de bien compliqué : vous vouliez simplement lire un roman.

Puis les personnages se sont multipliés, et les indices semés au début ont commencé à vous échapper.

Alors vous vous êtes dit : fabriquons un modèle de langage ! (Enfin, non.)

Classer un texte, déterminer si deux phrases sont liées, trouver une réponse dans un passage : ces tâches peuvent partager un même point de départ pour l'apprentissage. BERT, publié par Google en octobre 2018, a été un modèle important pour la compréhension du texte dans cette démarche. Son encodeur Transformer transforme le texte en représentations utilisables par différentes tâches. Article BERT

Le processus consiste à préentraîner sur de grandes quantités de texte non annoté, puis à affiner pour une tâche précise. Pour la classification, on ajoute une couche de sortie adaptée ; pour la compréhension écrite, on prédit la position de la réponse dans le passage. Pendant l'affinage, les poids de cette couche et ceux de BERT sont mis à jour ensemble. Chaque tâche peut partir des mêmes poids préentraînés et entraîner séparément son propre modèle. BERT §3, Figure 1

Avant BERT, GPT utilisait déjà le préentraînement puis l'affinage d'un Transformer. L'apport central de BERT est le préentraînement bidirectionnel, qui permet aux représentations d'exploiter le contexte à gauche comme à droite. L'article rapportait alors les meilleurs résultats sur onze tâches de traitement automatique du langage. Article GPT §3, BERT, résumé et §1

La base est prête. Quand un ingénieur confie un document un peu consistant au BERT standard, il constate vite que les 512 tokens sont épuisés avant la fin du document.

Ensuite, les fiches techniques ont commencé à afficher 32K, 128K, un million ; les rapports de recherche ont même atteint dix millions. Les chiffres montaient, comme si quelqu'un avait simplement oublié quelques zéros dans le fichier de configuration.

Si c'était aussi facile, les fabricants de GPU auraient probablement vendu beaucoup moins de cartes graphiques.

De 512 à un million, la séquence devient environ 1 953 fois plus longue. Si l'on relève simplement la limite, comment les paramètres de position, le calcul de l'attention et les données d'entraînement vont-ils suivre ?

Avant d'ajouter ces zéros, cherchons où se trouve le verrou des 512 tokens.

Où se trouve le verrou des 512 tokens ?

512 tokens, est-ce 512 caractères ? Tout dépend du découpage du tokenizer.

Un token est une unité produite par un tokenizer : un caractère, un fragment de mot ou un signe de ponctuation, par exemple. Deux tokenizers peuvent découper un même texte différemment. On ne peut donc pas convertir 512 tokens en un nombre fixe de caractères chinois.

L'ensemble des tokens auxquels un modèle peut se référer dans un calcul est généralement appelé sa fenêtre de contexte. Pour un modèle génératif, la consigne, les documents joints et le texte déjà généré peuvent tous l'occuper. Un produit peut aussi imposer des limites distinctes à l'entrée et à la sortie.

Une fois le texte découpé en identifiants de tokens, le modèle remplace chaque identifiant par une suite de nombres, son plongement lexical. Ces nombres décrivent le contenu ; il faut fournir séparément l'information de position.

L'entrée de BERT a besoin du contenu, mais aussi de sa position. Son implémentation standard prépare une table de plongements positionnels appris, avec un vecteur pour la position 0, un autre pour la position 1, et ainsi de suite. La configuration originale prévoit 512 positions, jusqu'à l'indice 511. BERT §3, modeling.py officiel

Le 513ᵉ token arrive. Il lui faut le vecteur de la position 512, mais cette ligne manque dans la table d'origine.

POSITION TABLE512 places. Un invité de plus.

Le 513ᵉ token demande l’indice 512. La table initiale s’arrête à 511.

Les symboles spéciaux comme [CLS] et [SEP] occupent aussi des places. Le panneau annonce « capacité : 512 personnes », mais le personnel est déjà assis à l'intérieur.

Comment les positions ajoutées vont-elles apprendre leur travail ?

On peut agrandir la table, initialiser les nouvelles positions, puis réentraîner ou affiner le modèle. Ces nouvelles lignes de paramètres doivent encore apprendre à fonctionner. On modifie à la fois les positions disponibles et l'étendue des données à traiter. La limite a changé ; le modèle doit encore s'adapter aux nouvelles positions.

L'article de BERT indique aussi que 90 % des étapes de préentraînement utilisaient une longueur de 128 et que seules les dernières 10 % utilisaient 512. Le coût élevé de l'attention sur les longues séquences en était une des raisons. BERT annexe A.2

La limite de 512 bute donc à la fois sur les positions et l'entraînement, et sur le calcul et la mémoire. Réglons les adresses avant de revenir aux cartes graphiques.

BERT lit le texte et produit des représentations avec un encodeur bidirectionnel. Les LLM génératifs courants utilisent un décodeur à masque causal pour produire la suite à partir du texte précédent. Tous rencontrent les problèmes de position et de calcul des longues séquences ; les modèles à contexte long présentés ensuite ont chacun leur architecture et leur origine d'entraînement.

Sans table de positions, comment garder les adresses ?

Prenons deux phrases : « La boîte contient la clé » et « La clé contient la boîte ». Les mots sont les mêmes, mais le contenant a changé. La deuxième clé doit être assez impressionnante.

Dans une auto-attention sans signal de position ni masque causal, permuter les entrées permute les sorties correspondantes. On appelle cela l'équivariance aux permutations. Les calculs liés au contenu suivent ce contenu, mais il manque encore au modèle l'indice « où ce mot était-il placé ? ». Le masque causal d'un modèle génératif fournit une direction de visibilité ; laissons-le de côté pour examiner le rôle des seuls signaux positionnels. Transformer §3.2–3.5

CONTENT + POSITIONMêmes mots, positions différentes
p = 0p = 1p = 2
S1
BoîteA—
contientB—
CléC—
S2
CléC—
contientB—
BoîteA—

Exemple d’entrée : une boîte contient une clé, puis une clé contient une boîte. Les vecteurs A, B, C suivent les mêmes mots. Avec la position, la boîte reçoit A+P0 dans la première phrase et A+P2 dans la seconde. Chaque groupe est une position illustrative ; la tokenisation réelle peut être plus fine.

Le schéma traite les trois groupes de mots comme trois cartes ; le découpage réel peut être plus fin. Le vecteur de contenu de la boîte est A : déplacé à l'autre bout, il reste A. Combiné au vecteur de position, il devient pourtant A + P₀ dans la première phrase et A + P₂ dans la seconde. Le même contenu possède maintenant un emplacement différent.

C'est le principe du codage positionnel absolu additif. Le plongement du token xpx_p et le vecteur de position PpP_p ont la même dimension ; on les additionne avant l'entrée dans le modèle :

x~p=xp+Pp\widetilde x_p=x_p+P_p

Une fois les vecteurs de position mêlés à l'entrée, le modèle apprend à utiliser ces signaux. Nous n'avons pas réservé une dimension particulière au numéro de page.

BERT place les vecteurs de chaque position dans une table apprise. Pour éviter d'apprendre ces paramètres ligne par ligne, il faut une autre façon de les produire.

Le Transformer de 2017, antérieur à BERT, produisait déjà directement ces vecteurs à l'aide de sinus et de cosinus de fréquences différentes. Transformer §3.5

Pourquoi dessiner plusieurs ondes pour une position ?

Les positions sont simplement 0, 1, 2. L'idée la plus immédiate consiste à donner cet entier en entrée.

Un indice unique fournit un seul nombre. Nous souhaitons aussi des signaux qui facilitent l'utilisation des variations entre positions voisines et des distances à plusieurs échelles. Le codage sinusoïdal envoie donc une même position dans plusieurs fonctions qui évoluent à des vitesses différentes.

Commençons par examiner isolément la paire [sin⁡(pω),cos⁡(pω)][\sin(p\omega),\cos(p\omega)]. p est la position ; ω détermine l'avancée de phase pour un pas. La phase indique où l'on se trouve sur l'onde : une avancée de 2π radians accomplit un cycle. Avec un grand ω, la courbe varie vite ; avec un petit ω, elle varie lentement. Le même p fournit des valeurs différentes selon la fréquence.

SINUSOIDAL / d_model = 8Une position, quatre valeurs
P0[0:4]4 dimensions sur 8
[0]
0.00
[1]
1.00
[2]
0.00
[3]
1.00

Exemple sinusoïdal à huit dimensions, limité aux dimensions 0–3. Les fréquences 1 et 0.1 donnent les paires sin et cos aux positions 0–7 ; les quatre autres dimensions sont omises. Valeurs calculées et arrondies à deux décimales.

Quand le curseur traverse cette plage, l'onde rapide a parcouru un cycle entier, tandis que l'onde lente a peu avancé. Les quatre nombres en dessous sont les valeurs sin et cos prélevées sur deux paires, puis rangées dans le vecteur. Ce petit exemple utilise dmodel=8d_{\text{model}}=8 et montre les quatre premières dimensions ; les quatre autres font toujours partie du codage complet.

L'article original regroupe les dimensions par paires :

Pp,2i=sin⁡(pωi)Pp,2i+1=cos⁡(pωi)ωi=10000−2i/dmodel\begin{aligned} P_{p,2i}&=\sin(p\omega_i)\\ P_{p,2i+1}&=\cos(p\omega_i)\\ \omega_i&=10000^{-2i/d_{\text{model}}} \end{aligned}

i numérote les paires à partir de 0 ; dmodeld_{\text{model}} est la dimension totale du vecteur positionnel d'entrée. L'exemple à huit dimensions comporte quatre paires, de fréquences 1, 0.1, 0.01 et 0.001 ; le schéma montre les deux premières. Il reste une seule position p, décrite à plusieurs échelles. Transformer §3.5

Pourquoi associer cos à sin ? Une même valeur d'une seule onde peut apparaître à plusieurs phases ; la paire permet de décrire la phase conjointement. Plus utile encore, les formules d'addition des angles permettent de mettre à jour chaque paire sin/cos par une même transformation linéaire bidimensionnelle lorsqu'on décale toutes les positions d'un nombre de pas fixe. Le modèle dispose ainsi d'une structure pour exploiter les déplacements relatifs. Transformer §3.5

Après addition au contenu et projection, quelles relations de position restent dans les scores d'attention ?

Connaître la page ou connaître la distance

Le modèle cherche la clé depuis le dernier chapitre. « La réponse est page 3 » donne une position absolue ; « la réponse est 20 pages avant moi » donne une position relative. Ajoutez une préface : tous les numéros de page changent, mais la distance entre deux indices peut rester identique.

Présentons les trois rôles de l'attention. Trois projections apprises transforment le vecteur caché de chaque position en Query, Key et Value :

  • Query (Q, requête) : le vecteur avec lequel cette position se compare aux autres.
  • Key (K, clé) : le vecteur proposé par une autre position pour cette comparaison.
  • Value (V, valeur) : le vecteur de contenu agrégé avec les poids obtenus.

Imaginons provisoirement la question finale comme Q, les repères des passages comme K, et le contenu associé comme V. En pratique, ce sont des vecteurs numériques appris, sans champ « emplacement de la clé » rempli à la main. Q et K donnent un score par produit scalaire, c'est-à-dire en multipliant les composantes correspondantes puis en les additionnant. L'attention multi-tête emploie plusieurs ensembles de projections et de comparaisons ; suivons ici une seule tête. Transformer §3.2

Si l'on ajoute d'abord la position au contenu, que mélange le produit scalaire de Q et K ? Prenons des projections identité et un seul nombre, avec le contenu 2 et la position 1 d'un côté, le contenu 3 et la position 4 de l'autre.

ADDITIVE PE / A = 1L’addition crée quatre interactions
x: contenuP: position
xn = 3Pn = 4
xm = 22 × 362 × 48
Pm = 11 × 331 × 44
(2 + 1)(3 + 4)= 6 + 8 + 3 + 4 = 21

Après mélange, le produit scalaire vaut (2+1)(3+4)=21(2+1)(3+4)=21. Le développement donne quatre termes : 6 pour contenu–contenu, 8 pour contenu–position, 3 pour position–contenu et 4 pour position–position.

Le modèle réel comporte aussi des matrices de projection. En notant leur composition A=WQ⊤WKA=W_Q^\top W_K, on retrouve les quatre types d'interaction :

qm⊤kn=(xm+Pm)⊤A(xn+Pn)=xm⊤Axn⏟contenu-contenu+xm⊤APn⏟contenu-position+Pm⊤Axn⏟position-contenu+Pm⊤APn⏟position-position\begin{aligned} &q_m^\top k_n\\ &=(x_m+P_m)^\top A(x_n+P_n)\\ &=\underbrace{x_m^\top Ax_n}_{\text{contenu-contenu}}\\ &\quad+\underbrace{x_m^\top AP_n}_{\text{contenu-position}}\\ &\quad+\underbrace{P_m^\top Ax_n}_{\text{position-contenu}}\\ &\quad+\underbrace{P_m^\top AP_n}_{\text{position-position}} \end{aligned}

Les propriétés des seuls vecteurs de position ne racontent donc qu'une partie de l'histoire. Les scores réels entre Q et K comprennent aussi les interactions entre contenu et position. Ce développement aide les recherches ultérieures à examiner quels termes doivent porter l'information positionnelle et sous quelle forme. RoFormer §2.2–2.3, Equation 6

L'article de Su Jianlin, « Le codage positionnel des Transformers, un casse-tête pour les chercheurs » (2021), rassemble ces perspectives de conception et constitue une lecture complémentaire utile. Pour comparer d'autres choix, on peut suivre les travaux originaux qu'il cite.

Peut-on organiser le calcul pour que le changement dû à la position entre directement dans le score par le déplacement relatif ?

En 2021, RoFormer propose le Rotary Position Embedding, ou RoPE. Il calcule d'abord Q et K, regroupe leurs dimensions par paires, puis fait tourner chaque vecteur bidimensionnel selon sa position. Il s'agit des dimensions effectivement tournées dans chaque tête, à distinguer de la dimension du vecteur positionnel d'entrée évoquée plus haut. RoFormer §3.1–3.2

Notons R(θ)R(\theta) une rotation bidimensionnelle. Pour une paire de fréquence ω, la position m tourne de mω et la position n de nω. Fixons les vecteurs de contenu projetés q et k, et regardons cette seule rotation. Faire tourner les deux vecteurs en sens inverse de mω conserve leur produit scalaire : q retrouve sa direction initiale et k garde un angle (n−m)ω :

(R(mω)q)⊤(R(nω)k)=q⊤R((n−m)ω)k\begin{aligned} & (R(m\omega)q)^\top(R(n\omega)k)\\ &=q^\top R((n-m)\omega)k \end{aligned}

Le membre de droite contient n−mn-m. Décaler les deux positions ensemble conserve cette différence et la relation relative introduite par la rotation. Le contenu q et k continue à participer au score. RoFormer §3.2, Equations 13–16

RoPE / q = k = (0,1)Deux horloges, une distance relative

Avec q=k=(0,1) fixes, les positions se déplacent ensemble et gardent un écart de 2. Pour les fréquences 1 et 0.1, les produits scalaires restent cos(2)≈−0.416 et cos(0.2)≈0.980. Seul l’effet de rotation sur un contenu fixe est illustré.

Le schéma fixe q=k=(0,1)q=k=(0,1) : les deux aiguilles ont la même longueur. Les positions passent ensemble de 0/2 à 2/4 puis 4/6, toujours séparées de 2. Pour la fréquence 1, le produit scalaire après rotation reste cos⁡2≈−0.416\cos 2\approx-0.416 ; pour la fréquence 0.1, il reste cos⁡0.2≈0.980\cos0.2\approx0.980. Les positions absolues changent, tandis que les valeurs de comparaison restent constantes. Ici, nous isolons la rotation à contenu fixe ; le modèle complet met aussi à jour les représentations du contenu.

Le codage additif ajoute un vecteur de position à l'entrée. RoPE transforme les positions en angles de rotation de Q et K. Les deux fournissent des signaux positionnels, avec des formes mathématiques et des points d'insertion différents.

On peut aussi introduire la position 100 000 dans la formule de rotation. Le modèle rencontre alors des combinaisons de positions qu'il n'a pas appris à bien connaître pendant l'entraînement.

Les aiguilles tournent en territoire inconnu

Supposons un modèle entraîné uniquement sur des séquences de longueur 2 048. Il a rencontré les combinaisons de positions, les distances relatives et les scores d'attention qu'elles forment avec le contenu dans cette plage.

Donnons-lui directement 32 768 tokens. La formule fonctionne toujours, mais les distances et les angles dépassent la plage d'entraînement initiale.

C'est l'extrapolation en longueur. Étendre directement un modèle RoPE existant peut dégrader nettement sa qualité. La forme relative de RoPE fournit une structure utile ; la qualité de l'extrapolation doit encore être établie par des méthodes et des expériences.

En 2023, Position Interpolation (PI) choisit une approche :

Puisque le modèle connaît l'ancienne plage de coordonnées, comprimons les nouvelles positions pour les y ramener.

Avec une position initiale pp et un facteur d'extension ss, la position transmise à RoPE devient :

p′=psp'=\frac{p}{s}

Partons de quatre positions, 0, 1, 2, 3, pour accueillir huit tokens. L'extension directe utilise 0 à 7. Une interpolation par deux utilise plutôt 0, 0.5, 1, 1.5, jusqu'à 3.5.

Un instant, 3.5 dépasse encore l'ancienne dernière position, 3. Le facteur se calcule ici en divisant les longueurs de fenêtre, 8 par 4, ce qui donne 2 ; les coordonnées redimensionnées appartiennent donc à [0,4)[0,4). L'entraînement initial n'avait échantillonné que les entiers 0, 1, 2, 3. PI ajoute des graduations intermédiaires et place le dernier point entre 3 et 4. Le modèle doit encore s'adapter à ces positions plus denses.

p → p / sPlus de tokens, des coordonnées redimensionnées

Les huit tokens sont conservés. La mise à l’échelle par 2 divise les distances voisines par deux ; la dernière coordonnée est 3,5, au-delà du dernier point d’entraînement, situé à 3.

Cette compression fusionne-t-elle deux tokens en un seul ?

Les huit tokens sont toujours là. Ce qui change, c'est la coordonnée transmise au codage positionnel. Les positions se resserrent, le roman reste entier et l'attention doit toujours traiter huit positions.

Regardons ensuite la Figure 1 de l'article. En haut à gauche se trouve la plage initiale de 2 048 ; les points rouges à droite prolongent directement les positions en territoire inconnu. En bas, les échantillons de la nouvelle séquence sont comprimés dans la plage initiale. Le graphique illustre le redimensionnement des positions ; son axe vertical montre une onde RoPE schématique. PI Figure 1

Figure 1 originale ; Chen et al., 2023, CC BY 4.0.

Ce choix facilite l'adaptation aux séquences allongées. PI §3.1 utilise par défaut 1 000 étapes d'affinage. Dans les Tables 1–2, LLaMA 7B/13B passent de 2 048 à 32 768 ; les résultats présentés vont jusqu'à 16 384 pour 33B et 8 192 pour 65B. PI §3.1–3.2, Tables 1–2

À la même époque, la communauté llama.cpp testait aussi le redimensionnement des positions RoPE, avec des modifications de code et des comparaisons de perplexité. L'article PI cite cette discussion. Discussion llama.cpp, juin 2023

Mais faire tenir huit positions sur une échelle de quatre réduit aussi la distance entre voisines.

En comprimant un million de positions ou davantage dans une plage de 2 048, que deviennent les graduations qui distinguaient les variations locales ?

Une carte comprimée a encore besoin de détails locaux

PI applique le même facteur de redimensionnement à toutes les fréquences de rotation, sans exception.

Or chaque fréquence RoPE traitait déjà les changements de position à une échelle différente. Ralentir aussi la trotteuse modifie les différences à courte distance que le modèle connaissait.

Comment étendre la portée tout en conservant la résolution locale ?

Écrire les fréquences de RoPE aide à voir la différence. Une forme courante est ωi=b−2i/d\omega_i=b^{-2i/d} : b est la base, d la dimension du vecteur soumis à la rotation et i l'indice de la paire bidimensionnelle. PI divise tous les angles par s ; changer b modifie les fréquences de façon différente selon i.

Pour i = 0, par exemple, la fréquence vaut 1 et ne dépend pas de la base. Les suivantes varient avec elle. On peut donc moins perturber les variations rapides et confier davantage de l'extension aux composantes lentes. L'approche NTK-aware décrite dans YaRN suit cette idée de redimensionnement non uniforme. YaRN §3.1, annexe A.2

En 2023, YaRN décompose encore le problème. Il étudie l'effet de l'interpolation uniforme sur les hautes fréquences et les distances relatives locales, puis distingue les régions fréquentielles : préserver autant que possible les variations locales des hautes fréquences, interpoler les basses et les relier par une transition progressive. Il ajuste aussi l'échelle des scores d'attention. YaRN §3

YaRN retrace également les explorations communautaires NTK-aware et NTK-by-parts. Ces approches cherchent toutes à étendre la portée en perturbant le moins possible l'information positionnelle locale utile.

En 2024, LongRoPE demande en outre si, au-delà des fréquences, les positions en début de séquence doivent toutes suivre la même règle.

Les auteurs observent deux non-uniformités. D'une part, le redimensionnement adapté varie selon les dimensions de RoPE ; d'autre part, certaines positions initiales gagnent à être traitées séparément. Ils recherchent donc les facteurs de redimensionnement et la plage initiale dont les positions sont conservées, puis combinent cela à une extension progressive. LongRoPE §2–3

LongRoPE initialise sa recherche avec des configurations correspondant à PI, NTK et YaRN, puis compare leur perplexité par mutation, croisement et sélection. Cet indicateur porte sur les probabilités de prédiction du token suivant. La recherche règle les positions ; l'affinage des poids intervient dans le processus d'extension progressive. LongRoPE §3.2, Algorithm 1

POSITION EXTENSIONTrois méthodes de position
PIÉchelle uniforme
LLaMA · 1,000 pas7B/13B → 32K
33B → 16K · 65B → 8K
YaRNÉchelle par fréquence
Llama 2 7B/13B · 64K à l’entraînement400 + 200 pas → 128K
LongRoPERecherche et étapes
LLaMA2-7B · 400 + 600 pas128K → 256K → 2048K

PI : Tables 1–2 · YaRN : §4 · LongRoPE : §4

Dans une procédure LLaMA2-7B de l'article, le modèle s'entraîne à 128K pendant 400 étapes, puis à 256K pendant 600 étapes. Une nouvelle recherche positionnelle sur ce modèle affiné l'étend ensuite à 2048K. Cette dernière phase n'affine pas les poids sur des séquences de deux millions de tokens. L'article définit 1K=1,0241K=1,024 : 2048K correspond donc à 2 097 152 tokens. LongRoPE §3.3–4.1, Table 6

Il faut lire les étapes avec leur coût. L'annexe A.2 indique respectivement huit A100 pendant une semaine et seize A100 pendant deux semaines pour ces deux phases d'affinage. La recherche positionnelle demande du calcul supplémentaire. LongRoPE annexe A.2–A.3

La plus longue séquence utilisée pour entraîner le modèle peut différer de la plus longue séquence testée après extension. Devant « prend en charge deux millions », cherchons la configuration d'extension, les tâches évaluées et les résultats à chaque longueur.

Les méthodes positionnelles ont d'autres branches. ALiBi, par exemple, ajoute avant le softmax un biais linéaire de distance qui pénalise davantage les positions éloignées, avec une pente fixe prédéfinie pour chaque tête. PI, YaRN et LongRoPE traitent ici des modèles existants utilisant RoPE. ALiBi §3, Figure 3

Les coordonnées sont réglées, mais le roman contient toujours un million de tokens. PI n'a supprimé aucun texte et RoPE n'a éliminé aucune des comparaisons exhaustives.

Les coordonnées sont réglées. Pourquoi le GPU déborde-t-il ?

Revenons à la question finale du roman. Cette position compare son Q aux K des positions précédentes pour produire des scores. Le softmax les transforme en poids, qui servent à agréger V.

Une tête calcule généralement les produits scalaires de Q et K, puis divise par d\sqrt d. Ici, d est la dimension des vecteurs Key et règle l'échelle des scores. Transformer §3.2.1

S=QK⊤dS=\frac{QK^\top}{\sqrt d}

Avec quatre positions candidates, notons la ligne de scores redimensionnés s1,s2,s3,s4s_1,s_2,s_3,s_4. Le poids de chaque position vaut :

ai=esi∑jesj,o=∑iaivia_i=\frac{e^{s_i}}{\sum_j e^{s_j}},\qquad o=\sum_i a_i v_i

Supposons qu'après exponentiation, les poids relatifs soient 1, 1, 2, 4 et les valeurs 10, 20, 30, 40. Additionnons d'abord les contenus pondérés dans u, puis divisons par le poids total :

u=1×10+1×20+2×30+4×40=250o=u1+1+2+4=31.25\begin{aligned} u&=1\times10+1\times20\\ &\quad+2\times30+4\times40=250\\ o&=\frac{u}{1+1+2+4}=31.25 \end{aligned}
Q → K → SOFTMAX → VUne requête, quatre positions, un résultat
Ksexp(s)αVαV
K1010.125101.25
K2010.125202.5
K3ln 220.25307.5
K4ln 440.54020
Σ81—31.25
s
Comparer les scores
α
Normaliser les poids
αV
Pondérer les valeurs

α = exp(s) / Σ exp(s)

Le tableau conserve chaque étape de gauche à droite. L'exponentielle des scores s donne 1, 1, 2, 4 ; la division par leur somme, 8, donne les poids normalisés α ; la multiplication par chaque V donne 1.25, 2.5, 7.5, 20. La dernière colonne totalise 31.25.

Ce sont des nombres pédagogiques choisis pour cet article. Les V réels sont des vecteurs ; nous regardons une composante pour comprendre le calcul. Nous réutiliserons ces nombres pour les blocs.

Un Q face à quatre K, c'est facile. Sur toute l'entrée, chaque position possède cependant son Q à comparer aux autres positions.

Pour une longueur NN, la matrice complète des scores d'une tête comporte N×NN\times N cases. Q et K ont la forme N×dN\times d ; leurs produits scalaires forment N×NN\times N. La multiplication par V, de forme N×dN\times d, donne ensuite le résultat agrégé pour chaque position. Transformer §3.2, Table 1

N × NLongueur × 2, paires × 4
TokensFP16
5120.5 MiB
32,7682 GiB
131,07232 GiB
1,000,0001.82 TiB

Mémoire : matrice complète, une couche, une tête, FP16.

Commençons petit, avec 4 positions qui produisent 4 × 4 comparaisons, soit 16 cases. À 8 positions, les deux axes doublent ; les 16 cases initiales n'occupent plus qu'un quart de la nouvelle matrice. Le tableau de droite convertit les longueurs réelles en mémoire, au lieu de comprimer un million de positions dans une minuscule image.

À un million de tokens, une couche, une tête d'attention et une seule matrice complète de scores FP16 exigent 1012×210^{12}\times2 bytes, soit 2 TB, environ 1.82 TiB.

Cela exclut les poids du modèle, Q/K/V, les résultats intermédiaires des autres couches, les gradients et les états de l'optimiseur. Une seule de ces grandes tables intermédiaires demande déjà 2 TB.

De 512 à un million, la longueur est multipliée par environ 1 953, mais le nombre de paires par 3,81 millions. Agrandir la table de positions et agrandir la matrice d'attention sont donc deux coûts d'ordres de grandeur très différents.

Le masque causal des modèles génératifs bloque les positions futures : les paires visibles forment un triangle. Leur nombre reste quadratique en N. Les noyaux peuvent éviter le travail des zones masquées ; la croissance quadratique demeure.

Que gagne-t-on en retirant des connexions ?

La piste est raisonnable. Dans un roman, beaucoup de phrases dépendent d'abord du texte voisin. Comparer chaque token à une description de paysage située des centaines de milliers de mots plus loin n'est pas toujours l'usage le plus économique du calcul.

En 2020, Longformer relie surtout les positions à une fenêtre locale, en donnant des connexions globales à quelques positions désignées. BigBird combine connexions locales, globales et aléatoires pour offrir d'autres chemins à l'information entre régions. Longformer §3, BigBird §2

DENSE / SPARSEQuelles positions relier ?

Avec les comparaisons complètes, le Query de la ligne orange atteint tous les Key. Avec les connexions locales et globales, il voit surtout les voisins et les positions globales. Des connexions clairsemées supplémentaires atteignent aussi quelques points éloignés. Pour un même Query, le nombre de connexions passe de 16 à 6, puis à 8.

Ce schéma illustre les règles de connexion. Les fenêtres, positions globales, blocs aléatoires et masques réels doivent suivre les configurations des articles.

Les positions globales lisent toute la séquence et sont accessibles aux autres positions. Si la largeur locale, le nombre de positions globales et le nombre de connexions aléatoires supplémentaires par position non globale restent fixes, le nombre total de paires croît linéairement avec la longueur. Chaque position globale conserve N connexions ; leur nombre étant fixe, leur coût total est aussi linéaire.

En contrepartie, pour atteindre le tiroir du premier chapitre, la question finale dépend désormais des liens directs conservés ou des chemins à travers plusieurs couches. Le modèle doit être entraîné pour cette structure, et les tâches doivent vérifier son accès à l'information nécessaire.

Une autre direction est le relais entre segments. Transformer-XL, en 2019, conserve les états cachés du segment précédent pour que le suivant puisse les consulter, avec un mécanisme positionnel relatif adapté aux segments. Transformer-XL §3

Cela crée une continuité, dans les limites des états conservés et de la mémoire disponible. Pour le roman, il faut vérifier si l'indice du premier chapitre reste directement accessible dans l'état courant ou doit traverser plusieurs transmissions avant d'influencer la réponse finale.

Modifier les connexions ou conserver des états sont ainsi différentes façons d'aborder les longues séquences. Chacune possède ses propres chemins d'information ; l'évaluation doit examiner le mécanisme réel.

Supposons pourtant que nous voulions garder l'attention complète, pour que la fin du roman attribue directement un score à toutes les positions précédentes. Peut-on économiser ailleurs ?

Les chercheurs passent alors de « combien de paires calcule-t-on ? » à « combien de fois déplace-t-on les données ? ».

Tout regarder sans conserver toute la grande table

Une implémentation directe calcule QK⊤QK^\top, stocke la matrice des scores, applique le softmax, stocke les poids puis multiplie par V. Le déroulement suit facilement la formule du manuel.

Mais une matrice intermédiaire dans une formule oblige-t-elle à la garder entièrement en mémoire au même instant ?

En 2022, FlashAttention attaque ce point. Il tient compte de la hiérarchie mémoire du GPU, qui associe une HBM de grande capacité à une SRAM sur puce, plus petite et plus rapide. L'endroit où l'on lit, calcule et réécrit les données influence la vitesse réelle. FlashAttention §2–3, version NeurIPS 2022

Imaginons le roman réparti dans des cartons, en ne faisant entrer que les blocs Q, K et V nécessaires. Si chaque bloc traité laisse assez de statistiques pour reconstruire le résultat complet, toute la table N×NN\times N peut rester non matérialisée.

Mais le dénominateur du softmax somme sur toutes les positions candidates. Après une moitié du livre, l'importance de l'autre moitié reste inconnue.

Reprenons nos nombres, avec les poids 1, 1, 2, 4 et les contenus 10, 20, 30, 40.

Le premier bloc lit les deux premières positions et conserve deux quantités :

numeˊrateur1=1×10+1×20=30deˊnominateur1=1+1=2\begin{aligned} \text{numérateur}_1&=1\times10\\ &\quad+1\times20=30\\ \text{dénominateur}_1&=1+1=2 \end{aligned}

Le deuxième conserve :

numeˊrateur2=2×30+4×40=220deˊnominateur2=2+4=6\begin{aligned} \text{numérateur}_2&=2\times30\\ &\quad+4\times40=220\\ \text{dénominateur}_2&=2+4=6 \end{aligned}

Additionnons les numérateurs et les dénominateurs :

30+2202+6=31.25\frac{30+220}{2+6}=31.25

On obtient le même résultat qu'en traitant les quatre positions ensemble.

FLASHATTENTIONCalculer, puis fusionner

Les deux blocs sont lus : (30 + 220) / (2 + 6) = 31,25, comme dans le calcul complet.

Le schéma fixe une ligne Q, note u le numérateur et ℓ le dénominateur. KV₁, en bleu, passe de HBM à SRAM et donne 30 et 2. Les accumulateurs restent, le bloc de travail est libéré, puis KV₂ arrive en orange. Il donne 220 et 6, pour un total de 250/8 = 31.25. Nous suivons une seule ligne Q ; toute la couche organise aussi les lectures et écritures des autres blocs Q et des statistiques.

Peut-on calculer la moyenne de chaque bloc, puis faire la moyenne des deux réponses ?

Essayons ; le résultat change :

15+36.672≈25.83\frac{15+36.67}{2}\approx25.83

Cette réponse est fausse. Le deuxième bloc a un poids total de 6, le premier de 2 : chacun ne peut pas recevoir la moitié des voix.

La fusion doit conserver le poids total de chaque bloc pour lui attribuer la bonne contribution à la sortie.

FlashAttention doit aussi assurer la stabilité numérique. L'exponentielle directe peut déborder avec de grands scores ; l'algorithme conserve donc le score maximal rencontré. Si un nouveau bloc augmente ce maximum, l'ancien numérateur et l'ancien dénominateur sont redimensionnés avant de poursuivre l'accumulation. FlashAttention Algorithm 1

Pour chaque ligne Q, il suffit de garder ces statistiques actualisables et le vecteur d'accumulation de sortie. La matrice complète des scores peut être libérée après calcul ; la recomputation pendant la rétropropagation réduit encore le stockage intermédiaire.

Le résultat mathématique de l'attention complète est conservé, avec les erreurs d'arrondi propres au calcul flottant. La méthode améliore la mémoire, les transferts HBM et l'efficacité du noyau ; le calcul exhaustif reste en O(N2d)O(N^2d).

FlashAttention-2 améliore ensuite la répartition du travail et le parallélisme sur GPU, en réduisant certaines opérations hors multiplication matricielle pour mieux utiliser le matériel. FlashAttention-2 §3

Même sans table des scores, Q, K, V, les sorties et les états intermédiaires des autres couches restent volumineux à un million de tokens. Les comparaisons quadratiques restent nombreuses. Il faut maintenant partager le travail dans un système plus grand.

Notes techniques et sources

Pour vérifier la fusion lors d'un changement de maximum, on peut écrire les statistiques d'un bloc sous la forme m=max⁡isim=\max_i s_i, ℓ=∑iesi−m\ell=\sum_i e^{s_i-m} et u=∑iesi−mviu=\sum_i e^{s_i-m}v_i.

Pour fusionner deux blocs, prenons m′=max⁡(m1,m2)m'=\max(m_1,m_2), puis calculons :

ℓ′=em1−m′ℓ1+em2−m′ℓ2u′=em1−m′u1+em2−m′u2\begin{aligned} \ell'&=e^{m_1-m'}\ell_1\\ &\quad+e^{m_2-m'}\ell_2\\ u'&=e^{m_1-m'}u_1\\ &\quad+e^{m_2-m'}u_2 \end{aligned}

La sortie finale vaut u′/ℓ′u'/\ell'. Si le deuxième bloc apporte le score maximal log⁡4\log4 dans notre exemple, la fusion donne un numérateur de 62.5 et un dénominateur de 2, soit toujours 31.25. Les noyaux réels traitent plusieurs lignes et dimensions ensemble ; nous isolons ici une ligne et une composante de sortie.

Un GPU ne suffit plus : partageons le travail

Voyons d'abord ce qu'une seule unité peut encore économiser.

Après l'attention, le Transformer possède un réseau à propagation avant, ou FFN. Celui-ci peut traiter les positions séparément, mais augmente généralement la dimension des caractéristiques en interne. Conserver d'un coup ces caractéristiques pour toute une longue séquence reste coûteux en mémoire.

Blockwise Parallel Transformer (BPT) réunit l'attention par blocs et le FFN dans un pipeline plus complet. Dès que certains blocs de sortie de l'attention sont prêts, le FFN correspondant est calculé. Avec la recomputation et l'ordonnancement, cela réduit le stockage des caractéristiques intermédiaires de toute la séquence. BPT §3, Figure 2

FlashAttention traitait la mémoire d'une couche d'attention ; BPT élargit la perspective à l'ensemble attention et FFN.

Une unité garde pourtant une capacité et une vitesse limitées. Répartissons donc la séquence entre plusieurs unités.

Découpons le roman en trois grandes parties A, B et C, confiées à trois GPU. Le GPU A possède les Q de sa partie, mais l'attention complète exige toujours une comparaison avec les K et V des autres parties.

La solution immédiate consiste à tout rassembler. Mais chaque unité doit alors stocker à nouveau une grande copie de K et V. Après toute cette répartition, le même roman finit empilé sur chaque bureau.

Ring Attention prolonge l'approche de BPT : chaque unité conserve ses Q, tandis que K et V circulent de station en station sur un anneau. Le calcul du bloc courant peut se superposer au transfert du suivant. On traite les blocs successifs en accumulant les résultats d'attention. Ring Attention §3

RING ATTENTIONGarder Q sur place, faire circuler K et V

Schéma à trois appareils. Chacun conserve son bloc Q et traite tous les blocs KV en trois tours ; l’algorithme réel superpose aussi transferts et calcul.

Q reste sur son unité, tandis que les blocs K/V verts tournent sur l'anneau. Après trois tours de traitement, chaque unité a rencontré tous les blocs. Le schéma montre l'ordonnancement des transferts ; un modèle génératif applique encore son masque causal aux positions que chaque Q peut réellement consulter.

Pourquoi l'accumulation par blocs de FlashAttention est-elle utile ici ? À l'arrivée d'un nouveau bloc KV, l'unité peut mettre à jour les mêmes statistiques et fusionner les résultats sans réunir tous les blocs KV simultanément.

Le gain de vitesse dépend de la capacité du calcul d'un bloc à masquer son temps de transfert. Si le calcul est trop court ou le réseau trop lent, les unités attendent les données. La superposition dépend donc à la fois de la taille des blocs, du nombre d'unités, de la bande passante et de la puissance de calcul.

Répartir le stockage de la séquence et superposer communication et calcul permet à plusieurs unités de traiter des entrées plus longues. Ensemble, elles doivent encore effectuer tous les calculs des paires autorisées.

Une fois ces longueurs accessibles au système, que doivent enseigner les données d'entraînement ?

La machine y arrive. Le modèle s'est-il exercé ?

Commençons par le jeu d'entraînement le plus évident, obtenu en concaténant dix mille petits articles sans rapport en une très longue séquence.

La longueur est suffisante et les positions vont loin. Il faut ensuite examiner les indices disponibles pour prédire les tokens suivants. Si les réponses viennent surtout des quelques centaines de caractères voisins, le modèle peut souvent réussir avec des informations locales.

Revenir du dernier au premier chapitre ou suivre les changements des personnages exige des données et des objectifs qui fournissent ce type d'exercice. Les masques entre documents et leur concaténation influencent aussi les échanges possibles entre positions.

La recherche doit donc organiser les longueurs d'entraînement, les données de longs documents et les procédures d'adaptation. L'interpolation aide le modèle à adopter de nouvelles coordonnées ; l'entraînement sur de longues séquences lui permet d'y apprendre réellement.

LongRoPE peut, nous l'avons vu, rechercher des positions plus longues après un affinage des poids sur des séquences plus courtes. Chaque méthode articule autrement extrapolation et données ; ses résultats étendus doivent être vérifiés expérimentalement.

En 2024, Large World Model (LWM) applique ces techniques de système à des modèles de texte long et audiovisuels. Regardons comment sa variante textuelle, LWM-Text, étend son contexte.

Initialisé avec LLaMA-2 7B, le modèle utilise Ring Attention pour distribuer les longues séquences. Il fusionne RingAttention et FlashAttention avec Pallas, un outil d'écriture de noyaux pour accélérateurs, et augmente la base RoPE avec la longueur. Cet entraînement a effectivement utilisé un TPU v4-512. LWM §3.1, Table 1

Les auteurs répartissent le préentraînement de LWM-Text en cinq étapes à 32K, 128K, 256K, 512K et 1M. Chacune utilise des livres Books3 filtrés par longueur et reprend le modèle de l'étape précédente. Les longueurs de la Table 1 sont des puissances de deux : le dernier 1M vaut 1 048 576 tokens. Les exemples de mémoire suivants utilisent un million rond. LWM §3.2, Table 1

LWM-TEXT / CHECKPOINTSChaque étape reprend le modèle précédent

LLaMA-2 7B → LWM-Text

  1. 32K01
  2. 128K02
  3. 256K03
  4. 512K04
  5. 1M05

Chaque flèche reprend les poids de l’étape précédente.

Tokens entraînés par étape
4.8B12B12B3B1.8B

TPU v4-512 · 1M = 1,048,576 Tokens · Table 1

Sur les cinq étapes, chaque flèche reprend les poids du modèle précédent. La ligne du bas indique le total réel de tokens d'entraînement par étape ; l'étape 32K en lit 4.8B, puis l'étape 1M encore 1.8B. La longueur d'une séquence et le total de tokens lus pendant une étape sont deux nombres distincts.

Pourquoi progresser par étapes ? Chaque mise à jour à la longueur maximale coûte cher. L'utiliser dès le départ pour toutes les mises à jour limiterait les données traitées et leur organisation à budget de calcul et de temps fixe. Commencer plus court puis allonger permet ici de répartir le coût d'entraînement.

Les capacités de contexte long peuvent aussi régresser plus tard.

Le rapport Llama 3 indique qu'après le préentraînement à contexte long, un affinage supervisé utilisant seulement des contextes courts dégrade les capacités sur les longs documents. Les auteurs ajoutent donc des questions-réponses sur de longs documents, des résumés et du raisonnement sur le code pour préserver ces capacités. Llama 3 §4.3.4

Le même rapport décrit l'extension du modèle 405B de 8K à 128K en six étapes, avec vérification de la recherche d'information et des performances sur contextes courts à chaque étape. Llama 3 §3.4.2

Nous voulons que le modèle lise plus loin tout en répondant toujours bien aux anciennes questions courtes. LongRoPE recherche aussi des configurations positionnelles pour des plages plus courtes afin de restaurer leurs performances. Il faut donc suivre ensemble tâches longues et courtes pendant l'extension. LongRoPE §3.3

Supposons maintenant le roman lu et le modèle prêt à répondre « le tiroir bleu ».

Quand la réponse commence, quels calculs conserver ?

Le traitement d'une longue entrée par un modèle génératif se décompose en deux phases.

La première phase, le prefill, traite la consigne et les documents, calcule les représentations de chaque couche et construit l'état nécessaire à la réponse. Les matrices complètes, FlashAttention et la répartition des séquences concernent étroitement son coût ; ces outils servent aussi à l'entraînement.

La seconde phase, le decode, produit la réponse token par token. Chaque nouvelle position possède ses Q, K et V et doit consulter le contenu précédent.

Avec une attention causale, un modèle fixe et une configuration positionnelle fixe, les anciennes positions ne voient pas le futur. Quand la réponse gagne un token, les K et V déjà calculés peuvent donc être réutilisés. Ces données conservées forment le cache KV.

Pourquoi KV, sans Q ? La nouvelle position pose sa question avec son propre Q. Les anciens Q ont déjà produit leur sortie ; les nouvelles positions n'ont plus besoin que des K et V précédents.

Le nouveau Q se compare aux K existants et agrège V avec les poids obtenus. Pour cette position, l'attention correspond à une ligne face à N positions. Elle évite de recalculer les précédentes, mais exige toujours l'accès à leurs K et V disponibles.

Par conséquent, plus le roman est long, plus chaque couche conserve de KV.

Supposons que chaque couche conserve toute la séquence, avec le même nombre de têtes KV et la même dimension. Pour une requête, la taille du cache se calcule ainsi :

2×couches×teˆtes KV×dimension par teˆte×tokens×bytes par valeur\begin{aligned} &2\times\text{couches}\times\text{têtes KV}\\ &\quad\times\text{dimension par tête}\times\text{tokens}\\ &\quad\times\text{bytes par valeur} \end{aligned}

Le premier 2 correspond à K et V. Avec 32 couches, 8 têtes KV, 128 dimensions par tête et 2 bytes par valeur, un million de tokens demande environ 122.1 GiB. Seul le cache KV est compté ; les poids du modèle s'ajoutent.

KV CACHE / GQALa mémoire s’accumule

32 couches · 128 dimensions · 2 octets/valeur

Une requête, 32 couches, 128 dimensions par tête KV, 2 octets par valeur. Comparaison de 8 et 32 têtes KV. Cache KV seul ; poids exclus.

Pour ce même million, passer de 8 à 32 têtes KV sans rien changer d'autre porte le total à environ 488.3 GiB. Les deux courbes augmentent avec la longueur ; celle de 32 têtes reste quatre fois plus grande. Ces configurations sont pédagogiques : il faut consulter l'architecture réelle pour connaître les couches, les têtes KV et le type numérique.

Grouped-Query Attention (GQA) permet à un groupe de têtes Q de partager une tête K et une tête V, réduisant les KV à stocker et à lire. Le nombre de têtes Query peut ainsi différer du nombre de têtes KV. Cela exige une architecture et un entraînement adaptés. Pour convertir un modèle multi-tête existant, l'article moyenne séparément les matrices de projection K et V au sein de chaque groupe, puis poursuit l'entraînement. GQA §2.2–3.1

Avec plusieurs requêtes simultanées, il faut aussi gérer l'allocation mémoire. Certaines conversations commencent ; d'autres ont déjà rempli des pages. Réserver une grande zone contiguë à chacune peut gaspiller beaucoup d'espace.

PagedAttention découpe le cache KV en blocs et gère leur correspondance logique-physique pour améliorer la réservation, la fragmentation et les copies lors du partage. Cette amélioration porte sur la gestion du cache ; l'architecture et le format numérique déterminent toujours les données KV par token. PagedAttention §3–4

Pour examiner un système à contexte long, mesurons donc séparément au moins le délai entre l'envoi du roman entier et la première réponse, puis le nombre de tokens par seconde une fois la génération commencée.

Le prefill en attention causale complète effectue un nombre quadratique de comparaisons. Une étape de decode avec cache consulte les anciens K et V ; allonger la séquence augmente aussi les lectures et calculs associés. Les formes de travail diffèrent, et les goulets d'étranglement peuvent différer aussi.

Pour la limite de longueur, l'attente avant réponse, la vitesse de génération et le nombre d'utilisateurs simultanés, les sections précédentes ont montré où se situe chaque goulot d'étranglement.

Le cache contient l'état intermédiaire de cette génération. Le roman devient le contexte du calcul courant ; les paramètres du modèle sont modifiés par entraînement. Ces deux formes de stockage contiennent des choses différentes et ont des durées de vie différentes.

Il ne reste enfin que l'épreuve la plus proche d'un contrôle de lecture, qui vérifie à quelles questions le modèle a vraiment bien répondu.

Un million de tokens : quelle lecture évalue-t-on ?

Revenons à la clé du premier chapitre.

Indicateur courant des modèles de langage, la perplexité mesure les probabilités attribuées au prochain token d'un texte réel. LongRoPE utilise aussi la perplexité sur de longs textes pour examiner la modélisation après extension et comparer les longueurs de contexte. LongRoPE §4.2, Tables 5–7

Mais beaucoup de mots suivants se prédisent avec le voisinage. Pour savoir précisément si le modèle retrouve la clé du premier chapitre à la fin, il faut construire cette question et contrôler la position de la réponse, sa distance et les distracteurs.

Le test le plus direct consiste à insérer une information unique dans un long texte, puis à demander au modèle s'il peut la retrouver. LongRoPE évalue ainsi la recherche d'un code à cinq chiffres, inséré parmi beaucoup de texte distracteur et à retrouver à la fin.

LongRoPE-LLaMA2-7B (ft=256K) conserve au moins 90 % d'exactitude entre 4K et 2048K dans ce test. Chaque longueur est évaluée dix fois, avec une position aléatoire du code : neuf bonnes réponses sur dix donnent ici 90 %. Sur la même figure, LongRoPE-Mistral-7B (ft=128K) tombe à 60 % à 2048K. ft désigne la fenêtre configurée pour l'affinage ; les séquences réellement utilisées pour Mistral font 16K, contrairement aux longueurs d'entraînement LLaMA2 décrites plus haut. LongRoPE §4.1–4.2, Figure 4

Ce résultat montre que le modèle retrouve effectivement un certain type d'information à des positions d'entrée très éloignées.

Si la clé reste dans le tiroir, tout est assez simple. Changeons maintenant le rangement.

Le premier chapitre dit seulement : « La clé est placée dans la boîte. » Le huitième : « La boîte est placée dans le manteau. » Le quinzième : « Le manteau est remis à Xiaomei. » La question finale : « À qui demander la clé maintenant ? »

La dernière phrase seule indique que Xiaomei a le manteau, sans expliquer son rapport avec la clé. Il faut suivre clé vers boîte, boîte vers manteau, puis manteau vers Xiaomei. Retirer un lien coupe le chemin.

RETRIEVE / TRACE / AGGREGATETrois questions, des indices différents

Trois faits distincts : la clé est mise dans une boîte ; la boîte dans un manteau ; le manteau est remis à Xiaomei. La recherche directe retrouve la boîte. Il faut relier les trois faits pour situer la clé chez Xiaomei ; la dernière phrase ne mentionne que le manteau. L’agrégation compte les trois dépôts ou remises : 1 + 1 + 1 = 3. Exemple pédagogique.

La recherche ponctuelle demande « Quel contenant renferme directement la clé ? » : le premier chapitre suffit. Relier les chapitres exige de conserver les relations « clé → boîte → manteau → Xiaomei ». Si l'on demande combien de placements ou remises ont eu lieu dans ces trois chapitres, on additionne une action par chapitre : 1 + 1 + 1 = 3, y compris le premier placement. Il s'agit d'un exemple pédagogique de cet article.

Même déplacer un indice identique peut changer le résultat.

Lost in the Middle réalise cette comparaison. Voici la Figure 1 de la version publiée dans TACL : on fixe une tâche de questions-réponses multi-documents et on change la position du document contenant la réponse parmi vingt documents. Figure 1 originale

Figure 1 originale ; Liu et al., TACL 2024, CC BY 4.0.

De gauche à droite sur l'axe horizontal, le document réponse passe du début à la fin ; l'axe vertical donne l'exactitude des réponses. La courbe violette correspond à cette expérience GPT-3.5-Turbo-0613. La ligne rouge pointillée est la référence closed-book, sans documents fournis.

Regardons d'abord le milieu de la courbe, où le même document produit de moins bonnes réponses lorsqu'il est placé au centre du contexte. La longueur totale est ici d'environ 4K, et la figure montre une sensibilité à la position pour ce modèle et cette tâche. Les modèles à un million doivent être réévalués sur leur propre plage d'utilisation.

En 2024, RULER distingue plusieurs recherches d'information, le suivi de variables en plusieurs étapes, l'agrégation et les questions-réponses. Les trois premières catégories sont synthétiques ; les questions-réponses utilisent SQuAD et HotpotQA, avec des documents distracteurs pour contrôler la longueur. Sur dix modèles et treize tâches dans la v1, les modèles bons en recherche simple pouvaient encore fortement régresser avec des entrées plus longues ou des tâches plus complexes. RULER §3–4

Comparez les longueurs annoncée et effective avec les scores à chaque longueur testée.

Les scores sont des moyennes sur treize tâches. Le soulignement indique les résultats atteignant le score de référence de Llama2-7B à 4K, seuil retenu ici pour la longueur effective. RULER: What's the Real Context Size of Your Long-Context Language Models? — Table 3, Hsieh, Cheng-Ping et al., CC BY 4.0.

Voilà pourquoi « un million » mérite une question complète :

Un million de tokens utilisables pour quelles tâches, avec l'information à quelles positions, pour quelle exactitude et quel coût ?

Le rapport Gemini 1.5 Pro de 2024 présente des expériences de recherche d'information dans du texte et de prédiction du prochain token de code jusqu'à dix millions de tokens. Les autres tâches de questions-réponses sur longs documents et de code ont leurs propres longueurs et indicateurs. Le rapport ne publie pas la recette complète de son implémentation à contexte long. Gemini 1.5 §2, §4.2

Rouvrons maintenant ce roman

Passer de 512 à un million exige que le codage positionnel, le calcul de l'attention, la mémoire et l'entraînement suivent. Il faut examiner séparément la longueur acceptée, son coût de traitement et les indices utilisables dans la réponse.

La prochaine fois qu'une fiche indique 1M ou 2M, cherchons d'abord la longueur d'entraînement, puis les longueurs des tâches réelles, les positions des réponses, l'exactitude et le coût. Comparer ces conditions à nos documents permet d'estimer si le modèle peut accomplir le travail.

Puis retournons au premier chapitre : la clé est dans la boîte, la boîte dans le manteau, et le manteau a été remis à Xiaomei.

Ouf. Quel parcours. La prochaine fois, je me contenterai de lire le roman.