👁️ Regarder une tête d'attention travailler

Depuis 58 runs on parle de « têtes d'attention » sans en avoir jamais vu une. Cette page en ouvre 144 — celles de Pythia 160M, un modèle entièrement ouvert — et montre les nombres qu'elles produisent. Puis elle en coupe quelques-unes pour vérifier qu'on n'a pas rêvé. Les sections 8 et 9 posent ensuite tous les réglages d'un modèle à plat — les sept nombres qu'on écrit avant d'entraîner, et ce que « lire 32 000 jetons » coûte vraiment.

Ce qu'est une tête, en une phrase : pour chaque jeton du texte, elle répartit 100 % d'attention sur les jetons déjà lus, lui-même compris. C'est tout. Une tête = un tableau de nombres, une ligne par jeton, chaque ligne sommant à 1. Il y en a 144 qui tournent en parallèle, et le modèle n'a jamais reçu la moindre instruction sur ce que chacune devait regarder.

Un jeton n'est pas un mot : c'est le morceau de texte que le modèle manipule. tapis se découpe en tap + is, dort en d + ort. Tous les mots en gras de cette page sont définis en bas, dans Les mots de cette page.

1. Les 144 têtes, d'un coup d'œil

Choisis une phrase. Chaque vignette est une tête : une ligne = un jeton, une colonne = le jeton regardé. Le coin en haut à gauche est le début de la phrase. Tout est vide au-dessus de la diagonale — un modèle de langue ne voit jamais l'avenir.

Les 12 colonnes sont les 12 têtes d'une couche ; les 12 lignes sont les 12 couches, la couche 0 en haut. Clique une vignette : la page descend sur la vue en grand (section 3), avec les numéros de jetons sur les deux bords.

Commence par « Du bruit pur ». Douze jetons tirés au hasard — itarian, Figure, Mus, für… — répétés une fois. Aucune grammaire, aucun sens, rien à comprendre. Le modèle prédit quand même la suite : itarian à 83,3 %. Il n'a pas compris la séquence, il a retrouvé où le jeton courant était déjà passé et recopié ce qui venait après.

Sur la grille de cette phrase, la plupart des vignettes sont une barre verticale collée à gauche. Cherche celles qui portent une seconde diagonale, décalée, parallèle à la vraie : ce sont les têtes d'induction. Elles sont dans les couches 4 à 8.

« Du français » donne la même leçon à l'envers. Pythia est entraîné presque uniquement sur de l'anglais, et pourtant Le chat dort sur le tapis . Le chat dort sur le continue par tap à 94,7 %. Recopier ne demande pas de comprendre — c'est précisément ce qui rend ce mécanisme si général.

« Deux prénoms » est plus dur. When Mary and John went to the shop , John gave a drink to : il faut repérer que John est déjà pris et sortir l'autre prénom. Le modèle répond Mary à 28,4 %, contre John à 8,3 %. La copie seule aurait donné le contraire.

2. Apprendre à lire une de ces images

Une vignette n'est pas un dessin, c'est un tableau. Autant de lignes et de colonnes que la phrase a de jetons — les morceaux de mots que le modèle manipule, parfois un mot entier, parfois trois lettres. « Du bruit pur » en compte 24 : le tableau fait donc 24 lignes sur 24 colonnes. Chaque case contient un pourcentage. Rien d'autre.

Une case, en vrai, avant toute règle. Ouvre couche 6, tête 6 sur « Du bruit pur ». Les jetons sont numérotés à partir de 0 : le jeton 12 est le second itarian, celui qui ouvre la copie. Prends sa ligne, va à la colonne 1 — Figure, le jeton qui suivait le premier itarian. La case affiche 89,0 %.

Ce nombre se lit dans un seul sens : quand le modèle traite le second itarian, cette tête place 89,0 % de son attention sur Figure. Le reste de la ligne est miette : 4,3 % sur theme, 2,7 % sur le premier itarian, 2,7 % sur Comb, et deux cases à 0,4 %. Les sept autres colonnes de cette ligne sont à zéro. Sur l'image ouverte en grand, survole n'importe laquelle de ces cases : la même valeur s'affiche sous le tableau.

Ces six cases additionnées font 99,6 %, pas 100 %. Les valeurs sont arrondies avant d'être envoyées à la page, au 0,4 % près, pour que le fichier reste petit. Aucun total lu sur cette page ne tombera pile.

Les deux axes ne disent pas la même chose

Une ligne = le jeton qui regarde. On lit une ligne à la fois, de gauche à droite. La ligne du haut est le premier jeton de la phrase.
Une colonne = le jeton regardé. La colonne de gauche est, elle aussi, le premier jeton de la phrase.
Une case = le pourcentage d'attention que le jeton de la ligne accorde au jeton de la colonne.
Plus la case est foncée, plus le pourcentage est grand. Une case vide, c'est zéro.

Confondre les deux axes retourne le sens. « itarian regarde Figure » et « Figure regarde itarian » sont deux cases différentes, et l'une des deux n'existe pas.

Le triangle vide, et le 100 % de chaque ligne

La moitié en haut à droite est toujours vide. Un modèle de langue — un programme qui ne fait qu'une chose, deviner le jeton suivant — est entraîné à ne jamais regarder plus loin que le jeton qu'il traite. La phrase entière lui est bien donnée d'un coup ; c'est un masque, posé dans le code avant le calcul, qui met à zéro toute case au-dessus de la diagonale. Quand il traite le jeton 12, les jetons 13 et au-delà lui sont donc cachés.

Reste que chaque ligne totalise 100 %. La cause s'appelle le softmax : l'opération qui convertit les scores bruts d'une tête en pourcentages, en les forçant à faire 100 % ensemble. Une tête ne peut ni s'abstenir, ni distribuer 200 %. Elle a 100 % à répartir sur les jetons déjà lus, pas un de plus.

Conséquence à connaître avant de conclure quoi que ce soit : la première ligne de toutes ces images, dans les 144 têtes et sur les quatre phrases, vaut 100 % sur la première colonne. Le premier jeton n'a que lui-même à regarder. Une case pleine, là, ne signifie rien.

3. Une tête en grand

Survole une case.

Ces quatre notes — et surtout la façon dont elles sont calculées — sont expliquées en section 4. Les numéros de jetons écrits sur les bords de l'image servent à retrouver une case précise : la case (12, 1) dont parle toute cette page est la ligne 12, colonne 1.

Le vocabulaire des formes

Trois formes reviennent, et chacune se reconnaît sans hésitation une fois qu'on l'a vue. La troisième colonne donne une tête réelle à ouvrir pour voir la forme en grand, avec la note qu'elle a obtenue.

La forme	Ce que ça veut dire	La tête à ouvrir
Une barre verticale collée au bord gauche. Une seule colonne foncée, la colonne 0, sur toute la hauteur. Le reste est clair.	Chaque jeton envoie presque tout sur le premier jeton de la phrase. La tête ne relie rien : elle se gare. C'est le puits — le softmax l'oblige à poser ses 100 % quelque part, et ces têtes-là les posent, mesure faite, sur le jeton 0.	couche 9, tête 5 — puits 1,000, la plus haute des 144. Sur « Du bruit pur », la ligne du jeton 12 met 100 % sur la colonne 0.
Un trait fin juste sous la diagonale. Une case foncée par ligne, toujours décalée d'un cran vers la gauche.	Chaque jeton envoie presque tout sur celui qui le précède immédiatement. C'est la tête jeton précédent. Elle ne relie pas les deux copies de la phrase : sa case foncée reste collée à la diagonale, un cran à gauche.	couche 3, tête 0 — précédent 0,857, très loin devant la deuxième du classement, à 0,555. Ligne du jeton 12 : 96,9 % sur aline, qui est le jeton 11.
Une deuxième diagonale, parallèle à la vraie, décalée vers la gauche. Elle n'apparaît que sur une phrase qui se répète.	Chaque jeton de la deuxième copie regarde le jeton qui avait suivi sa première occurrence. C'est l'induction, la recopie. Sur « Du bruit pur » le motif fait 12 jetons, donc la deuxième diagonale est décalée de 11 colonnes (12 pour retomber sur le même jeton, moins 1 pour prendre celui qui le suivait).	couche 6, tête 6 — induction 0,850, la meilleure des 144, de peu : la suivante est à 0,849. Ligne du jeton 12 : 89,0 % sur la colonne 1.

Une quatrième forme n'a pas de nom parce qu'elle ne dit rien : le nuage. Des cases moyennes un peu partout, sans structure. C'est le cas ordinaire — couche 0, tête 3, sur la ligne du jeton 12, met 27 % sur elle-même, 20 % sur der, 16 % sur itzerland, puis s'étale. Sa note d'induction : 0,019. La plupart des 144 têtes ressemblent à ça. C'est pour cette raison qu'on les note toutes au lieu de les choisir à l'œil.

Faire tourner la page

Choisis une phrase dans les boutons de la section 1. « Du bruit pur » est la plus lisible pour commencer : ses jetons sont tirés au hasard, donc aucune grammaire et aucun sens ne peuvent expliquer une deuxième diagonale. Seule la répétition le peut.
Balaye la grille des 144 vignettes. Les 12 lignes sont les 12 couches, couche 0 en haut ; les 12 colonnes sont les 12 têtes de cette couche. Cherche les formes du tableau ci-dessus.
Clique une vignette pour l'ouvrir en grand, avec les jetons écrits sur les deux bords. Les boutons « voir » des classements ouvrent directement une tête nommée.
Survole une case : la ligne sous l'image donne le jeton qui regarde, le jeton regardé et le pourcentage. C'est le seul endroit où on lit un nombre plutôt qu'une nuance de bleu.
Change de phrase sans changer de tête. C'est l'exercice qui apprend le plus. Ouvre couche 4, tête 6 sur « Deux prénoms », une phrase anglaise ordinaire : c'est une barre verticale, chaque ligne met au moins 78 % sur la colonne 0. Repasse sur « Du bruit pur » sans toucher à la tête : la barre s'affaisse et une deuxième diagonale apparaît.
Les notes du run disent la même chose en grand, sur des phrases qui ne sont pas celles de la page : couche 4 tête 6 obtient un puits de 0,987 sur les 8 phrases anglaises de l'épreuve, et une induction de 0,815 sur les 40 séquences répétées. La tête n'a pas changé, l'entrée oui.

