Le double coût du contexte¶
Le contexte long se heurte à deux murs distincts. Les confondre est l'erreur la plus courante dans les discussions sur le sujet — et c'est en les séparant qu'on peut encadrer l'architecture de Pokee-Isaac.
| Mur | Ressource | Croissance | Se manifeste par |
|---|---|---|---|
| Mémoire | VRAM du GPU | linéaire en \(n\) | « out of memory » |
| Calcul | FLOPs | quadratique en \(n\) | lenteur, coût |
Rappel : l'attention¶
Dans un transformeur, chaque token produit trois vecteurs : une requête \(q\) (« ce que je cherche »), une clé \(k\) (« ce que je suis ») et une valeur \(v\) (« ce que j'apporte »). Un token regarde tous les tokens précédents en comparant sa requête à leurs clés :
| Symbole | Signification | Dimension |
|---|---|---|
| \(Q\) | Matrice des requêtes | \(n \times d_k\) |
| \(K\) | Matrice des clés | \(n \times d_k\) |
| \(V\) | Matrice des valeurs | \(n \times d_v\) |
| \(d_k\) | Dimension d'une tête | scalaire (souvent 128) |
| \(n\) | Nombre de tokens | scalaire |
Le produit \(QK^{\top}\) est une matrice \(n \times n\) : chaque token contre chaque token. C'est la source des deux murs.
Mur nº 1 — la mémoire : le cache clé-valeur¶
Quand le modèle génère du texte, il produit un token à la fois. Recalculer les clés et valeurs de tous les tokens précédents à chaque étape serait absurde : on les conserve. C'est le cache clé-valeur (KV cache).
Sa taille :
| Symbole | Signification | Valeur typique |
|---|---|---|
| \(2\) | On stocke K et V | — |
| \(n\) | Nombre de tokens | jusqu'à \(10^7\) |
| \(L\) | Nombre de couches | 64 |
| \(H_{kv}\) | Nombre de têtes clé/valeur | 8 (attention groupée) |
| \(d_h\) | Dimension d'une tête | 128 |
| \(b\) | Octets par valeur | 2 (fp16), 1 (fp8), 0,5 (int4) |
Exemple numérique. Pour un modèle de forme classique de 30 milliards de paramètres, en demi-précision :
À 1 M de tokens : 262 Go. À 10 M de tokens : 2,62 To.
Limite importante
Aucun GPU unique n'a 2,62 To de mémoire. Une B200 en a 192 Go, une RTX 4090 en a 24 Go. Le mur mémoire est absolu : il ne s'agit pas de patienter plus longtemps, le calcul est impossible.
C'est ce chiffre que Pokee attaque avec sa revendication de « ≈ 5× de cache KV à VRAM égale ». Le chapitre Architecture · 02 montre que ce facteur 5, seul, est très loin de suffire.
Mur nº 2 — le calcul : la quadratique¶
Le coût en opérations de la phase de préfill (lecture de l'entrée) :
où \(d_q = H_q \cdot d_h\) est la dimension totale des requêtes (par exemple \(64 \times 128 = 8192\)). Le facteur \(n^2\) vient du produit \(QK^\top\) ; la causalité (un token ne voit que le passé) fait gagner un facteur 2, déjà intégré ici.
Exemple numérique. Une seule couche, à \(n = 10^7\) et \(d_q = 8192\) :
Une B200 délivre environ \(4{,}5 \times 10^{15}\) FLOPs/s en 8 bits, soit \(2{,}25 \times 10^{15}\) à un rendement réaliste de 50 %. Cette unique couche prendrait donc environ 12 minutes. Avec 64 couches : 13 heures.
Erreur fréquente
Doubler le contexte ne double pas le coût de l'attention : il le quadruple. Passer de 1 M à 10 M multiplie le coût par 100, pas par 10.
Le coût linéaire, souvent oublié¶
Même sans attention, faire passer \(n\) tokens dans un modèle de \(N\) paramètres actifs coûte :
Pour un modèle dense de 28 milliards de paramètres : 56 GFLOPs par token. À 10 M de tokens : \(5{,}6 \times 10^{17}\) FLOPs, soit plus de 4 minutes sur B200 à 50 % de rendement — avant même toute attention.
Ce terme, apparemment anodin, est celui qui contraint le plus fortement le débit annoncé par Pokee. Voir Architecture · 03.
À retenir
- Mémoire : \(256\) Kio par token pour une forme classique → 2,62 To à 10 M. Mur absolu.
- Attention : quadratique en \(n\) → 12 min par couche à 10 M sur B200. Mur de temps.
- Reste du modèle : linéaire en \(n\), mais \(2N\) par token, ce qui plafonne le débit atteignable.
Une architecture qui atteint 10 M de tokens doit franchir les trois.
Chapitre suivant : Les familles de solutions connues