La forme : largeur, têtes, experts
la mesure. run-062 · 2026-09-01 · Kaggle T4 · 24 modèles · 0 €
Quatre boutons écrits à la main avant l'entraînement. Ce que chacun change.
- run
- run-062
- date
- 2026-09-01
- machine
- Kaggle T4
- durée
- 73 min
- coût
- 0 €
- journal
- EXPERIENCES.md
1. Les mots, et le relevé
Un jeton est le morceau de texte avalé d'un coup — ici un caractère. La largeur est le nombre de valeurs qui le décrivent.
Les têtes ne s'ajoutent pas à la largeur : elles la découpent. largeur = têtes × taille d'une tête.
Les experts remplacent le bloc dense par plusieurs petits blocs ; un routeur n'en réveille que deux par jeton.
Le nombre de têtes est écrit une seule fois pour tout le modèle. Aucun lien avec le nombre de couches :
| modèle | couches | têtes | largeur | tête |
|---|---|---|---|---|
| Qwen2.5-0.5B | 24 | 14 | 896 | 64 |
| Qwen2.5-1.5B | 28 | 12 | 1 536 | 128 |
| run-034, le mien | 8 | 6 | 384 | 64 |
| run-062, le mien | 4 | 4 | 256 | 64 |
Le 1.5B a plus de couches que le 0.5B et moins de têtes : aucun lien n'est possible. Relevé complet : attention.html.
2. Redécouper ne coûte pas un poids
À largeur fixée, changer le nombre de têtes ne change aucun poids : Wq, Wk, Wv et Wo font chacune 256 × 256 qu'il y ait 1 tête de 256 ou 32 têtes de 8. Le découpage regroupe les mêmes nombres autrement.
poids
identique partout
taille d'une tête
256 ÷ têtes
perte
3 graines, bas = mieux
3. Balayage A — le découpage seul
Le run-062 entraîne 24 modèles écrits de zéro : 8 configurations × 3 graines, sur du Shakespeare au caractère. Trois graines, sans quoi un écart de 0,01 se confond avec le bruit de départ.
| découpage | poids | perte | écart-type |
|---|---|---|---|
| 4 têtes de 64 | 3 221 504 | 1,5144 | ± 0,0050 |
| 2 têtes de 128 | 3 221 504 | 1,5176 | ± 0,0043 |
| 1 tête de 256 | 3 221 504 | 1,5188 | ± 0,0028 |
| 8 têtes de 32 | 3 221 504 | 1,5210 | ± 0,0045 |
| 16 têtes de 16 | 3 221 504 | 1,5270 | ± 0,0002 |
| 32 têtes de 8 | 3 221 504 | 1,5443 | ± 0,0027 |
Le découpage compte, et l'optimum est au milieu : 0,0299 du meilleur au pire, contre 0,0032 de bruit entre graines. Neuf fois le bruit, à poids strictement identiques.
Mais quadrupler la capacité, de la largeur 128 à 256, vaut 0,1326. La largeur pèse 4,4 fois le découpage.
run-062 · 2026-09-01 · Kaggle T4 · 73 min · 0 € · tetes062.json
Les deux extrêmes perdent, mais pas également : une grosse tête coûte +0,0044, trente-deux minuscules +0,0299 — sept fois plus. À 8 valeurs par tête, une tête ne distingue presque plus rien.
L'optimum tombe sur des têtes de 64, la valeur même de Qwen2.5-0.5B en section 1.
4. Balayage B — le témoin qui a raté
Que vaut un vrai gain de capacité ? Taille de tête fixée à 64, largeur variable.
| largeur | poids | perte |
|---|---|---|
| 128 (2 têtes) | 824 320 | 1,6470 |
| 256 (4 têtes) | 3 221 504 | 1,5144 |
| 512 (8 têtes) | 12 734 464 | 1,5396 |
Le témoin n'est pas monotone, et je le publie tel quel. De 128 à 256, quadrupler les poids gagne 0,1326. De 256 à 512, les quadrupler encore fait perdre 0,0252.
Ce n'est pas « la largeur nuit » : 2 000 pas sur un million de caractères ne suffisent pas à 12,7 millions de poids. Le plus gros modèle est le moins bien entraîné. Seul l'écart 128 → 256 sert de référence au 4,4.
run-062, balayage B · tetes062.json
5. Les clés partagées : un bouton de mémoire
On peut donner au modèle moins de têtes de clés que de requêtes. Qwen2.5-0.5B en a 14 contre 2 : sept têtes lisent les mêmes clés. Le gain est sur le cache — les clés et valeurs des jetons déjà lus, gardées pour ne pas les recalculer.
Le même modèle sans partage tiendrait 86 016 octets par jeton ; avec partage, 12 288. Facteur 7, soit exactement le nombre de têtes par jeu de clés.
Le partage existe bien dans les poids : couper une tranche de clés fait bouger exactement 7 têtes sur les 48 cas, et l'écart chez les 7 autres vaut exactement 0,000.
run-063 · 2026-09-01 · Kaggle T4 · 24 s · 0 € · tetesKV063.json · contexte.json
Le récit du run-063 — 336 cartes, ablation, témoin Pythia — reste en section 10 de la page attention.
6. Les experts : payer en stockage, pas en calcul
Le run-034 remplace le bloc dense par 8 experts, dont le routeur n'en réveille que 2 par jeton. Trois bras identiques en tout — mêmes données, mêmes pas, même graine — sauf ce bloc. La note : le français comprimé en bits par caractère, sur un texte jamais vu.
| bloc | stockés | actifs | bits/car |
|---|---|---|---|
| dense, 1 536 neurones | 14,5 M | 14,5 M | 1,649 |
| 8 experts × 768, top-2, équilibrage 0,01 | 42,8 M | 14,5 M | 1,590 |
| les mêmes, sans équilibrage | 42,8 M | 14,5 M | 1,597 |
À calcul rigoureusement égal — top-2 × 768 = 1 536 neurones traversés — les 42,8 M stockés battent les 14,5 M : 1,590 contre 1,649.
Le calcul théorique n'est pas du temps : le routage coûte 25 % de vitesse réelle, 37 900 caractères/s contre 50 400.
run-034 · 2026-08-03 · Kaggle P100 · ~2 h · 0 € · llm.html, section 12
Le troisième bras teste le garde-fou. Sans lui, l'expert le plus servi prend 18,1 % des jetons, le moins servi 9,2 %. Avec lui, les huit tiennent entre 12,3 et 12,8 % (idéal 12,5). Le déséquilibre coûte +0,007 bits/car.
run-034, bras sans garde-fou · 8 000 pas
Déclaré non mesuré
La profondeur à budget de poids constant. Le run-062 fige les couches à 4. Personne ici n'a comparé 4 couches larges contre 12 fines à poids égaux.
run-062, couches=4 dans les 8 configurations
La taille du vocabulaire. Aucun run ne l'a fait varier toutes choses égales par ailleurs. Le run-062 tient sur 65 caractères, le run-034 sur 238 : deux corpus, pas une comparaison.
tetes062.json, vocab 65
Ce que le partage de clés coûte en qualité. Le run-063 mesure la mémoire épargnée, pas la perte payée pour elle : il aurait fallu entraîner deux fois le même modèle, avec et sans.
run-063, inférence pure, aucun entraînement
Le nombre d'experts et le top-k. Le run-034 ne connaît qu'une forme de MoE : 8 experts, top-2. Ce qui est comparé, c'est le garde-fou.
run-034, trois bras seulement
Portée du reste : un corpus, une profondeur, un budget. Rien ne dit que l'optimum tienne à 64 sur un modèle de 70 milliards.