4. Ce que fait chaque tête, mesuré

Une carte de chaleur ne prouve rien : l'œil trouve des motifs partout. Alors on donne à chacune des 144 têtes quatre notes calculées, pas devinées. Chaque note est une moyenne d'attention vers des positions précises.

Note	Ce qu'on mesure	Sur quoi
puits	attention vers le jeton 0	8 phrases anglaises ordinaires, écrites à la main dans le code du run : « The doctor asked the nurse… », « In 1969 the first humans landed on the Moon… », « A small brown dog was sleeping under the kitchen table… », etc.
précédent	attention vers le jeton juste avant
soi	attention vers le jeton courant
induction	attention vers le jeton qui avait suivi la précédente occurrence du jeton courant	40 séquences tirées au hasard puis répétées

Pour les trois premières notes, la ligne 0 est écartée du calcul — le premier jeton n'a que lui-même à regarder, une case pleine là ne voudrait rien dire. Sans cette précaution, la note « puits » serait gonflée par un artefact.

Le détail de l'induction compte : la séquence est aléatoire, elle n'a aucun sens. Le modèle ne peut pas s'en sortir par le vocabulaire, la grammaire ou la culture générale. La seule stratégie qui marche est de retrouver où le jeton courant est déjà apparu et de recopier ce qui venait après. Une tête qui note haut sur cette épreuve fait vraiment ce travail-là.

