DeltaNet : corriger la mémoire

Remplacer l’écriture additive aveugle par lire, comparer, corriger.

Applied AI · advanced · Session 14

Carte du mécanisme

TOKEN t :  k=[1,0]   v=[9,9]        état hérité S = [[2,3],
                                                       [5,1]]
      │
      ▼
┌──────────────┐   ① LIRE      v̂ = Sᵀk = [2,3]
│   lecture    │───────────────────────────────┐
└──────────────┘                               ▼
                                 ┌───────────────────────┐
                                 │ ② COMPARER            │
                                 │   e = v − v̂ = [7,6]   │
                                 └───────────────────────┘
                                               │
      ┌────────────────────────────────────────┘
      ▼
┌──────────────────────────────────────────────┐
│ ③ CORRIGER    S ← S + β k eᵀ     (β = 1)     │
└──────────────────────────────────────────────┘
      │
      ▼
   S = [[9,9],      lecture q=[1,0] → [9,9]  ✅ remplacé
        [5,1]]      ligne 2 jamais touchée   ✅ préservée

Le problème — Limite de l’addition

Session 13, dernière écriture : k=[1,0] resservi, lecture [11,12] — ni [2,3] ni [9,9]. Une mémoire additive ne sait que renforcer : mettre à jour une association (« le prix est passé à 9 ») produit un mélange des deux versions au lieu d’un remplacement.

L’idée — Limite de l’addition

Le diagnostic est structurel : S ← S + k vᵀ ne consulte jamais S. L’écriture est décidée sans savoir ce que la mémoire contient déjà — répéter une information l’amplifie, la corriger l’entremêle.

Pourquoi / à quel prix — Limite de l’addition

Nommer la cause — l’écriture aveugle — désigne le remède : lire avant d’écrire. Le prix de l’addition reste sa simplicité : une seule opération, aucun état consulté ; tout ce que la suite ajoute se paiera en calcul par token.

Contrôle : La séance 13 finissait sur S ligne 1 = [11,12] après avoir réécrit k=[1,0] avec v=[9,9]. Quelle information exacte a été perdue là, et pourquoi la simple addition ne peut jamais la récupérer ?

Support visuel — Limite de l’addition

addition aveugle (s.13)            règle delta (s.14)
k=[1,0] réécrit avec [9,9]         même token
        │                                  │
        ▼                                  ▼
ligne 1 : [2,3] + [9,9]            lit v̂ = [2,3], e = [7,6]
        = [11,12]   ❌             écrit k eᵀ → [9,9]   ✅

mélange des deux versions          remplacement propre

Le problème — Lire avant d’écrire

Pour corriger sans mélanger, il faut savoir ce que la mémoire répondrait AVANT d’écrire. Sinon, impossible de distinguer « information nouvelle » (écrire fort) d’« information déjà connue » (ne rien faire).

L’idée — Lire avant d’écrire

La mémoire prédit d’abord : v̂ = Sᵀk. Sur S = [[2,3],[5,1]] avec k=[1,0], v̂ = [2,3] — exactement ce qu’une requête alignée lirait. L’écriture devient conditionnelle à l’état, plus seulement à l’entrée.

v̂=Sᵀk

Pourquoi / à quel prix — Lire avant d’écrire

Cette lecture est ce qui rend la correction possible — et c’est une multiplication de plus par token, avant même d’écrire. Le prix : v̂ n’est fiable que si k s’aligne sur ce qui fut écrit ; une clé mal placée fait « corriger » une prédiction qui n’existait pas.

Contrôle : Sur S = [[2,3],[5,1]], calculez v̂ = Sᵀk pour k=[0,1] puis pour k=[0,5;0,5]. Dans quel cas la lecture ne correspond à aucune valeur écrite, et qu’est-ce que cela dit du choix des clés ?

Le problème — Erreur locale

La lecture donne v̂ = [2,3], la cible est v = [9,9]. Écrire v en entier re-superposerait tout — retour au problème de la session 13. Que faut-il écrire, exactement, pour passer de l’un à l’autre ?

L’idée — Erreur locale

Seulement la différence : e = v − v̂ = [7,6]. Elle contient à la fois ce qui manque (composantes positives) et ce qui doit s’effacer (négatives). Et si v̂ = v, alors e = [0,0] : le token redondant n’écrit rien.

