Jusqu'où le modèle peut lire
ça tourne dans ton navigateur. Les relevés viennent des fichiers des modèles ; le reste est calculé ici, sans serveur.
Un modèle qui lit 2 048 jetons et le même qui en lit 32 768 pèsent pareil : le contexte se paie à l'usage, pas en poids. Quatre verrous le limitent.
Les quatre verrous
Verrou 1 — le plafond déclaré
Un entier, context_length. Il autorise, il ne garantit rien : une déclaration, pas une mesure.
Verrou 2 — la table de positions apprise
Une tête voit un sac de jetons, pas une suite. Mes deux modèles maison apprennent une ligne de nombres par position.
Coût : contexte × largeur, soit 128 × 256 = 32 768 poids dans run-062. À la position 128, plus de ligne : le code ne se dégrade pas, il s'arrête.
Verrou 3 — la base de rotary
Pythia et Qwen n'apprennent aucune position : chaque paire de nombres d'une tranche est tournée d'un angle proportionnel à la position. Aucune table, aucun mur.
Mais chaque paire tourne à sa vitesse, et la plus lente finit par boucler. Après ce tour, deux positions éloignées redeviennent indiscernables. Le réglage qui commande ce tour est la base.
Verrou 4 — la facture
Celle qui tranche. Deux lignes : le cache KV, qui grandit comme le contexte, et les cases d'attention, comme son carré.
La base, en une horloge
Rotary, ou RoPE : elle fait tourner les nombres, pas les mots. Un cadran par paire ; le premier jeton est cloué à midi, l'aiguille marque le second. Tant qu'une aiguille n'a pas bouclé, elle sait encore dire de combien les deux jetons sont éloignés.
Pythia-160M — base 10 000, 8 paires tournées, fenêtre déclarée 2 048 jetons
contexte.json ne charge pas : horloge et tableaux restent figés sur l'image ci-dessus.
À 2 048 jetons d'écart, 2 aiguilles sur 8 n'ont pas fini leur premier tour.
L'écart monte jusqu'à ce que la dernière aiguille boucle.
Aiguilles qui savent encore
premier tour non fini
Portée
le tour de la plus lente
Marge
19 869 ÷ 2 048
Coût en poids
une ligne de configuration, pas une matrice
La première aiguille ne bouge jamais. Elle tourne d'un radian par jeton et boucle à 6,3 jetons, quelle que soit la base : la base n'accélère personne, elle écarte les vitesses.
Une aiguille bouclée n'est pas cassée. Elle sert encore pour les jetons voisins ; elle ne sépare plus proche et lointain. La portée n'est pas un mur.
Les limites de cette mesure
Une aiguille n'est pas une tête : les 144 têtes de Pythia tournent avec les mêmes 8 aiguilles.
Seuls 16 des 64 nombres d'une tranche tournent, chez Pythia. Les 48 autres ne portent aucune position.
Mes modèles maison n'ont pas d'horloge : ils apprennent une ligne par position, c'est le verrou 2. D'où le mur à 128 et 256.
Le modèle ne lit jamais une aiguille seule : compter les vivantes donne une borne haute.
Trois nombres sont lus : base, dimensions tournées, fenêtre. Le reste est calculé.
La formule : le tour de la paire n vaut 2π × base^((n−1)/P), P étant le nombre de paires.
Le relevé, modèle par modèle
| Modèle | dims tournées | base | tour complet | contexte | marge |
|---|---|---|---|---|---|
| chargement… | |||||
C'est la dernière colonne qui compte. Qwen 0.5B garde 124 fois sa fenêtre en réserve ; le 1.5B, qui annonce 128 k, n'en a plus que 38.
Monter la base de 10 000 à 1 000 000 rallonge un modèle déjà entraîné sans coûter un poids. Le bouton « ↗ Pythia avec la base de Qwen » le fait : à 2 048 d'écart, Pythia passe de 2 aiguilles vivantes à 4, sa marge de ×9,7 à ×545,6.
La facture du contexte
La mémoire : le cache KV
Le modèle garde la clé et la valeur de chaque jeton déjà lu. Coût par jeton : 2 × couches × têtes de clés × taille de tête × octets. Ni largeur, ni bloc dense, ni vocabulaire n'y entrent.
| Modèle | Le calcul | par jeton | au contexte plein |
|---|---|---|---|
| chargement… | |||
Pythia-160M coûte trois fois plus par jeton que Qwen 0.5B, et il est trois fois plus petit : 12 têtes de clés contre 2.
Le calcul : les cases d'attention
Chaque jeton est comparé à chaque jeton : une carte n × n par tête et par couche, soit n² × têtes × couches.
| Modèle | contexte | cases (passage plein) |
|---|---|---|
| chargement… | ||
Doubler la fenêtre double le cache et quadruple les cases. De run-062 (128 jetons) à Qwen 2.5-1.5B (131 072) : 524,3 ko contre 3,76 Go de cache, 262 144 contre 5 772 milliards de cases.
Lu dans les GGUF, le config.json de Pythia et mes train.py par contexte_params.py → contexte.json. Aucun GPU : 0 €.
Le partage des têtes de clés
Qwen 0.5B a 14 têtes de requêtes et 2 têtes de clés : sept têtes partagent les mêmes clés.
Qwen 0.5B tel qu'il est
2 têtes de clés · 32 768 jetons
Le même sans ce partage
14 têtes de clés · même modèle
Sept fois plus de mémoire, même modèle. Les têtes de requêtes règlent la qualité ; les têtes de clés, le budget de contexte.
GGUF → contexte.json, champ gqa. 0 €.
Essaye : quelle facture pour quel réglage
Les mêmes formules, à la main. Regarde surtout ce qui ne bouge pas.
Largeur
têtes × taille de tête
Cache KV par jeton
2 × couches × têtes de clés × taille de tête × 2 octets
Cache au contexte plein
hors poids
Cases d'attention
contexte² × têtes × couches
Ce qui n'y change rien
La largeur, le bloc dense, le vocabulaire — l'essentiel des poids — coûtent par jeton, jamais par paire. En une ligne : la base décide de la portée et ne coûte rien ; couches × têtes de clés × taille de tête, de la mémoire ; le n², du calcul.
Déclaré non mesuré
Aucun modèle n'a jamais été réentraîné ici avec une autre base de rotary. L'horloge montre la géométrie, elle ne prouve rien sur la qualité.
À quelle longueur la qualité décroche : jamais mesuré ici. Un modèle qui annonce 128 k n'est pas forcément bon à 128 k. Il faudrait un run, avec une perte mesurée par tranche de position.
Cette page est un relevé de fichiers et de l'arithmétique, pas une expérience.