Comment on a trouvé ces têtes (on n'en a choisi aucune)

Personne n'a désigné la couche 6, ni la tête 6, ni la couche 4. On a fabriqué une épreuve, on l'a fait passer aux 144 têtes sans exception, chacune est ressortie avec une note chiffrée, et on a trié la colonne.

Couche 6 tête 6 arrive première avec 0,850, couche 4 tête 8 juste derrière avec 0,849 — comme un élève sort premier d'un classement, pas parce qu'on l'a montré du doigt.

Le choix humain est en amont, et il est unique : décider quelle case de la matrice on va lire. Une fois cette case fixée, plus personne ne choisit — la machine lit les 144 têtes et trie. Tout ce qui suit sert à montrer quelle case, et pourquoi celle-là.

Deux épreuves, en fait. Celle décrite ici note l'induction (des séquences répétées). Les trois autres notes — puits, précédent, soi — sortent d'une seconde épreuve : 8 phrases anglaises ordinaires, sur lesquelles on lit des positions fixes (le jeton 0, le jeton d'avant, le jeton lui-même). Même principe, cases différentes.

L'épreuve : une séquence qui ne veut rien dire

L'épreuve est une suite de 25 jetons tirés au hasard dans une large tranche du vocabulaire, puis recollée à elle-même : 50 jetons, deux copies identiques d'une bouillie.

Le hasard n'est pas de la coquetterie, c'est toute l'astuce. Sur une phrase anglaise normale, une tête peut avoir l'air brillante en s'appuyant sur la grammaire, sur les mots fréquents, sur ce qui traînait dans son corpus d'entraînement. Ici il n'y a rien de tout ça : aucune grammaire, aucun sens, aucun mot attendu après un autre.

Reste une seule régularité exploitable dans une telle suite : le jeton courant est déjà passé plus tôt, et quelque chose le suivait. La note mesure exactement ça — combien d'attention part vers ce quelque chose. C'est la note appelée induction, dont le classement suit juste en dessous : un nom savant pour « recopier ce qui venait après, la fois d'avant ».

Le cas travaillé : une seule case d'un seul tableau

Prenons la phrase « Du bruit pur » de la grille plus haut : 12 jetons tirés au hasard, répétés une fois. Chaque tête rend donc un tableau de 24 lignes et 24 colonnes — une ligne par jeton qui regarde, une colonne par jeton regardé, et chaque ligne partage 100 % entre ses colonnes.

Les douze jetons sont, dans l'ordre : 0 itarian, 1 Figure, 2 onze espaces, 3 Mus, 4 für, 5 conservative, 6 theme, puis cinq autres. Les mêmes reviennent aux positions 12 à 23.
On se place sur la ligne 12. C'est le deuxième itarian ; le premier était en position 0.
Que suivait itarian la première fois ? Figure, en position 1.
Une tête qui recopie met donc son attention de la ligne 12 sur la colonne 1. Une seule case à lire : (12, 1).
On lit cette même case dans les 144 tableaux. Voici ce qu'on y trouve pour cinq d'entre eux — montrés pour l'exemple, un de chaque genre : la première du classement, la deuxième, une tête « jeton précédent », un puits, et une tête quelconque. Le calcul, lui, passe sur les 144 sans exception.

Tête	case (12, 1)	Où va vraiment son attention, ligne 12	Lecture
couche 6, tête 6	0,890	col. 1 Figure 0,89 · col. 6 theme 0,04 · col. 0 itarian 0,03	presque tout son poids sur la case attendue
couche 4, tête 8	0,227	col. 0 itarian 0,49 · col. 1 Figure 0,23 · col. 6 theme 0,20	la case attendue reçoit sa part, mais le premier jeton en reçoit deux fois plus
couche 3, tête 0	0,000	col. 11 aline 0,97	tout sur le jeton juste avant la ligne 12, rien sur la copie
couche 9, tête 5	0,000	col. 0 itarian 1,00	tout sur le tout premier jeton de la phrase
couche 0, tête 3	0,008	col. 12 itarian 0,27 · col. 10 der 0,20 · col. 8 itzerland 0,16	réparti sur plusieurs colonnes, la plus grosse part sur la ligne elle-même (colonne 12)

Ces cinq têtes voient exactement la même phrase, dans le même passage du modèle. Rien ne les distingue à part le nombre inscrit dans la case (12, 1). Aucun jugement n'intervient : on compare des cases.

De cette case unique à une note

D'où vient le décalage de 11 et pas de 12 ? On recule de 12 pour retomber sur le même jeton, puis on avance d'un cran pour prendre celui qui le suivait : 12 − 1 = 11. C'est l'unique calcul de toute la démonstration.

Une case, c'est une anecdote. On refait donc la même lecture ligne après ligne dans la deuxième copie : ligne 13 vers colonne 2, ligne 14 vers colonne 3, et ainsi de suite jusqu'à la ligne 22. Moyenne de ces onze cases.

La ligne 23 n'est pas comptée, et ce n'est pas un tri arrangeant : à la ligne 23, la colonne à lire serait la 12, c'est-à-dire le début de la deuxième copie. Il n'y a plus rien de « déjà vu » à viser. On s'arrête donc à la ligne d'avant.

Cette moyenne dépend encore du tirage : ce motif-là était peut-être facile. Alors on recommence sur 40 séquences aléatoires différentes et on remoyenne. La note du run, c'est ça — et rien d'autre.

Tête	Moyenne sur cette seule phrase	Note du run, 40 séquences
couche 6, tête 6	0,869	0,850
couche 4, tête 8	0,774	0,849
couche 3, tête 0	0,000	0,000
couche 9, tête 5	0,091	0,028
couche 0, tête 3	0,050	0,019

Les valeurs bougent d'une colonne à l'autre — 0,774 contre 0,849 pour couche 4 tête 8 — mais l'ordre des cinq têtes, lui, ne bouge pas. Une tête haute sur cette phrase reste haute sur 40 tirages ; une tête à zéro reste à zéro. Le classement ne tient donc pas à ce motif-ci.

Fin de l'histoire. Les 144 têtes passent les deux épreuves, chacune ressort avec ses 4 notes, on trie le tableau, on lit les premières lignes. Ce sont les classements juste en dessous — obtenus sans qu'à aucun moment quelqu'un ait écrit « regarde la couche 4 ».

Une écriture, deux formes : le run note entre 0 et 1 (0,850), la page affiche en pourcentage (85,0 %). C'est le même nombre. Et les tailles d'échantillon — 40 séquences, 25 jetons, 8 phrases, 32 séquences d'épreuve, 8 tirages au hasard — ont été fixées avant de regarder le moindre résultat : ce sont des réglages, pas des conclusions.

La note, en 11 additions et une division

Voici, sans rien cacher, toutes les cases qui entrent dans la note de couche 6 tête 6 sur la phrase « Du bruit pur ». Une ligne du tableau de la tête, une colonne, une valeur lue.

On est à la ligne	On lit la colonne	Valeur
12 itarian	1 Figure	0,890
13 Figure	2 (espaces)	0,996
14 (espaces)	3 Mus	0,216
15 Mus	4 für	0,686
16 für	5 conservative	0,949
17 conservative	6 theme	0,965
18 theme	7 annels	0,906
19 annels	8 itzerland	0,996
20 itzerland	9 Comb	0,973
21 Comb	10 der	0,980
22 der	11 aline	1,000
somme		9,557
divisé par 11		0,869

Pas de formule cachée, pas de pondération : onze nombres additionnés, divisés par onze. Pour couche 3 tête 0, les onze mêmes cases valent toutes 0,000 — elle ne met jamais rien là. Sa note est donc 0,000, et ce n'est pas une punition : elle fait un autre métier, qui se lit dans une autre case.

Le run, lui, ne travaille pas sur cette phrase de 12 jetons mais sur des séquences de 25 jetons répétés — soit 24 cases par séquence, sur 40 séquences. La note publiée, 0,850, est la moyenne de 960 nombres. Le même calcul tourne pour les 144 têtes : 138 240 cases lues en tout.

Les 144 notes, triées, d'un seul coup d'œil

Une barre par tête, la plus haute à gauche. C'est ça, le classement — et c'est la seule raison pour laquelle couche 6 tête 6 est en tête : elle est la première ligne du tableau trié.

Change de note et regarde la pile se réorganiser complètement : les têtes qui dominent l'induction ne sont pas celles qui dominent « jeton précédent ». Chaque note range les mêmes 144 têtes dans un ordre différent, parce que chaque note lit une case différente.

Le résultat qui surprend : des têtes qui ne font rien

Cinq têtes envoient 99,6 à 100,0 % de leur attention sur le tout premier jeton d'une phrase ordinaire — couche 9, tête 5, à 1,000. Elles ne lisent rien. C'est le puits d'attention : le softmax force chaque tête à répartir 100 % quelque part, alors celle qui n'a rien à dire sur cette phrase se gare sur le jeton 0.

Et ce n'est pas cinq têtes marginales : 38 des 144 dépassent 90 % de puits. Le phénomène est massif.

Une tête n'a pas un métier. Les trois premières du classement d'induction sont aussi des puits presque parfaits sur l'anglais ordinaire : couche 6 tête 6 à 0,994, couche 4 tête 8 à 0,953, couche 4 tête 6 à 0,987. La même tête est muette ou décisive selon l'entrée. C'est pour ça que les deux notes sont mesurées sur deux corpus différents — et pourquoi « à quoi sert cette tête ? » n'a pas de réponse unique.

Le circuit, lui, se lit. Une seule tête domine le classement « jeton précédent » : couche 3, tête 0, à 0,857 quand la deuxième est à 0,555. Juste au-dessus d'elle, la couche 4 porte quatre des huit meilleures têtes d'induction. Une tête qui marque « le jeton d'avant » en couche 3, des têtes qui s'en servent pour recopier en couche 4 : c'est la structure en deux étages décrite dans la littérature — retrouvée ici sur ce modèle, avec nos propres séquences, sans l'avoir cherchée.

5. Et les poids, on les voit où ?

Tout ce qu'on a regardé jusqu'ici est une sortie : change la phrase, les 144 cartes changent. Les poids, eux, ne bougent jamais — ce sont les 162 322 944 nombres fixés à la fin de l'entraînement. Une tête n'est rien d'autre qu'une tranche de ces nombres.

Dans le modèle	Forme	Nombres
`layers[6].attention.query_key_value.weight`	2304 × 768	1 769 472
`layers[6].attention.dense.weight`	768 × 768	589 824

Ces deux matrices portent les 12 têtes de la couche 6, empilées. La tête 6 occupe les lignes 1152 à 1343 de la première et les colonnes 384 à 447 de la seconde. Découpées, ça donne quatre tranches :

Wq · la question

64×768

ce que ce jeton cherche

Wk · la clé

64×768

ce que chaque jeton offre

Wv · la valeur

64×768

ce qui est transporté

Wo · la sortie

768×64

ce qui repart dans le modèle

196 608 poids en tout, soit 0,121 % du modèle. C'est ça, physiquement, « la tête (6,6) ». Les cartes d'attention, elles, ne sont stockées nulle part : elles sont recalculées à chaque phrase.

Et ils sont illisibles. Les huit premiers nombres de Wq : 0,0189 · 0,0013 · 0,0005 · 0,0005 · −0,0400 · 0,0120 · −0,0015 · −0,0029. L'ensemble tient entre −0,374 et 0,447, écart-type 0,079. Aucun de ces nombres ne « veut dire » quelque chose, et personne ne sait les lire directement.

C'est toute la différence avec le détecteur d'offres de ce site, dont les poids se lisent mot à mot — jobs = +8,41, career = +4,96. Là, un poids est collé à un mot. Ici, il faut passer par les sorties pour dire quoi que ce soit — et c'est exactement pour ça que cette page mesure des cartes plutôt que des poids.

La preuve que la carte sort bien de ces poids-là. Le script training/local/attention_poids.py découpe les 196 608 nombres, refait le calcul complet à la main — normalisation, question × clé, encodage des positions, masque, softmax — et compare le résultat à la carte que le modèle produit lui-même.

Écart maximum : 7,73 × 10⁻⁷. La case (12, 1) refaite à la main donne 0,889903 ; le modèle donne 0,889903. Les onze cases de la note remoyennées donnent 0,869.

La carte d'attention n'est donc pas une illustration ni une approximation : c'est le produit exact des poids et de l'entrée. C'est aussi le seul moyen honnête de relier les deux — sans ce contrôle, « la carte vient des poids » serait une affirmation de plus.

6. Combien de têtes, et qui le décide ?

Non : la couche ne décide rien. Le nombre de têtes est écrit une seule fois, pour le modèle entier, et chaque couche reçoit la même valeur. Il n'a aucun lien avec le nombre de couches — sur les modèles posés sur cette machine, les deux nombres diffèrent presque toujours, et il arrive même qu'ils bougent en sens inverse.

D'où vient la question : Pythia-160M affiche 12 et 12

Le fichier de configuration de Pythia-160M, celui que lisent les runs 059 à 061, porte deux clés distinctes qui tombent sur la même valeur :

num_hidden_layers : 12 — le nombre de couches
num_attention_heads : 12 — le nombre de têtes
hidden_size : 768 — la largeur du modèle

Lu par cat sur /root/.cache/huggingface/hub/models--EleutherAI--pythia-160m-deduped/snapshots/582159a2.../config.json. Ce sont deux clés indépendantes, pas une clé qui en déduit l'autre. grep -c num_attention_heads renvoie 1 : il n'existe qu'une seule déclaration de têtes pour tout le modèle, et aucune clé par couche.

Deux clés séparées qui valent 12 toutes les deux, c'est exactement ce qui fait naître l'idée d'un lien. Le lien n'existe pas, et la preuve est dans la même famille d'architecture, dans le même cache.

Le contre-exemple, dans la même architecture

tiny-random-GPTNeoXForCausalLM est un modèle de test présent dans le cache local. Son model_type est gpt_neox, exactement celui de Pythia. Son config donne 5 couches et 4 têtes. Même code, mêmes clés, deux nombres différents.

Et les modèles du projet le confirment à plus grande échelle :

Qwen2.5-0.5B

24 / 14

24 couches, 14 têtes. Lu dans l'en-tête des 9 fichiers qwen25-05b-*.gguf.

Qwen2.5-1.5B

28 / 12

28 couches, 12 têtes. Le modèle est plus gros, et il a moins de têtes que le 0.5B.

run-004f, modèle maison

5 / 6

{'dim': 192, 'heads': 6, 'blocs': 5}, lu dans le point de sauvegarde lui-même.

Le passage du 0.5B au 1.5B est le cas le plus net : les couches augmentent (24 → 28) pendant que les têtes diminuent (14 → 12). Si un lien existait, ce serait impossible.

Le relevé complet, modèle par modèle

Modèle	Couches	Têtes	Largeur	Taille d'une tête	Têtes clés/valeurs
Pythia-160M-deduped config.json	12	12	768	64	12
tiny-random-GPTNeoX config.json	5	4	32	8	4
Qwen2.5-0.5B en-tête GGUF	24	14	896	64	2
Qwen2.5-1.5B en-tête GGUF	28	12	1536	128	2
run-004f-sketchy-scratch .pt	5	6	192	32	6
run-034-moe train.py	8	6	384	64	6
run-013-vqgpt train.py	6	8	256	32	8
run-003-attention mini_transformer.py	1	4	100	25	4

Sources : config.json du cache HuggingFace pour les deux premiers ; en-tête GGUF lu octet par octet pour les Qwen (qwen2.block_count, qwen2.attention.head_count, qwen2.attention.head_count_kv, qwen2.embedding_length) ; torch.load pour run-004f ; train.py lignes 30-32 pour run-034 (D = 384, COUCHES = 8, TETES = 6), ligne 179 pour run-013 (def __init__(self, dim=256, heads=8, blocs=6, ...)), ligne 19 de mini_transformer.py pour run-003. Sur les 8 lignes du tableau, une seule a couches = têtes.

Toutes les couches d'un modèle ont le même nombre de têtes

Ce n'est pas une supposition, ça se lit dans la forme des poids. Dans qwen25-05b-base-q8.gguf, les 24 matrices de requêtes blk.N.attn_q.weight ont toutes la forme (896, 896) — une seule forme distincte sur 24 couches. Dans qwen25-15b-base-q8.gguf, les 28 ont toutes (1536, 1536). Chez Pythia, les 12 layers.N.attention.query_key_value.weight ont toutes la forme [2304, 768].

Il n'y a d'ailleurs nulle part où écrire un nombre de têtes par couche : le format GGUF stocke qwen2.attention.head_count comme un entier unique, et le config de Pythia n'a qu'une clé num_attention_heads. Le code du projet fait la même chose : self.blocs = nn.ModuleList(Bloc(dim, heads, ffn_dim) for _ in range(blocs)) — heads est écrit une fois, la boucle le repasse tel quel à chaque bloc.

La vraie relation : une division de la largeur

largeur = nombre de têtes × taille d'une tête

Pythia-160M : 768 = 12 × 64
Qwen2.5-0.5B : 896 = 14 × 64
Qwen2.5-1.5B : 1536 = 12 × 128
run-004f : 192 = 6 × 32
run-034-moe : 384 = 6 × 64
run-003 : 100 = 4 × 25

Les têtes découpent la largeur, elles ne s'y ajoutent pas. C'est déjà écrit dans le code du projet, trois fois : self.dim, self.heads, self.d_head = dim, heads, dim // heads (mini_transformer.py ligne 22), self.heads, self.d_head = heads, dim // heads (mini_gpt.py ligne 32), self.heads, self.dh = heads, dim // heads (run-013/train.py ligne 161). Et dans run-059/train.py ligne 65 : DIM = cfg.hidden_size // NT.

Conséquence directe : la division doit tomber juste. D'où les gardes écrites à la main dans le projet — assert dim % heads == 0 (mini_transformer.py ligne 21) et assert large % tetes == 0 (run-062-tetes-largeur/train.py ligne 83). Ce même run-062 est la démonstration en acte : ses couches sont figées à 4 (def __init__(s, large, tetes, couches=4)) pendant que les têtes balaient 1, 2, 4, 8, 16, 32 à largeur 256 constante — soit des têtes de 256, 128, 64, 32, 16 et 8. Deux réglages, deux boutons.

La taille d'une tête n'est écrite dans aucun de ces fichiers. Ni le config de Pythia, ni les 16 en-têtes GGUF ne portent de clé head_dim, key_length ou value_length — recherche explicite sur ces trois motifs, aucun résultat. Elle est toujours déduite par division. Elle est ensuite recoupée par la forme des tenseurs, ce qui la rend sûre : chez Pythia, 2304 = 3 × 12 × 64 ; chez Qwen 0.5B, la sortie clés vaut 128 = 2 × 64.

Oui, certains modèles ont moins de têtes de clés que de têtes de requêtes

C'est l'attention groupée : plusieurs têtes de requêtes se partagent un même jeu de clés et de valeurs, pour alléger la mémoire. Les 16 modèles Qwen du projet le font tous, et ça se lit deux fois.

Dans l'en-tête : qwen2.attention.head_count = 14 mais qwen2.attention.head_count_kv = 2 sur le 0.5B, soit 7 têtes de requêtes par tête clés/valeurs. Et 12 contre 2 sur le 1.5B, soit 6 pour 1.

Dans les poids : sur les 24 couches du 0.5B, attn_q.weight fait (896, 896) alors que attn_k.weight et attn_v.weight ne font que (896, 128). Sur les 28 couches du 1.5B, (1536, 1536) contre (1536, 256). Les matrices de clés et de valeurs sont littéralement 7 fois, puis 6 fois plus petites que celles des requêtes — et elles portent la même quantisation, donc le rapport vaut aussi sur le disque.

Les adaptateurs LoRA du projet montrent la même asymétrie, cette fois dans des poids PyTorch entraînés sur cette machine : run-015-adaptateur-lora a q_proj.lora_B de forme (896, 16) mais k_proj.lora_B et v_proj.lora_B de forme (128, 16), sur les 24 couches. run-046-detecteur-15b : (1536, 16) contre (256, 16), sur les 28 couches.

Pythia, lui, ne fait pas d'attention groupée : la clé num_key_value_heads est absente de son config (grep -c renvoie 0), et son bloc QKV fusionné vaut 2304 = 3 × 768, soit autant de place pour les clés et les valeurs que pour les requêtes. Aucun modèle écrit à la main dans le projet n'en fait non plus.

Deux précisions sur ce qui vient d'où

La géométrie des Qwen (24 couches / 14 têtes, 28 couches / 12 têtes) n'est pas un choix fait dans ce projet : elle est héritée des modèles de départ. Les deux fichiers base portent un lien de licence vers huggingface.co/Qwen/Qwen2.5-0.5B et Qwen2.5-1.5B. Les 14 autres fichiers ne portent aucune trace de leur variante dans l'en-tête : sft, rl, grpo, star, skills… n'existent que dans le nom de fichier.

En revanche l'entraînement a bien changé les poids sans jamais toucher à la forme : les 9 fichiers 0.5B ont tous une géométrie identique (24 couches, 896, 14 têtes, 2 kv, 290 tenseurs) et les 7 fichiers 1.5B aussi (28 couches, 1536, 12 têtes, 2 kv, 338 tenseurs), mais les premiers octets de blk.0.attn_q.weight donnent 16 empreintes sha256 toutes différentes, à des décalages de fichier identiques. Même plan mémoire, contenu différent.

Ce qui n'a pas pu être établi

Aucun modèle, sur cette machine, n'a un nombre de têtes qui varie d'une couche à l'autre. On peut donc prouver que ça n'arrive jamais ici, pas que ça n'existe nulle part.
La preuve que toutes les couches ont le même nombre de têtes est empirique : elle vient des formes de tenseurs, pas d'une déclaration. Aucun de ces formats ne prévoit d'écrire un nombre de têtes par couche — ce qui est en soi un indice, mais pas une déclaration.
La taille d'une tête n'est lue nulle part : elle est calculée par division, puis recoupée sur les formes.
Les chiffres des Qwen viennent des exports GGUF du projet, lus avec un lecteur d'en-tête écrit pour l'occasion. Aucun config.json d'origine de Qwen2.5 n'est présent sur cette machine.
Le nombre de têtes de run-003-attention.pt n'est pas dans le fichier de poids : ses clés racine sont run, state_dict, vocab, max_tokens, acc_test. Le 4 vient de la valeur par défaut de mini_transformer.py, non surchargée à l'appel — c'est une inférence à partir du code, pas une lecture du fichier.
Rien ici ne dit ce que les têtes font, seulement combien il y en a et quelle place elles occupent.

7. Le découpage change-t-il la qualité ?

Le fait qui rend la question intéressante : à 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 ne fait que regrouper les mêmes nombres autrement. Si la qualité change, ce n'est donc pas parce qu'on a ajouté de la capacité.

Le run-062 entraîne 24 modèles écrits de zéro — 8 configurations × 3 graines — sur du Shakespeare au caractère. Trois graines, parce qu'un écart de 0,01 sans elles est indiscernable du bruit d'initialisation.

Balayage A — largeur 256 fixe, on change le découpage

Découpage	Poids	Perte de validation	Écart-type sur 3 graines
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

La colonne des poids est identique sur les six lignes — le run le vérifie et refuse de conclure si ce n'est pas le cas.

Oui, le découpage compte — et l'optimum est au milieu. Écart du meilleur au pire : 0,0299, contre 0,0032 de bruit entre graines. Neuf fois le bruit : ce n'est pas un accident de tirage.

Les deux extrêmes perdent, mais pas également. Une seule grosse tête coûte +0,0044 ; trente-deux têtes minuscules coûtent +0,0299, soit sept fois plus. Émietter est bien plus coûteux que regrouper — à 8 dimensions par tête, une tête ne peut presque plus rien distinguer.

L'optimum tombe sur des têtes de 64, exactement la valeur qu'utilisent Pythia-160M et Qwen2.5-0.5B (section 6). Ce n'est pas une confirmation d'autorité : c'est le même optimum retrouvé indépendamment, sur un autre corpus et à une autre échelle.

Balayage B — le témoin d'échelle, qui n'a pas fait ce que j'attendais

Pour savoir si 0,0299 est beaucoup ou peu, il faut une référence : que vaut un vrai gain de capacité ? On fixe donc la taille de tête à 64 et on fait varier la largeur.

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 ça compte. 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 ». C'est que le budget d'entraînement est saturé : 2 000 pas et un corpus d'un million de caractères ne suffisent pas à un modèle de 12,7 millions de poids. À budget fixé, le plus gros modèle n'est pas le meilleur — il est le moins bien entraîné.

J'avais écrit le run en supposant que ce balayage donnerait une échelle propre. Il donne autre chose, et je le publie tel quel : le seul écart de capacité exploitable ici est 128 → 256, et c'est celui-là qu'il faut comparer.

La réponse à la question, avec les deux chiffres côte à côte :

Changer le découpage

0,030

du meilleur au pire, à poids strictement identiques

Quadrupler la capacité

0,133

de 128 à 256 de largeur

La capacité vaut environ 4,4 fois le découpage. Le nombre de têtes n'est donc pas un levier de qualité : c'est un réglage, qui coûte s'il est mal mis et ne rapporte presque rien s'il est bien mis. Ni « la taille » ni « le nombre » n'augmente la qualité — ils se partagent une largeur, et c'est la largeur qui compte.

Portée du résultat : un corpus, une profondeur (4 couches), un budget d'entraînement. Rien ne dit que l'optimum reste à 64 sur un modèle de 70 milliards. Ce qui est établi ici, c'est la forme du compromis et son ordre de grandeur. Tout est dans tetes062.json.

8. Les réglages d'un modèle, en clair

Cette page a manipulé des mots — largeur, têtes, couches — sans jamais les poser côte à côte. Les voici tous. Un modèle de langue, du plus petit au plus gros, est entièrement décrit par sept nombres. On les écrit dans un fichier avant de lancer l'entraînement. Aucun n'est appris : ils sont décidés, et ils ne changent plus.

Le réglage	En clair	Pythia-160M	Ce qui se passe si on l'augmente
largeur « hidden size »	Combien de nombres décrivent un jeton à l'intérieur du modèle. C'est la taille du paquet qui traverse tous les étages.	768	La qualité monte, les poids montent vite. C'est le vrai levier (section 7).
taille de tête	Combien de ces nombres une seule tête reçoit. Chaque tête ne voit qu'une tranche du paquet, jamais le paquet entier.	64	Rien en soi : elle prend sa place sur le voisin.
nombre de têtes	En combien de tranches la largeur est découpée à chaque étage.	12	Rien non plus, seul. Mal réglé, ça coûte ; bien réglé, ça ne rapporte presque rien.
têtes de clés « têtes KV »	Combien de tranches ont leur propre clé et valeur. Souvent moins que le nombre de têtes : plusieurs têtes se partagent alors les mêmes.	12	Ne change pas la qualité ; change la mémoire nécessaire pour lire long (section 9).
couches	Combien de fois le paquet est retravaillé, l'un après l'autre. Chaque couche a son propre jeu de têtes et son propre bloc dense.	12	La qualité monte, les poids montent, et le calcul devient plus long à dérouler.
taille du bloc dense « FFN »	Le morceau de calcul placé après l'attention dans chaque couche. Il ne compare pas les jetons entre eux : il retravaille chacun séparément.	3 072	Les poids montent le plus vite de tous — c'est déjà le plus gros bloc du modèle.
vocabulaire	Combien de jetons distincts le modèle connaît. Sa liste de morceaux de mots.	50 304	Textes découpés en moins de jetons, mais deux grosses tables de poids qui grossissent.
contexte	Combien de jetons il peut lire d'un seul tenant.	2 048	N'ajoute aucun poids, et coûte pourtant le plus cher à l'usage. C'est toute la section 9.

Le seul lien obligatoire entre eux

largeur = nombre de têtes × taille de tête

Chez Pythia : 12 × 64 = 768. Deux des trois nombres suffisent, le troisième s'en déduit — c'est pour ça qu'on ne peut pas « ajouter des têtes » sans les rétrécir. Tous les autres réglages sont libres les uns des autres.

Le nombre de couches, en particulier, ne décide de rien. Il n'impose ni le nombre de têtes ni la largeur, et toutes les couches d'un même modèle partagent exactement le même découpage — le relevé de la section 6 le montre sur six modèles.

Où sont réellement les poids

Toute cette page parle d'attention. Il faut donc dire ce qu'elle pèse. Voici les 162 322 944 poids de Pythia-160M, rangés par bloc — lus dans le fichier du modèle, pas estimés.

Bloc	Poids	Part	Ce que c'est
bloc dense (FFN)	56 669 184	34,9 %	12 couches × deux matrices 768 × 3 072
embeddings d'entrée	38 633 472	23,8 %	50 304 jetons × 768 : le paquet de départ de chaque jeton
embeddings de sortie	38 633 472	23,8 %	la même table à l'envers, pour produire les pourcentages finaux
attention	28 366 848	17,5 %	les 144 têtes de cette page, Q, K, V et sortie comprises
layernorm et biais	19 968	0,0 %	de petits réglages par couche

L'attention, c'est 17,5 % du modèle. Les 144 cartes de cette page, les têtes d'induction, la tête (3, 0) sans qui plus rien ne se copie — tout ça tient dans moins d'un cinquième des poids. Le reste est ailleurs : un tiers dans les blocs denses, la moitié dans les deux tables de jetons.

Et une tête seule, c'est 0,121 % — les 196 608 poids de la section 5. C'est le bon ordre de grandeur à garder en tête quand on lit « telle tête fait telle chose » : on parle d'un millième du modèle.

9. Jusqu'où le modèle peut lire

Le contexte est le réglage à part. Il n'apparaît dans aucun compte de poids — un modèle qui lit 2 048 jetons et le même qui en lit 32 768 pèsent pareil. Et pourtant c'est lui qui décide si le modèle tient sur une carte graphique. Quatre verrous différents le limitent, chacun branché sur un paramètre différent.

Verrou 1 — le plafond écrit dans le fichier

Un entier, max_position_embeddings ou context_length. Il ne garantit rien, il autorise. C'est une déclaration de l'auteur du modèle, pas une propriété mesurée.

Verrou 2 — la table de positions, quand elle est apprise

Une tête ne sait pas dans quel ordre les jetons arrivent : elle voit un sac. Il faut donc lui dire où chacun se trouve. La façon la plus simple, celle de mes deux modèles maison, est d'apprendre un paquet de nombres par position — une ligne pour la position 0, une pour la 1, et ainsi de suite.

Ça coûte contexte × largeur poids : 128 × 256 = 32 768 dans mon run-062, soit 1,02 % du modèle. Bon marché. Mais à la position 128, il n'y a plus de ligne. Le code ne se dégrade pas : il s'arrête. C'est un mur franc, et c'est la seule limite de contexte qui soit honnête.

Verrou 3 — la base de rotary, quand les positions sont calculées

Pythia et Qwen n'apprennent aucune position. Ils appliquent une formule : chaque paire de nombres de la tranche d'une tête est tournée d'un angle proportionnel à la position. Aucune table, donc aucun mur — on peut leur passer n'importe quelle longueur, ça calcule.

Mais chaque paire tourne à sa propre vitesse, et la plus lente finit quand même par boucler. Au-delà de ce tour complet, deux positions éloignées redeviennent indiscernables. Le réglage qui commande la longueur de ce tour est la base.

Ce que la base règle, en une horloge

Rotary — on écrit aussi RoPE — c'est la méthode. Au lieu de ranger la position d'un jeton dans une table, on prend les nombres de la tranche d'une tête deux par deux, et on fait tourner chaque paire d'un angle proportionnel à la position. Pas les mots : les nombres. La base est le réglage principal de cette méthode — un entier écrit dans le fichier du modèle, 10 000 chez Pythia, 1 000 000 chez Qwen.

Ci-dessous, un cadran par paire. Le premier des deux jetons comparés 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. Une fois qu'elle a fait son tour, elle confond cet écart avec un écart bien plus court.

Pythia-160M — base 10 000, 8 paires tournées, fenêtre déclarée 2 048 jetons

À 2 048 jetons d'écart, 2 aiguilles sur 8 n'ont pas fini leur premier tour.

écart entre les deux jetons 2 048 j base de rotary 10 000

l'écart part de 1 jeton et monte jusqu'à ce que la dernière aiguille boucle.

Aiguilles qui savent encore

2 sur 8

elles n'ont pas fini leur premier tour

Portée

19 869 jetons

le tour complet de la plus lente

Marge sur la fenêtre déclarée

×9,7

19 869 ÷ 2 048

Ce que cette portée coûte en poids

la base est une ligne de configuration, pas une matrice apprise

Pourquoi la première aiguille ne bouge jamais. Quelle que soit la base, elle tourne d'un radian par jeton : c'est la paire de référence, et elle boucle toujours au bout de 6,3 jetons. La base n'accélère personne — elle écarte les vitesses, en ralentissant les suivantes. C'est pour ça que le premier trait de l'axe reste cloué quand tu tires le curseur, et que tous les autres filent vers la droite.

Une aiguille bouclée n'est pas cassée. Elle sert encore, très bien, pour les jetons voisins : elle ne sait juste plus faire la différence entre proche et lointain. Et le modèle ne lit jamais une aiguille seule — il les lit toutes ensemble. La portée n'est donc pas un mur : c'est le point à partir duquel il ne lui reste plus rien pour distinguer deux positions.

Une aiguille n'est pas une tête. C'est une paire de nombres à l'intérieur de la tranche d'une tête : les 144 têtes de Pythia tournent toutes avec exactement les mêmes 8 aiguilles. Et chez Pythia, seuls 16 des 64 nombres d'une tranche tournent — les 48 autres ne portent aucune position.

Mes deux modèles maison n'ont pas d'horloge et ne sont pas dans la liste : ils apprennent une ligne de nombres par position, c'est le verrou 2 juste au-dessus. C'est ce qui leur donne un mur franc à 128 et 256 jetons.

Ce que cette horloge ne dit pas. Elle ne fait que de la géométrie : à quel écart deux positions se confondent. Elle ne dit rien de la qualité. Pousser la base ne rend pas un modèle bon sur du texte long — il n'a jamais été entraîné à l'être. C'est exactement ce que la fin de cette section reconnaît ne pas avoir mesuré.

Base, dimensions tournées et fenêtre déclarée sont lues dans les fichiers des modèles (contexte.json) ; tout le reste de ce bloc est de l'arithmétique à partir de ces trois nombres. La seule formule, pour qui la veut : le tour complet de la paire numéro n vaut 2π × base^((n−1)/P), où P est 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, pas l'avant-dernière. Qwen 0.5B travaille avec 124 fois sa fenêtre en réserve. Le 1.5B, qui annonce 128 k, n'en a plus que 38 — même base, même famille, mais l'ambition sur le contexte a mangé la marge. Passer la base de 10 000 à 1 000 000 est exactement la manœuvre qu'on emploie pour rallonger un modèle déjà entraîné : elle ne coûte aucun poids. Le bouton « ↗ Pythia avec la base de Qwen » de l'horloge la fait : à 2 048 jetons d'écart, Pythia passe de 2 aiguilles qui savent encore à 4, et sa marge de ×9,7 à ×545,6.

Verrou 4 — la facture, et c'est elle qui tranche en pratique

Elle a deux lignes.

La mémoire. Pour ne pas tout recalculer à chaque nouveau jeton, le modèle garde la clé et la valeur de chaque jeton déjà lu : c'est le cache KV. Sa taille par jeton est 2 × couches × têtes de clés × taille de tête × octets. Elle ne dépend ni de la largeur, ni du FFN, ni du vocabulaire.

Modèle	Le calcul	par jeton	au contexte plein
chargement…

Pythia-160M coûte trois fois plus par jeton que Qwen 0.5B, alors qu'il est trois fois plus petit. Parce que Pythia a 12 têtes de clés et Qwen en a 2.

Le calcul. L'attention compare chaque jeton à chaque jeton : une carte n × n par tête et par couche — exactement les images du haut de cette page. Le total est n² × têtes × couches, et le n² écrase tout le reste.

Modèle	contexte	cases pour un passage plein
chargement…

De Pythia à Qwen 1.5B : près de 10 000 fois plus de calcul d'attention, pour dix fois plus de poids. Doubler le contexte quadruple cette facture, toujours.

Une trace concrète dans le fichier de Pythia : son masque causal, le triangle qui interdit de regarder vers l'avant, est stocké en 2 048 × 2 048 par couche. 50 331 648 nombres — plus que tous les poids d'attention du modèle réunis. Ce ne sont pas des poids appris, mais c'est de la mémoire, et elle grandit en n².

Ce que le nombre de têtes de clés change vraiment

La section 7 concluait que le nombre de têtes n'est pas un levier de qualité. Voici son vrai rôle. Qwen 0.5B a 14 têtes de requêtes et 2 têtes de clés : sept têtes se partagent les mêmes clés et valeurs. La qualité y perd un peu, le cache y gagne beaucoup.

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, même qualité

Sept fois plus de mémoire pour le même modèle. Voilà pourquoi le nombre de têtes de requêtes et le nombre de têtes de clés ont été séparés : le premier est un réglage de qualité, le second un budget de contexte. Sans cette séparation, 32 768 jetons ne tiendraient plus sur la T4 qui a servi à tous les runs de ce projet.

Essaye : quelle facture pour quel réglage

Les mêmes formules, à la main. Change un curseur et regarde ce qui bouge — et surtout ce qui ne bouge pas.

Largeur qui en découle

—

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

—

et ce n'est que le cache : les poids s'ajoutent

Cases d'attention

—

contexte² × têtes × couches

Ce qui n'a aucun effet sur la longueur de contexte

La largeur, le bloc dense, le vocabulaire. Ce sont pourtant les trois quarts des poids du modèle. Un modèle deux fois plus large ne lit pas plus loin : ces blocs travaillent jeton par jeton, ils coûtent par jeton et jamais par paire de jetons. Seuls les réglages qui touchent l'attention — couches, têtes de clés, taille de tête — entrent dans la facture du contexte.

Résumé en une ligne : la base de rotary décide de la portée et ne coûte rien ; couches × têtes de clés × taille de tête décide de la mémoire ; le n² décide du calcul.

Ce que cette section ne mesure pas

Tous les chiffres ci-dessus sont lus ou calculés à partir des fichiers de modèles présents sur ce serveur — les GGUF des deux Qwen, le config.json de Pythia, mes propres train.py. C'est un relevé et de l'arithmétique, pas une expérience.

Ce qui manque : à partir de quelle longueur la qualité décroche réellement. Un modèle qui annonce 128 k n'est pas forcément bon à 128 k, et rien ici ne le teste. Cette mesure-là demande un run, comme celui de la section 7.

10. Voir les têtes de clés

La section précédente dit que Qwen a « 14 têtes et 2 têtes de clés » et que c'est ce qui rend son cache sept fois moins gros. Question légitime : est-ce qu'on peut les voir ? La réponse tient en trois temps — oui dans le fichier, non sur les images, et oui si on coupe.

Oui, dans le fichier — c'est une asymétrie de formes

Les quatre matrices d'attention de la couche 0 de Qwen2.5-0.5B, telles que le run les a lues :

Matrice	Forme	Ce qu'elle produit par jeton
chargement…

La matrice des clés ne produit que 128 nombres par jeton, contre 896 pour les requêtes. Il n'y a de la place que pour 2 jeux de clés face à 14 jeux de requêtes. Sept têtes lisent forcément les mêmes clés — c'est écrit dans la forme du tenseur, avant toute mesure. Chez Pythia, ces quatre matrices font 768 partout : aucune asymétrie, aucun partage.

Non, sur les images — et c'est le point qu'on rate

Il n'existe pas de carte d'attention « de la tête de clés ». Chaque tête garde sa propre requête, donc sa propre carte. Voici les 24 × 14 = 336 cartes de Qwen : le trait vertical marque la frontière entre les deux groupes, têtes 0 à 6 d'un côté, 7 à 13 de l'autre.

24 lignes : les 24 couches. 14 colonnes : les 14 têtes. Clique une vignette pour l'ouvrir en grand.

Rien ne saute aux yeux à la frontière. Les têtes d'un même groupe ne se ressemblent pas visiblement plus que les autres. C'est normal : partager les clés ne partage pas les requêtes, et c'est la requête qui décide de la ligne qu'on lit. Le partage économise de la mémoire — il ne fabrique pas des jumelles.

Une tête de Qwen en grand

Survole une case.

Oui, si on coupe — et là c'est net

La seule façon de rendre le partage visible est celle de la section 12 : on met une pièce à zéro et on regarde ce qui casse. Ici la pièce est une tranche de clés — 64 nombres à la sortie de k_proj — et la question est : quelles têtes changent ?

Si le partage est réel, exactement 7 têtes doivent bouger et les 7 autres ne doivent pas bouger du tout. Pas « presque pas » : écart exactement zéro. Le test a été fait sur les 24 couches × 2 tranches = 48 cas.

Tranche de clés coupée	Têtes qui bougent	Cas	Écart max chez les autres
chargement…

Le témoin, sans qui ce résultat ne vaut rien

« 7 têtes ont bougé » ne dit pas si on mesure le partage ou si on mesure sa propre méthode. Donc le même test, exactement, sur Pythia-160M, qui a 12 têtes et 12 têtes de clés — aucun partage.

chargement…

Deux modèles, une seule méthode, deux réponses différentes et toutes deux exactement celles que la forme des fichiers annonçait. C'est ce qui autorise à dire que le partage est une propriété de Qwen et pas un artefact du crochet.

Deux contrôles de plus, tous deux à écart exactement 0 : les couches situées avant la coupe ne bougent pas (couper les clés de la couche 12 ne peut rien changer aux couches 0 à 11), et le modèle revient intact après chaque crochet. Le run échoue s'ils ne sont pas nuls.

La question à laquelle je n'avais pas la réponse

Partager les clés rend-il les sept têtes d'un groupe semblables ? J'ai écrit ma prédiction dans le script avant de lancer : peu d'écart, parce que les requêtes restent propres à chaque tête. Mesure : corrélation moyenne entre cartes, sur les 24 couches.

+0,027 d'écart sur un fond de +0,73. Deux têtes de Qwen se ressemblent déjà beaucoup, qu'elles partagent leurs clés ou non ; le partage n'ajoute presque rien à cette ressemblance. La prédiction tient.

Une réserve qu'il faut poser : les têtes d'un même groupe sont aussi des voisines par leur numéro (0 à 6, puis 7 à 13). Si des têtes voisines se ressemblaient pour une autre raison, ce test ne saurait pas les distinguer. Vu la taille de l'écart — 0,027 — la question reste académique ici, mais le protocole ne la tranche pas.

Ce que ça dit du réglage. La section 7 montrait que le nombre de têtes n'est pas un levier de qualité. Le voici de l'autre côté : le nombre de têtes de clés n'a rien à voir avec la qualité non plus — c'est un budget de mémoire, et il se paie en cache, pas en perte. Qwen a choisi 2 sur 14. Pythia, plus ancien, n'avait pas ce réglage du tout.

Run-063, 24 secondes, T4 — de l'inférence pure, qui n'avait aucun besoin de GPU : Kaggle refusait les sessions CPU (« Maximum batch CPU session count of 5 reached ») alors que tous mes kernels étaient terminés. Les deux pools sont indépendants, on est passé par l'autre. Tout est dans tetesKV063.json.

11. Ce que veut dire « perte 5,81 »

Tout le tableau qui suit tient sur une seule mesure. À chaque jeton, le modèle produit une répartition de pourcentages sur tout son vocabulaire, c'est-à-dire sur la liste de tous les jetons qu'il connaît. Puis on lui montre le vrai jeton suivant. La perte ne regarde qu'une chose : la part de pourcentage qu'il avait accordée à ce jeton-là.

Petit = grosse part accordée au bon jeton. Grand = part minuscule. La perte ne récompense pas « avoir désigné le bon favori » : elle ignore le classement et ne lit que la part donnée à ce qui est réellement arrivé. On la dit « surprise » par commodité ; il n'y a rien à ressentir là-dedans, c'est un pourcentage transformé en nombre.

Le « nat » est l'unité dans laquelle ce nombre se compte. Elle vient du logarithme naturel, appliqué à cette part — d'où le nom. Une seule chose à en retenir : l'échelle n'est pas linéaire mais multiplicative. Un nat de plus, ce n'est pas « un peu pire », c'est une part plusieurs fois plus petite accordée au bon jeton.

Et « par jeton » veut dire : divisé par le nombre de jetons. Un texte long accumule mécaniquement plus de perte qu'un texte court, sans que le modèle y soit pour rien. On divise donc, et deux passages de longueurs différentes deviennent comparables — c'est ce qui autorise à poser 5,81 et 25,62 côte à côte.

Les deux copies sont les mêmes jetons

L'épreuve : 32 séquences, tirées avec d'autres graines que tout le reste du run. Chacune est faite de 25 jetons tirés au hasard dans une large tranche du vocabulaire, puis recollés à l'identique derrière eux — 50 jetons en tout. Le jeton en position 25 est le même que celui en position 0, le 26 est le 1, et ainsi jusqu'au bout.

Sur la première copie, la perte est de 25,62 nats par jeton. Sur la seconde, 5,81. Or ce sont, jeton pour jeton, les mêmes dans le même ordre. Aucune propriété du texte ne sépare les deux copies. La seule chose qui les distingue, c'est que la seconde a déjà défilé une fois.

L'écart de 19,81 nats ne peut donc venir que de cette répétition : sur la seconde copie, le bon jeton reçoit des parts bien plus grosses, et la seule information disponible en plus est sa première occurrence, 25 positions plus tôt. Ce n'est pas une lecture d'image, c'est une soustraction. Reste à savoir quoi, dans le modèle, exploite cette information — c'est ce que la coupe teste.

Pourquoi 25,62 est un chiffre énorme. Les 25 premiers jetons sont tirés au sort. Rien dans un texte ordinaire ne ressemble à ça : pas de grammaire qui annonce la suite, pas de sujet qui la rende probable. Le modèle n'a aucun moyen de prévoir le jeton suivant, et il ne le prévoit pas. Ce n'est pas un modèle qui hésite entre tous les jetons possibles : c'est un modèle très sûr de lui et systématiquement à côté, qui mise sur des suites plausibles en anglais alors que la suite est un tirage au sort. Ce point de départ ne laisse rien d'autre expliquer le 5,81 de la seconde copie.

12. Le test qui tranche : on coupe

Une note élevée ne prouve rien. Elle dit qu'une tête regarde au bon endroit, pas que la sortie du modèle dépende de ce qu'elle regarde. Un témoin peut fixer la scène du début à la fin sans que son témoignage change le verdict. La seule façon de savoir s'il compte est de rejuger sans lui.

Couper une tête, concrètement

C'est ce qu'on appelle une ablation — en clair : on retire une pièce et on regarde ce qui casse. Ici la pièce est une tête, et on ne l'arrache pas. Chaque tête produit 64 nombres par jeton (par morceau de mot) ; ces 64 nombres sont mis bout à bout avec ceux des 11 autres têtes de la couche, et le tout est recombiné en un seul bloc qui repart dans le modèle.

Couper la tête, c'est mettre ses 64 nombres à zéro juste avant cette recombinaison. Elle calcule toujours, elle répartit toujours ses pourcentages d'attention. Simplement sa part vaut zéro dans le bloc qui continue. Rien n'est modifié dans les poids, les nombres appris pendant l'entraînement : on pose le zéro le temps d'une mesure, on l'enlève après, le modèle est intact pour la mesure suivante.

Pourquoi une deuxième colonne, tirée au hasard

Supposons qu'on ne coupe que les 5 têtes visées. La perte sur la 2ᵉ copie passe de 5,81 à 13,77. On aurait donc un gros dégât et une phrase à écrire. Laquelle ?

Impossible de trancher entre deux explications : le dégât vient d'avoir coupé ces têtes-là, ou simplement d'avoir coupé des têtes, cinq n'importe lesquelles. Peut-être qu'un modèle amputé de 5 de ses 144 têtes va mal de toute façon. Sans point de comparaison, on ne mesure pas l'induction — la capacité à retrouver où le jeton courant est déjà passé et à recopier ce qui venait après —, on mesure l'amputation.

D'où la deuxième colonne : exactement la même coupe, exactement 5 têtes, mais tirées au hasard parmi les 139 autres, et recommencée 8 fois pour ne pas dépendre d'un tirage chanceux. Résultat : 6,38 au lieu de 13,77. Les têtes visées ne sont pas des têtes comme les autres.

Le résultat imaginaire qui aurait tout annulé. Si cette ligne avait rendu 13,77 des deux côtés, la conclusion honnête aurait été : « n'importe quelles 5 têtes font le même dégât ». Le classement d'induction n'aurait alors rien identifié du tout, et les jolies diagonales des sections précédentes seraient restées de jolies diagonales. Le contrôle fait partie de la mesure et pas du commentaire d'après coup : il tourne sur chaque ligne du tableau, y compris celles où il rend le résultat moins net.

On coupe	Perte, 2ᵉ copie	Écart	Mêmes têtes au hasard	Écart	1ʳᵉ copie (témoin)

Perte en nats par jeton : plus bas = le modèle est moins surpris. La 1ʳᵉ copie est imprévisible par construction (des jetons tirés au hasard) — c'est le témoin qui montre que la coupe ne casse pas le modèle en général. Le nombre de têtes affiché est celui réellement coupé, lu dans le fichier du run.

Le second témoin : la 1ʳᵉ copie

Chaque séquence de l'épreuve est faite de jetons tirés au hasard, puis répétée. La 1ʳᵉ moitié est donc imprévisible par construction : aucune tête d'induction ne peut y aider, il n'y a rien à recopier. Ce que le modèle y perd ne doit pas bouger quand on coupe.

1ʳᵉ copie — modèle intact

25,62

rien à recopier, le modèle devine

1ʳᵉ copie — 5 têtes coupées

25,66

le témoin n'a pas bougé

2ᵉ copie — 5 têtes coupées

13,77

contre 5,81 intact

C'est la partie rassurante. Si couper ces 5 têtes avait aussi dégradé la 1ʳᵉ copie, cela voudrait dire qu'on a abîmé le modèle en général — ses statistiques de vocabulaire, son fonctionnement de base — et le chiffre de la 2ᵉ copie ne dirait plus rien sur la copie. Le témoin reste plat pendant que la 2ᵉ copie s'effondre. On a retiré une capacité précise, pas de la puissance de calcul.

Ce que le contrôle ne prouve pas encore

Aux petits nombres, la deuxième colonne fait mal elle aussi. Contre 5,81 intact : à 1 tête, la coupe visée donne 6,19 et le tirage au hasard 6,01 ; à 2 têtes, 7,21 contre 6,57 ; à 3 têtes, 9,28 contre 7,49. Sur ces trois lignes, le tirage au hasard reproduit à peu près la moitié du dégât visé.

L'explication tient au modèle lui-même : l'induction n'est pas portée par une tête unique. Le run garde les 8 premières du classement d'induction — un nombre fixé d'avance dans le code, pas un seuil. Il se trouve que la coupure tombe à un endroit où le classement décroche de toute façon : la 8ᵉ est à 0,582, la 9ᵉ à 0,514. Couper les 3 premières en laisse donc 5 en place. Un tirage de 3 têtes parmi les 141 restantes peut donc tomber sur l'une de ces 5.

Le contrôle ne devient net qu'aux grosses coupes : 13,77 contre 6,38 à 5 têtes, 17,77 contre 6,71 sur la dernière ligne. À 5 têtes coupées il en reste 3 dans le classement ; sur la dernière ligne il n'en reste aucune, pendant que les tirages continuent de piocher dans une majorité de têtes sans rapport. Les lignes 1, 2 et 3 restent affichées telles quelles : elles sont bruyantes, et les cacher rendrait le résultat plus net qu'il ne l'est.

Un défaut d'étiquette dans cette dernière ligne, puisqu'il faut le dire. Le tableau l'annonce à 10 têtes coupées. Le classement d'induction n'en gardait que 8 : la coupe visée porte en fait sur ces 8 têtes (17,77), pendant que le tirage au hasard en coupe bien 10 (6,71). La comparaison joue donc contre le côté visé, qui coupe moins que son témoin, et l'écart tient quand même. La ligne à 5 têtes, elle, compare bien 5 contre 5.

13. La tête notée 0,000 qui décide de tout

La question qui a déclenché ce run : « les quatre classements ne désignent pas les mêmes têtes — alors laquelle choisir ? » La réponse tenait dans une hypothèse : aucune, parce qu'elles ne sont pas en concurrence. La tête « jeton précédent » de la couche 3 marquerait, pour chaque position, quel jeton la précédait ; les têtes d'induction des couches 4 à 8 se serviraient de cette marque. Une chaîne, pas un concours.

Jolie histoire, donc suspecte. Elle fait une prédiction risquée : couper couche 3 tête 0 — dont la note d'induction vaut exactement 0,000, dernière ex æquo des 144 — devrait faire s'effondrer l'induction des autres têtes. Rien dans le classement ne le laisse prévoir. C'est le genre de prédiction qui peut échouer bruyamment.

Ce qui arrive quand on coupe la tête (3, 0)

Tête d'induction	Note, modèle intact	Après la coupe de (3, 0)	Témoin : 1 tête au hasard
couche 6, tête 6	0,859	0,171	0,854
couche 4, tête 8	0,851	0,039	0,851
couche 4, tête 6	0,822	0,010	0,823
couche 4, tête 11	0,812	0,008	0,812
couche 8, tête 2	0,765	0,379	0,757
couche 4, tête 10	0,722	0,003	0,724
couche 8, tête 10	0,674	0,470	0,665
couche 5, tête 6	0,577	0,151	0,577

Quatre têtes tombent sous 0,04 — elles ne recopient plus du tout. Le témoin, lui, ne bouge pas : couper une autre tête au hasard (8 tirages) déplace les notes de 0,009 au maximum. Sur l'ensemble des 144, 29 têtes notées au-dessus de 0,10 perdent plus de la moitié de leur note.

Et le comportement suit

On coupe	Perte, 2ᵉ copie	Écart	1ʳᵉ copie (témoin)
rien (modèle intact)	9,21	—	29,90
1 tête au hasard, 8 tirages	9,19	−0,02	29,95
la meilleure tête d'induction (6, 6), note 0,859	9,43	+0,22	29,88
la tête « jeton précédent » (3, 0), note d'induction 0,000	19,17	+9,96	29,24

Lis les deux dernières lignes ensemble. La tête la mieux notée en induction, coupée seule, coûte +0,22. La tête notée zéro en induction coûte +9,96 — quarante-cinq fois plus.

Ma propre note se trompait de cible. Elle disait de la tête (3, 0) : « ne participe pas à la copie ». C'est faux, et c'est même l'inverse : sans elle, personne ne copie. La note ne mesurait pas la participation, elle mesurait une façon précise de participer — celle du dernier maillon.

La raison est simple une fois vue : l'induction est portée par huit têtes, donc en couper une laisse les sept autres travailler. Le marquage du jeton précédent, lui, est porté par une seule tête très en avance sur les autres (0,857 contre 0,555). C'est un goulot d'étranglement — et un goulot ne se voit pas dans un classement qui note les sorties.

Ce que ça change pour toute cette page. Un classement dit qui fait quoi, pas qui est nécessaire. Les deux questions sont différentes, et seule la seconde se répond en coupant. Sans le run-060, la section 9 aurait laissé croire que « les têtes d'induction sont les têtes importantes ». Elles sont les têtes visibles.

Les chiffres de cette section ne se comparent pas à ceux de la section 9 : ce sont d'autres séquences (24 au lieu de 32, tirées avec d'autres graines), d'où une perte intacte de 9,21 au lieu de 5,81. Chaque run porte son propre modèle intact comme point de référence — c'est la seule comparaison qui ait un sens. Tout est dans circuit060.json.

14. « Quelle tête a prédit ce mot ? »

La question vient naturellement après tout ce qui précède, et la réponse est on peut classer, on ne peut pas attribuer. Voici pourquoi, mesuré.

Comment on coupe une tête, exactement

À chaque jeton, dans une couche, les 12 têtes travaillent chacune dans son coin, sans se voir. Chacune produit 64 nombres. Les 12 résultats sont simplement collés bout à bout — 768 nombres — et ce collage traverse la matrice dense avant d'être rendu au flux principal du modèle.

Couper la tête 6, c'est mettre à zéro ses 64 nombres dans ce collage, juste avant la recombinaison :

x[..., 6*64 : 7*64] = 0.0

La tête calcule toujours et répartit toujours ses pourcentages d'attention : simplement, sa voix vaut zéro dans la suite. Aucun poids n'est modifié — c'est un crochet posé le temps d'une mesure et retiré juste après.

Contrôle. Le run vérifie que couper par ce crochet donne exactement le même résultat que mettre à zéro les 64 colonnes correspondantes de dense.weight : écart nul sur les 50 304 logits, et modèle restauré à l'identique après la mesure. Ce contrôle était faux dans la première version du run — voir plus bas.

144 coupes, une par tête, pour une seule prédiction

Sur chaque phrase : on note la probabilité du jeton attendu, on coupe la tête n° 1, on remesure, on la remet — et on recommence 144 fois. 580 passages avant en tout.

Phrase	Prédiction	Tête la plus coûteuse	Chute	Têtes sans effet	Les 8 premières coupées ensemble
La répétition	`mat` 32,0 %	couche 10, tête 8	−17,9 pts	43 / 144	1,9 %
Deux prénoms	`Mary` 28,4 %	couche 5, tête 3	−18,1 pts	41 / 144	0,6 %
Du français	`tap` 94,7 %	couche 3, tête 0	−86,7 pts	81 / 144	5,0 %
Du bruit pur	`itarian` 83,3 %	couche 3, tête 0	−83,3 pts	64 / 144	0,0 %

Les responsables changent complètement selon la phrase. Les deux phrases qui reposent sur la recopie sont écrasées par la tête (3, 0) — celle de la section 10, notée 0,000 en induction. Les deux phrases d'anglais ordinaire ne la citent même pas. Il n'y a pas de « tête importante » dans l'absolu : ça dépend de ce qu'on demande au modèle.

Et les effets ne s'additionnent pas

C'est le résultat qui tue l'idée d'attribuer un mot à une tête. On coupe les deux têtes les plus coûteuses séparément, on additionne leurs dégâts, puis on les coupe ensemble :

Phrase	chute(A) + chute(B)	chute(A et B ensemble)
La répétition	28,8 pts	23,5
Deux prénoms	35,6 pts	21,8
Du français	139,6 pts	87,2
Du bruit pur	165,9 pts	83,3

Regarde la dernière ligne. Sur « Du bruit pur », deux têtes détruisent chacune la prédiction à elle seule — −83,3 et −82,6 points, sur 83,3 possibles. Les couper ensemble ne fait pas plus de dégât : il n'y a plus rien à détruire.

On ne peut donc pas écrire « celle-ci compte pour 50 %, celle-là pour 50 % ». La responsabilité ne se découpe pas en parts. Deux têtes peuvent être chacune indispensable sans qu'aucune ne soit « la » responsable.

Ce qu'on peut affirmer, et rien de plus : sans cette tête-là, cette prédiction-ci tombe de tant. C'est une mesure de nécessité, pas de production. Personne ne « fabrique » le mot mat ; il tient tant qu'un chemin suffisant reste debout.

Le contrôle raté, puisqu'il faut le dire. La première version de ce run vérifiait bien que les deux façons de couper coïncident — mais en comparant la probabilité du jeton n° 0, qui vaut ~0 dans les deux cas. L'égalité était vraie et ne prouvait rien. Un contrôle qui passe toujours n'est pas un contrôle. Corrigé : on compare maintenant les 50 304 logits entiers, et on vérifie que le modèle est restauré. Les résultats, eux, n'ont pas bougé d'un chiffre — le run est déterministe.

Tout est dans attribution061.json : les 144 chutes, pour les 4 phrases.

15. Le run a d'abord rendu un fichier entier de NaN

La première version de ce run s'est terminée « avec succès » et a écrit ses 234 049 octets. Tout y était NaN : la perte, les cinq ablations, les prédictions. La cause : le config.json de Pythia annonce float16, transformers a donc chargé le modèle en demi-précision, et sur CPU les logits débordent silencieusement.

Le piège est là : les notes des 144 têtes, elles, étaient sorties plausibles — 0,846 d'induction pour la meilleure. Le softmax de l'attention renormalise et efface le débordement. Le run avait l'air d'avoir marché, la moitié visible du résultat était juste, et le tableau des meilleures têtes aurait été publiable tel quel.

La correction n'est pas .float() — ça, c'est le bug. La correction est le garde-fou : le run affiche maintenant sa précision au chargement, fait un passage avant de contrôle, et refuse d'écrire le JSON si un seul nombre est NaN. Même leçon qu'au chapitre du harnais : un run qui finit n'est pas un run qui a marché.

Les chiffres des deux versions diffèrent, d'ailleurs : la meilleure tête d'induction était couche 4 tête 8 (0,846) en float16, elle est couche 6 tête 6 (0,850) en float32. Assez proche pour rassurer — assez différent pour que rien de la v1 ne soit publié ici.

16. Ce que cette page ne montre pas

144 têtes, ce n'est pas 160 millions de poids. On regarde ici les sorties de l'attention, pas les poids eux-mêmes. Les matrices affichées sont calculées pour une phrase donnée ; change la phrase, elles changent. Les poids, eux, ne bougent pas — et personne ne sait les lire directement.

L'attention n'est qu'une partie du modèle. Entre deux blocs d'attention il y a un réseau dense (ffn) qui porte la majorité des paramètres et dont on ne montre rien. Beaucoup de ce que « sait » un modèle est rangé là, pas dans l'attention.

Une tête nette n'est pas une explication. Voir une tête relier deux jetons dit où l'information circule, pas pourquoi la sortie est ce qu'elle est. C'est pour ça que la section 12 existe : tant qu'on n'a pas coupé et comparé à un tirage au hasard, on n'a qu'une jolie image.

C'est un petit modèle. 160 millions de poids, 12 couches. Les mêmes mesures sur un modèle de 70 milliards donneraient des cartes bien plus embrouillées — c'est justement pour ça que la recherche en interprétabilité travaille sur de petits modèles entièrement ouverts.

17. Les mots de cette page

Un modèle de langue ne lit pas des mots : il lit un texte découpé en jetons, des morceaux de longueur variable. Il les fait passer par une pile d'étages, appelés couches. Dans chaque étage, plusieurs têtes calculent en parallèle, chacune sans voir ce que font les autres. Une tête ne fait qu'une chose : répartir 100 % sur les jetons déjà lus.

Le mot	Ce qu'il désigne
jeton	Un morceau de texte, pas un mot : `tapis` se découpe en `tap` + `is`, `dort` en `d` + `ort`. Certains morceaux ne forment aucun mot à eux seuls, comme `itarian`. La phrase française de cette page, « Le chat dort sur le tapis . Le chat dort sur le », fait 15 jetons.
couche	Un étage du modèle. Pythia 160M en a 12, numérotées de 0 (celle qui voit le texte en premier) à 11.
tête d'attention	Une unité de calcul parmi douze à l'intérieur d'un étage. 12 têtes par couche, 144 en tout, chacune manipulant 64 nombres par jeton. Aucune n'a de rôle inscrit quelque part : son comportement ne se connaît qu'en le mesurant.
attention (le pourcentage)	La part qu'une tête accorde à un jeton déjà lu. Pour un jeton donné, ses parts font toujours 100 % au total ; la façon dont elles se répartissent est tout ce qu'on observe. Exemple réel, sur la séquence « Du bruit pur » : la tête 6 de la couche 6 place 89,0 % de la part du jeton n° 12 sur le jeton n° 1.
carte de chaleur	Ces pourcentages dessinés : une ligne par jeton lu, une colonne par jeton regardé, case d'autant plus vive que la part est grande. 24 lignes sur 24 colonnes pour « Du bruit pur ». Rien au-dessus de la diagonale : aucun jeton ne reçoit de part sur ce qui vient après lui.
note	Un nombre entre 0 et 1 : la moyenne de la part qu'une tête place sur une case précise de sa carte. La couche 6, tête 6 a une note d'induction de 0,850, c'est-à-dire 85,0 % de part en moyenne sur cette case, sur 40 séquences. Les 144 têtes reçoivent les mêmes quatre notes, calculées pareil pour toutes.
induction	La case qui compte quand un texte se répète : le jeton courant est déjà passé plus tôt, et la part est placée sur celui qui l'avait suivi cette fois-là. La note d'induction mesure cette seule case. Sur « Du bruit pur », après les 24 jetons, le modèle donne 83,3 % au jeton qui vient effectivement ensuite dans la répétition.
puits d'attention	Une tête qui dépose presque toute sa part sur le jeton n° 0, quel que soit le texte. Sur 8 phrases anglaises ordinaires, la couche 9, tête 5 y met 100 % en moyenne (note 1,000). Le run mesure ce comportement ; il ne dit pas pourquoi il existe.
précédent et soi	Les deux autres notes. « Précédent » : la part placée sur le jeton juste avant. « Soi » : la part qu'un jeton garde sur lui-même. La plus haute note « précédent » est celle de la couche 3, tête 0 : 0,857.
perte	Un nombre calculé jeton par jeton. Il vaut zéro quand le modèle donnait 100 % au jeton qui arrive vraiment, et il monte d'autant plus haut que la probabilité donnée était petite. Sur 32 séquences aléatoires répétées, modèle intact : 25,62 sur la 1re copie, 5,81 sur la 2e — même contenu, mais la 2e fois il est déjà passé.
nat	L'unité de la perte, comptée par jeton. Un nat seul ne veut rien dire ; seuls les écarts entre deux chiffres portant sur la même épreuve se lisent, comme 5,81 contre 13,77.
contexte	Le nombre de jetons que le modèle peut lire d'un seul tenant. Pythia : 2 048. Mes modèles maison : 128 et 256. Il n'ajoute aucun poids au modèle, mais c'est lui qui décide de la mémoire et du calcul à l'usage.
cache KV	La clé et la valeur de chaque jeton déjà lu, gardées de côté pour ne pas les recalculer. Sa taille par jeton vaut `2 × couches × têtes de clés × taille de tête × octets` : 12 288 octets chez Qwen 0.5B, 36 864 chez Pythia — trois fois plus pour un modèle trois fois plus petit.
rotary (RoPE), base de rotary	Rotary, ou RoPE, est la méthode qui code la position d'un jeton en faisant tourner les nombres de la tranche d'une tête, deux par deux, d'un angle proportionnel à la position — aucune table, aucun poids appris. La base est le nombre qui règle la vitesse de ces rotations. 10 000 chez Pythia, 1 000 000 chez Qwen. Plus il est grand, plus le modèle distingue des positions lointaines — et il ne coûte aucun poids.
bloc dense (FFN)	Le calcul placé après l'attention dans chaque couche, qui retravaille chaque jeton séparément sans jamais les comparer. C'est le plus gros bloc du modèle : 34,9 % des poids de Pythia, contre 17,5 % pour toute l'attention.
ablation	Couper une tête : sa contribution est remplacée par des zéros avant que l'étage ne rassemble ses douze têtes. Elle calcule encore, mais elle ne pèse plus sur la suite. Couper les 5 meilleures têtes d'induction fait passer la perte de la 2e copie de 5,81 à 13,77 ; couper 5 têtes tirées au hasard la laisse à 6,38.

Les quatre notes — puits, précédent, soi, induction — sont calculées de la même façon pour les 144 têtes, sans en choisir aucune à la main ; « Comment on a trouvé ces têtes » donne le calcul. Une même tête peut être haute sur deux notes à la fois : la couche 4, tête 6 note 0,987 en puits et 0,815 en induction.

Projet IA · ia.vmailx.com · runs 059 à 062 · Kaggle, 0 € · modèle EleutherAI/pythia-160m-deduped · toutes les valeurs de cette page viennent de attention059.json (run-059) et circuit060.json (run-060) et attribution061.json (run-061) et tetes062.json (run-062) et contexte.json (relevé des modèles présents ici, par training/local/contexte_params.py) et tetesKV063.json (run-063), produits par les kernels training/kaggle/run-059…, run-060… et run-061-attribution/ · EXPERIENCES.md