e=v−v̂

Pourquoi / à quel prix — Erreur locale

L’erreur nulle est le premier mécanisme d’économie : pas de réécriture inutile, pas de dérive sur les répétitions. Le prix : e est local à la clé courante — il corrige ce que k lit, pas la mémoire entière ; une erreur vue d’une mauvaise clé reste invisible.

Contrôle : Un token arrive avec v = [9,9] alors que la mémoire prédit déjà v̂ = [9,9]. Écrivez e, écrivez k eᵀ, et dites précisément ce que la mémoire fait à ce pas.

Le problème — Mise à jour delta

e dit quoi corriger ; reste à l’appliquer au bon endroit et à la bonne force. Une correction diffusée partout dégraderait les autres lignes ; une correction trop forte dépasse la cible — le cas D lit [−5,−4].

L’idée — Mise à jour delta

S ← S + β k eᵀ : k localise (ligne 1 seulement), e porte le contenu, β dose. Avec β=1 et ‖k‖=1 : remplacement exact, [2,3] → [9,9], ligne 2 intacte. Avec β=0,5 : à mi-chemin, [5,5 ; 6].

S←S+βk(v−Sᵀk)ᵀ

Pourquoi / à quel prix — Mise à jour delta

Après un pas, il reste (1 − β·‖k‖²) de l’erreur : le remplacement exact exige β=1 ET une clé normalisée. Le prix : le calibrage — β mal réglé ou ‖k‖ ≠ 1 fait dépasser ou osciller, comme le taux d’apprentissage de la session débutant… au rythme d’un token.

Contrôle : Avec e = [7,6] et k = [1,0], donnez S après β=1 puis après β=0,5. Formulez ensuite la règle générale : quelle fraction de l’erreur reste après une mise à jour de force β ?

Support visuel — Mise à jour delta

S ← S + β · k · eᵀ
         │    │    │
         │    │    └── QUOI corriger : e = v − v̂ = [7,6]
         │    └─────── OÙ écrire : k = [1,0] → ligne 1 seule
         └──────────── COMBIEN : β = 1 → tout ; β = 0,5 → moitié

reste après un pas : (1 − β·‖k‖²) × e

Le problème — Poids rapides

S change à chaque token pendant l’inférence — alors qu’a-t-on « appris » à l’entraînement ? Si tout bouge tout le temps, la distinction entraînement/conversation de la session débutant semble s’effondrer.

L’idée — Poids rapides

Deux vitesses coexistent : S est un poids RAPIDE, réécrit token par token et jeté en fin de séquence ; les matrices qui produisent k, v, β sont des paramètres LENTS, figés à l’inférence. L’entraînement apprend à piloter la mémoire, pas son contenu.

Pourquoi / à quel prix — Poids rapides

Cette séparation réconcilie les deux régimes : le contexte s’écrit dans S sans toucher aux paramètres. Le prix : le débogage change de nature — un comportement étrange peut venir de l’état (cette séquence-ci) ou des paramètres (l’entraînement), et les remèdes n’ont rien en commun.

Contrôle : Pendant l’inférence, S passe de [[2,3],[5,1]] à [[9,9],[5,1]] entre deux tokens. Les matrices qui produisent k, v et β ont-elles bougé ? Classez chaque objet en « rapide » ou « lent » et justifiez.

Support visuel — Poids rapides

                PARAMÈTRES (lents)      ÉTAT (rapide)
                W_k, W_v, W_β           S
changent…       à l’entraînement        à chaque token
à l’inférence   figés                   réécrit sans cesse
portée          tous les contextes      cette séquence-ci
analogie        la grammaire apprise    la conversation en cours

Le problème — Orientations

Vous ouvrez deux implémentations : l’une écrit S + βk eᵀ et lit qᵀS ; l’autre écrit S + βe kᵀ et lit Sq. Les formules diffèrent — l’une des deux est-elle fausse ?

L’idée — Orientations

Ni l’une ni l’autre : toute la présentation se transpose (lignes ↔ colonnes) sans changer le mécanisme. Ce qui est immuable : lire, comparer, corriger — et les FORMES déclarées : k(d_k), e(d_v), S(d_k×d_v) dans une convention, transposées dans l’autre.

Pourquoi / à quel prix — Orientations

