L'attention linéaire et DeltaNet¶
Remplacer la relecture de tout l'historique par une mémoire de taille fixe — et comprendre ce qu'on y perd.
L'idée¶
L'attention classique, pour traiter le jeton \(t\), relit tous les jetons de \(1\) à \(t-1\). D'où le coût quadratique.
L'attention linéaire fait autre chose : elle maintient un état \(S\) de taille fixe, mis à jour à chaque jeton. Pour traiter le jeton \(t\), elle ne consulte que cet état.
Attention classique : jeton t → relit 1, 2, 3, …, t-1 coût O(t)
Attention linéaire : jeton t → consulte S, puis met S à jour coût O(1)
Sur toute une séquence de \(n\) jetons, on passe de \(O(n^2)\) à \(O(n)\). D'où le nom.
L'analogie qui marche
L'attention classique, c'est relire tout son carnet de notes à chaque nouvelle idée. L'attention linéaire, c'est tenir un résumé et le mettre à jour. Le résumé est plus rapide à consulter, mais il ne contient pas tout.
La forme mathématique¶
L'astuce est de retirer le softmax. Sans lui, l'attention devient :
| Symbole | Signification | Dimensions |
|---|---|---|
| \(\mathbf{q}_t, \mathbf{k}_t\) | requête et clé du jeton \(t\) | \(d_k\) |
| \(\mathbf{v}_t\) | valeur du jeton \(t\) | \(d_v\) |
| \(S_t\) | état récurrent après le jeton \(t\) | \(d_k \times d_v\) |
| \(\mathbf{o}_t\) | sortie pour le jeton \(t\) | \(d_v\) |
Lecture : \(S_t\) est une somme de produits externes \(\mathbf{k}\mathbf{v}^{\top}\). Chaque nouveau jeton y ajoute sa contribution. Interroger l'état avec \(\mathbf{q}_t\) revient à récupérer une combinaison des valeurs passées, pondérée par la ressemblance entre \(\mathbf{q}_t\) et les clés.
Le point crucial : \(S_t\) a la taille \(d_k \times d_v\), indépendamment de la longueur de la séquence. Un million de jetons ou mille, l'état pèse pareil.
Le problème : l'état sature¶
Une somme qui ne fait qu'ajouter finit par tout mélanger. Après cent mille jetons, \(S\) est une bouillie où plus rien n'est distinguable.
Il faut donc un mécanisme d'oubli. La première solution, dite attention linéaire gatée, multiplie l'état par un facteur de décroissance :
avec \(\alpha_t \in\, ]0,1[\) appris et dépendant du jeton. L'information ancienne s'estompe progressivement.
Cela marche, mais c'est grossier : on oublie tout un peu, au lieu d'oublier ce qui n'est plus utile.
La règle delta¶
DeltaNet apporte une idée plus fine, empruntée à une vieille règle d'apprentissage. Au lieu d'ajouter aveuglément, on écrase sélectivement ce que l'état contient déjà à propos de la clé courante :
| Symbole | Signification |
|---|---|
| \(I\) | matrice identité \(d_k \times d_k\) |
| \(\beta_t \in\, ]0,1[\) | taux d'écriture, appris, propre à chaque jeton |
| \(\mathbf{k}_t \mathbf{k}_t^{\top}\) | projecteur sur la direction de la clé courante |
Lecture intuitive, en deux temps :
- \(S_{t-1}(I - \beta_t \mathbf{k}_t\mathbf{k}_t^{\top})\) : on efface partiellement ce que l'état associait déjà à cette clé. Les autres directions sont intactes.
- \(+\, \beta_t \mathbf{k}_t \mathbf{v}_t^{\top}\) : on écrit la nouvelle association.
La différence en une phrase
L'attention linéaire gatée oublie tout un peu. La règle delta remplace précisément l'entrée concernée, comme une mise à jour dans un dictionnaire.
C'est ce qui permet à DeltaNet de bien réussir les tâches de rappel associatif — « quelle était la valeur associée à cette clé, 200 000 jetons plus tôt ? » — là où les attentions linéaires antérieures échouaient.
Gated DeltaNet combine les deux : un facteur de décroissance global \(\alpha_t\)
et la règle delta. C'est ce que Qwen3.8-Max utilise, sous le nom
linear_attention dans son fichier de configuration.
Ce qu'on perd¶
L'état \(S\) est de taille fixe. Il ne peut donc pas contenir plus qu'une quantité fixe d'information, quelle que soit la longueur du texte.
| Attention complète | Attention linéaire | |
|---|---|---|
| Coût de calcul | \(O(n^2)\) | \(O(n)\) |
| Mémoire par jeton | croît linéairement | constante |
| Rappel exact d'un détail lointain | fiable | dégradé |
| Copie littérale d'un long passage | fiable | difficile |
Le compromis est réel, pas cosmétique
Un modèle entièrement en attention linéaire échoue sur les tâches de récupération précise : retrouver un identifiant exact cité une seule fois dans un document de 300 pages, par exemple.
C'est pour cette raison qu'aucun modèle sérieux n'est purement linéaire.
D'où l'hybride¶
La solution retenue par Qwen3.8-Max — et avant lui par Qwen3-Next et Kimi K3 — est de mélanger :
couche 1 : attention linéaire (Gated DeltaNet)
couche 2 : attention linéaire
couche 3 : attention linéaire
couche 4 : ATTENTION COMPLÈTE ← ancrage
couche 5 : attention linéaire
…
Les couches linéaires font le gros du travail à coût faible. Les couches complètes, une sur quatre, fournissent les capacités de rappel exact.
Le fichier de configuration de Qwen3.8-Max l'exprime ainsi :
"full_attention_interval": 4,
"num_hidden_layers": 92
Soit 69 couches linéaires et 23 couches complètes. Le détail des conséquences chiffrées est en Architecture · Vue d'ensemble.
Les dimensions dans Qwen3.8-Max¶
"linear_num_value_heads": 128,
"linear_num_key_heads": 16,
"linear_key_head_dim": 128,
"linear_value_head_dim": 128,
"linear_conv_kernel_dim": 4
Traduction :
- 16 têtes de clé de dimension 128, soit un espace de clés de 2 048 dimensions ;
- 128 têtes de valeur de dimension 128, soit 16 384 dimensions de valeurs — huit têtes de valeur par tête de clé ;
- une convolution causale de rang 4 appliquée avant l'attention, qui donne au mécanisme une petite mémoire locale exacte sur les 4 derniers jetons.
La taille de l'état récurrent par couche :
En float32, cela fait 8 Mo par couche, soit environ 0,6 Go pour les 69 couches — et ce chiffre ne bouge pas que le contexte fasse mille jetons ou un million.
À retenir¶
Ce chapitre en cinq points
- L'attention linéaire remplace la relecture de l'historique par un état de taille fixe, ce qui ramène le coût de \(O(n^2)\) à \(O(n)\).
- Sans mécanisme d'oubli, cet état sature. La règle delta efface sélectivement l'ancienne association avant d'écrire la nouvelle.
- Gated DeltaNet combine décroissance globale et règle delta.
- Le prix à payer est une perte de rappel exact à longue distance.
- D'où l'architecture hybride : 69 couches linéaires, 23 complètes.
Chapitre suivant : Le Mixture-of-Experts — comment 2,4 billions de paramètres n'en coûtent que 95 milliards.