Savoir cela évite de « corriger » un code juste. Le prix : la liberté de convention est un piège d’équipe — mélanger les deux dans un même fichier produit des bugs silencieux. D’où la règle de séance : déclarer les formes à côté de chaque formule.

Contrôle : Une bibliothèque écrit S ← S + βe kᵀ au lieu de S ← S + βk eᵀ, et lit y = Sq. Le mécanisme est-il différent, ou est-ce la même chose transposée ? Quelle forme déclarer pour trancher ?

Cas guidé — trace complète

Si S lit [0,6;0,2] pour une cible [1;0], l’erreur [0,4;−0,2] pilote seulement la correction manquante, contrairement à une addition complète de la cible.

État hérité de la séance 13 (deux écritures orthogonales) :
  S = [[2,3],      ligne 1 ↔ clé [1,0]
       [5,1]]      ligne 2 ↔ clé [0,1]

── Cas A : réécrire la clé [1,0] avec v=[9,9], β=1 ──────────────
  v̂ = Sᵀk = 1·[2,3] + 0·[5,1] = [2,3]
  e  = v − v̂ = [9−2, 9−3] = [7,6]
  k eᵀ = [[7,6],[0,0]]
  S  = [[2+7, 3+6],[5,1]] = [[9,9],[5,1]]
  lecture q=[1,0] → [9,9]   ✅ ancienne valeur écrasée, pas empilée
  lecture q=[0,1] → [5,1]   ✅ l’autre association est intacte
  (rappel séance 13, addition brute : S = [[11,12],[5,1]] → ❌ [11,12])

── Cas B : token redondant, v = [9,9] déjà en mémoire ────────────
  v̂ = [9,9] → e = [0,0] → k eᵀ = 0 → S inchangée   ✅ pas de réécriture

── Cas C : β partiel, β=0,5 sur l’état de départ ─────────────────
  S = [[2+0,5·7 ; 3+0,5·6],[5,1]] = [[5,5 ; 6],[5,1]]
  lecture q=[1,0] → [5,5 ; 6]   ❌ ni [2,3] ni [9,9] : à mi-chemin

── Cas D : clé non normalisée k=[1,1], cible v=[1,0], β=1 ────────
  v̂ = Sᵀk = [2,3]+[5,1] = [7,4]   ;  e = [−6,−4]
  S = [[2−6, 3−4],[5−6, 1−4]] = [[−4,−1],[−1,−3]]
  lecture q=[1,1] → [−5,−4]   ❌ dépassement : ‖k‖² = 2, pas 1
  correction : le β qui annule l’erreur vaut 1/‖k‖² = 0,5

CONTRÔLE DE FORME : k(2×1) eᵀ(1×2) → correction 2×2 = forme de S.
β est un SCALAIRE ; si β sortait en vecteur (2), le produit βk est
déjà autre chose qu’un facteur d’intensité — l’implémentation ment.

Écriture additive contre règle delta, sur le même flux de tokens

Situation Addition S ← S + k vᵀ Delta S ← S + βk(v−Sᵀk)ᵀ
Clé [1,0] réécrite avec [9,9] S ligne 1 = [11,12] (superposition) S ligne 1 = [9,9] (remplacement)
Token redondant (v déjà stocké) écrit quand même, double la trace e=[0,0] : aucune écriture
Ce que consulte l’écriture rien : k et v seulement l’état courant S, via v̂=Sᵀk
Point de rupture saturation par accumulation clé non normalisée ou β mal calibré

Laboratoire causal

Prédire → modifier une variable → exécuter → expliquer l’écart

/interactives/curriculum/linear-delta-memory.html?lang=fr

Erreurs fréquentes

« La règle delta efface l’ancienne valeur et écrit la nouvelle. »

Elle n’efface rien : elle ajoute βk eᵀ. Le remplacement exact du cas A n’arrive que parce que β=1 et ‖k‖²=1. Le cas D, avec k=[1,1], dépasse la cible et lit [−5,−4] — la même formule, sans normalisation.

« β est un taux d’apprentissage, donc un hyperparamètre qu’on règle une fois. »

β est produit par le réseau à chaque token, comme k et v : c’est un poids rapide, pas un réglage. Il peut valoir 1 sur un token qui corrige et ~0 sur le token redondant du cas B, dans la même séquence.

Frontière, preuve et sources

La règle delta réduit certaines interférences ; elle ne crée pas une capacité illimitée et sa stabilité dépend des clés, portes et normalisations.

Statut de preuve : Mécanismes établis ; les simplifications numériques sont pédagogiques.

  • Dossier de cours bilingue fourni par le propriétaire, chapitre 9.
  • Schlag, Irie & Schmidhuber, “Linear Transformers Are Secretly Fast Weight Programmers”, ICML (2021).
  • Yang et al., “Parallelizing Linear Transformers with the Delta Rule over Sequence Length” (DeltaNet), NeurIPS (2024).
  • Dossier source fourni par le propriétaire; les détails sur des produits nommés restent attribués à cette source jusqu’à vérification primaire.

Défi de transfert

Rejouez le cas D avec la clé normalisée k = [1/√2 ; 1/√2] ≈ [0,707 ; 0,707], cible v = [1,0], β = 1, sur S = [[2,3],[5,1]].

  1. Prédisez : la lecture q = k après mise à jour atteindra-t-elle exactement [1,0] ?
  2. Calculez v̂, e, puis la lecture après correction.
  3. Concluez : que garantit ‖k‖ = 1, et que ne garantit-il PAS pour les autres clés ?

Synthèse et ticket de sortie

  • Limite de l’addition
  • Lire avant d’écrire
  • Erreur locale
  • Mise à jour delta
  • Poids rapides
  • Orientations

Ticket : mécanisme · trace · observation · frontière · preuve · prochaine expérience

Notes formateur: Poser le problème avant de nommer le mécanisme. Recueillir une prédiction initiale et la conserver pour le ticket de sortie.

Notes formateur: Faire relier chaque étape à la suivante par un verbe causal. Signaler toute flèche purement décorative.

Notes formateur: Réafficher le S = [[11,12],[5,1]] de la session 13 et faire voter : « bug d’implémentation ou propriété mathématique ? ». Le vote « bug » est souvent majoritaire — parfait : le beat montre que l’addition a fait exactement ce qu’on lui a demandé.

Notes formateur: Ouvrir en réaffichant le S = [[11,12],[5,1]] de la séance précédente et demander « qu’est-ce qui aurait dû se passer ? » avant d’introduire la moindre formule. La règle delta doit arriver comme une réponse à un problème déjà ressenti.

Notes formateur: Réponse : l’attribution est perdue — rien n’indique que [11,12] = [2,3] + [9,9] plutôt qu’une autre décomposition ; une somme a une infinité d’antécédents, l’addition est donc irréversible. Erreur attendue : « on soustrait l’ancienne valeur » — encore faudrait-il la connaître.

Notes formateur: Faire lire les deux colonnes de droite à gauche : le même token produit deux mémoires différentes. La seule différence de code est la lecture préalable — la faire souligner.

Notes formateur: Demander : « avant de corriger quelqu’un, que faut-il savoir ? » — ce qu’il croit déjà. L’analogie pédagogique porte le beat : une mémoire se corrige comme un apprenant, en partant de sa réponse actuelle.

Notes formateur: Faire calculer v̂ = Sᵀk à la main pour deux clés, dont une non alignée. Ne pas commenter le second résultat : laisser le groupe constater que la lecture ne correspond à rien de stocké.

Notes formateur: Réponse : k=[0,1] lit [5,1], une valeur réellement stockée ; k=[0,5;0,5] lit 0,5·[2,3] + 0,5·[5,1] = [3,5 ; 2] — aucune valeur écrite. Le choix des clés décide si « lire » signifie récupérer ou mélanger. Erreur attendue : renormaliser le mélange pour « retrouver » une valeur.

Notes formateur: Faire calculer e sur deux cas dégénérés d’abord : v̂ = v (rien à faire) et v̂ = 0 (tout à écrire). Les deux extrêmes rendent le cas général [7,6] immédiatement lisible.

Notes formateur: Insister sur le cas e=[0,0] par un vote à main levée : « la mémoire écrit-elle quelque chose ? » La moitié dira oui. C’est le moment où la différence avec l’addition devient viscérale.

Notes formateur: Réponse : e = [0,0], k eᵀ = [[0,0],[0,0]] — la mémoire ne fait RIEN, et c’est le comportement voulu sur un token redondant. Erreur attendue : « elle renforce l’association », le réflexe hérité de l’addition de la session 13.

Notes formateur: Annoncer « une seule formule, trois boutons » et faire identifier les rôles avant de donner la décomposition : qui localise ? qui porte le contenu ? qui dose ? Les trois réponses (k, e, β) structurent le beat.

Notes formateur: Faire prédire S pour β=0,5 avant de le calculer, puis demander la valeur de β qui annulerait l’erreur en un pas. Enchaîner immédiatement sur le cas D : la réponse « 1 » est fausse dès que ‖k‖≠1.

Notes formateur: Réponse : β=1 → ligne 1 = [9,9] ; β=0,5 → [5,5 ; 6]. Règle : il reste (1 − β·‖k‖²) de l’erreur — ici ‖k‖² = 1, donc (1 − β). Erreur attendue : généraliser (1 − β) à toute clé en oubliant ‖k‖² ; le cas D la démentira deux slides plus loin.

Notes formateur: Cacher les trois légendes et les faire retrouver. Puis tester la formule du reste sur le cas D : β = 1 mais ‖k‖² = 2 → reste (1 − 2) = −1 : le signe négatif EST le dépassement.

Notes formateur: Question éclair : « pendant que vous parlez à un assistant, qu’est-ce qui change dans la machine ? ». Recueillir les réponses en vrac, puis les ranger dans les deux colonnes du support visuel.

Notes formateur: Tracer deux colonnes au tableau, « change à chaque token » et « change à chaque pas de gradient », et faire ranger S, W_k, W_v, β, k. La confusion poids rapides / paramètres est ce qui bloque les séances 16 et 17.

Notes formateur: Réponse : non — W_k, W_v, W_β sont figées à l’inférence. Classement : S rapide ; k, v, β recalculés à chaque token à partir de paramètres lents ; W_* lentes. Erreur attendue : classer β en hyperparamètre — c’est l’erreur fréquente 2 du deck.

Notes formateur: Faire ranger dans le tableau les objets cités par la salle au début du beat, puis demander : « où vit une correction faite en chat ? ». Colonne de droite — c’est le rappel direct de la session débutant 11.

Notes formateur: Montrer les deux extraits de code côte à côte pendant 30 secondes et faire voter : « même mécanisme ou pas ? ». Noter le score du vote — on le comparera après le beat.

Notes formateur: Écrire volontairement la formule transposée au tableau et demander qui proteste. Conclure par une règle de séance : aucune formule n’est discutée sans que les formes soient écrites à côté.

Notes formateur: Réponse : même mécanisme transposé — déclarer la forme de S, (d_k×d_v) ou (d_v×d_k), tranche immédiatement ; vérifier ensuite que écriture ET lecture utilisent la même convention. Erreur attendue : déclarer le second code faux parce que « la formule du cours » est l’autre.

Notes formateur: Dérouler ligne par ligne. Une incohérence se localise à la première étape fautive, pas seulement sur la dernière ligne.

Notes formateur: Faire remplir la dernière ligne par les apprenants avant de la révéler : c’est le compromis qui décide en production.

Notes formateur: Conserver les valeurs initiales et finales. Interdire les changements simultanés qui rendent l’écart impossible à attribuer.

Notes formateur: Pour chaque affirmation, faire produire le contre-exemple minimal par le groupe avant de donner la correction.

Notes formateur: Séparer mécanisme vérifiable, choix d’implémentation rapporté et résultat expérimental. La précision de la preuve doit suivre celle de l’affirmation.

Notes formateur: Réponses : v̂ = 0,707·[7,4] ≈ [4,95 ; 2,83], e ≈ [−3,95 ; −2,83] ; comme β·‖k‖² = 1, la lecture q = k retombe exactement sur [1,0] — le dépassement du cas D disparaît. MAIS la correction s’écrit sur les DEUX lignes (k n’a aucun zéro) : les lectures q=[1,0] et q=[0,1] sont polluées. ‖k‖ = 1 garantit le remplacement exact sur CETTE clé ; l’isolation des autres vient de l’orthogonalité, pas de la norme. 10 minutes, binômes.

Notes formateur: Faire reconstruire la chaîne sans regarder les slides, puis remplir le ticket en six lignes maximum. Comparer à la prédiction initiale du premier slide et nommer ce qui a réellement changé.