Gated DeltaNet et oubli sélectif

Ajouter décroissance et portes d’écriture à une mémoire correctible.

Applied AI · advanced · Session 16

Carte du mécanisme

état hérité   S_{t−1} = [[2 ; 3],
                            [5 ; 1]]
      │
      ▼
┌──────────────────────────┐   α_t = 0,8   ① DÉCROISSANCE
│  S′ = α_t · S_{t−1}      │   (porte, dépend du token)
└──────────────────────────┘
      │   S′ = [[1,6 ; 2,4],
      ▼         [4,0 ; 0,8]]
┌──────────────────────────┐   v̂ = S′ᵀk = [1,6 ; 2,4]
│  ② LIRE / COMPARER       │   e  = v − v̂ = [7,4 ; 6,6]
└──────────────────────────┘   (k=[1,0], v=[9,9])
      │
      ▼
┌──────────────────────────┐   β_t = 0,5   ③ PORTE D’ÉCRITURE
│  S_t = S′ + β_t k eᵀ     │   0 → ignorer, 1 → corriger à fond
└──────────────────────────┘
      │
      ▼   S_t = [[5,3 ; 5,7],
              [4,0 ; 0,8]]     demi-vie à α=0,8 ≈ 3,1 tokens
DEUX PORTES INDÉPENDANTES : α = ce que je garde, β = ce que j’inscris

Le problème — Pourquoi oublier

Un document change de sujet au token 500 ; la mémoire delta, elle, garde tout. Les associations de l’ancien sujet continuent de répondre aux requêtes du nouveau — la superposition de la session 13 revient, non par clés proches, mais par simple accumulation dans le temps.

L’idée — Pourquoi oublier

Renverser le réflexe : l’oubli est une fonction, pas une panne. Une mémoire de capacité fixe qui ne libère jamais rien finit par ne plus rien distinguer ; effacer l’obsolète est précisément ce qui garde le présent lisible.

Pourquoi / à quel prix — Pourquoi oublier

Oublier libère de la capacité et borne l’influence du passé. Le prix, évident mais réel : ce qui est décru est perdu — un fait posé au token 10 et utile au token 10 000 doit avoir été réécrit entre-temps, sinon il n’existe plus.

Contrôle : Un document change de sujet au token 500 mais la mémoire garde les associations des 500 premiers. Décrivez une erreur de génération concrète que cela produit, puis dites quel mécanisme de la séance la corrige.

Le problème — Porte de décroissance

D’accord pour oublier — mais à quelle vitesse ? Un taux figé serait faux partout : un dialogue veut retenir 50 tokens, un contrat 5 000. Il faut un oubli piloté par le contenu, pas par une constante globale.

L’idée — Porte de décroissance

Une porte α_t ∈ [0,1], produite à chaque token, multiplie l’état avant l’écriture : S′ = α_t·S_{t−1}. À 0,8, une trace suit 1 → 0,8 → 0,64, et sa demi-vie vaut ln(0,5)/ln(0,8) ≈ 3,1 tokens. Le modèle apprend quand serrer ou ouvrir la porte.

S_t=α_t S_{t−1}+update_t

Pourquoi / à quel prix — Porte de décroissance

L’oubli devient mesurable — une demi-vie — et contextuel. Le prix : la décroissance est globale. La ligne 2 de la trace, jamais réécrite, décroît quand même ; ce qui n’est pas réécrit régulièrement s’évapore, pertinent ou non.

Contrôle : Avec α = 0,8, une trace vaut 0,64 après deux pas. Combien de tokens pour qu’elle passe sous 0,1, et comment retrouvez-vous la demi-vie 3,1 à partir de α seul ?

Support visuel — Porte de décroissance

trace d’une écriture de valeur 1, sans réécriture (α = 0,8)

1,00 ●
0,80 │  ●
0,64 │     ●
0,51 │        ●
     │           ●
     │              ●  …
0,10 ┤─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ● ─   franchi vers 11 tokens
     └────────────────────────▶ tokens

demi-vie = ln(0,5)/ln(α) ≈ 3,1 tokens

Le problème — Porte d’écriture

Symétriquement : tout token mérite-t-il d’écrire ? Un « le » redondant qui écrit à pleine force use la capacité et pousse l’état vers l’interférence ; une correction critique écrite timidement ne corrige rien.

L’idée — Porte d’écriture

β_t dose la correction delta : S_t = S′ + β_t k eᵀ. Sur la trace, β = 0,5 n’applique que la moitié de l’erreur — il reste exactement (1−β)·e. β ≈ 0 ignore, β = 1 corrige à fond, décidé token par token.

Pourquoi / à quel prix — Porte d’écriture

Deux portes indépendantes : α décide ce qui reste, β ce qui entre — une commande fine, et apprise. Le prix : deux réglages qui peuvent se compenser ; diagnostiquer « mémoire trop courte » exige de séparer l’effet de α de celui de β.

Contrôle : Sur l’état décru S′ = [[1,6 ; 2,4],[4 ; 0,8]] avec e = [7,4 ; 6,6], donnez S pour β=0 puis β=1. Quel token du texte justifierait chacun de ces deux réglages ?

Le problème — Stabilité

Ces récurrences tournent 100 000 fois de suite. Une porte à 1,05 — 5 % de trop — multiplie l’état par 7 en 40 tokens, par 131 en 100. Et le même code avec l’ordre corriger-puis-décroître produit d’autres nombres : deux modèles pour une même formule.

L’idée — Stabilité

La stabilité tient à des détails contraignants : α borné dans [0,1] — pas seulement |α| ≤ 1, un α négatif ferait osciller le signe —, clés normalisées, et un ordre d’opérations déclaré : décroître, lire, corriger.

Pourquoi / à quel prix — Stabilité

Ces contraintes rendent la récurrence sûre sur des longueurs arbitraires. Le prix : rien n’est cosmétique — une implémentation qui écrit S = αS + βk eᵀ sans préciser l’ordre est irreproductible. Les détails sont l’architecture.

Contrôle : Deux implémentations partent de S₀ = [[2 ; 3],[5 ; 1]] avec α=0,8, β=0,5, k=[1,0], v=[9,9]. L’une décroît puis corrige : [[5,30 ; 5,70],[4,00 ; 0,80]]. L’autre corrige puis décroît : [[4,40 ; 4,80],[4,00 ; 0,80]]. Un seul détail change — lequel ? Pourquoi un rapport qui écrit « S = αS + βk eᵀ » sans préciser l’ordre est-il irreproductible ?

Support visuel — Stabilité

même formule, deux ordres, deux modèles

① décroître → corriger : S₁ = α·S₀ + β k e′ᵀ → [[5,30 ; 5,70],…]
② corriger → décroître : S₁ = α·(S₀ + β k eᵀ) → [[4,40 ; 4,80],…]
                                   ↑
                 en ②, la correction fraîche subit
                 un oubli qu’elle n’a pas vécu

Le problème — Capacité effective

S fait toujours 2×2 — pourtant α = 0,99 et α = 0,80 donnent des mémoires radicalement différentes. Si la taille physique ne bouge pas, que mesure au juste « la mémoire » de ce modèle ?

L’idée — Capacité effective

La bonne grandeur est la durée utile : demi-vie ≈ 69 tokens à α = 0,99, ≈ 3,1 à α = 0,80, 1,0 à α = 0,5. La capacité effective combine taille de S, oubli et séparation des clés — pas la longueur maximale affichée du contexte.

Pourquoi / à quel prix — Capacité effective

La demi-vie donne un langage honnête pour comparer des mémoires — et pour lire les annonces : « contexte de 1 M de tokens » ne dit rien de ce qui survit 1 000 pas. Le prix : c’est une moyenne ; la rétention réelle dépend des portes apprises, donc du contenu.

Contrôle : La taille de S reste 2×2 dans toute la séance. À α=0,99, la demi-vie d’une trace vaut ≈ 69 tokens ; à α=0,80, ≈ 3,1. Qu’est-ce qui a changé si ce n’est pas la capacité physique ? Reformulez « contexte de 1 M de tokens » en une phrase contenant une demi-vie.

Support visuel — Capacité effective

α           0,50           0,80           0,99
            │              │              │
demi-vie    1 token        3,1 tokens     69 tokens
            mémoire de     contexte       quasi-rétention,
            travail        local          interférence accumulée

« contexte 1 M de tokens » sans demi-vie :
la longueur du papier, pas celle de la mémoire

Le problème — Lien avec Mamba

Deux familles — SSM (Mamba) et mémoires delta à portes — affichent le même argumentaire : état fixe, portes dépendantes de l’entrée, long contexte. Faut-il en conclure qu’elles sont interchangeables, et benchmarker l’une pour choisir l’autre ?

L’idée — Lien avec Mamba

Le recouvrement est réel : récurrence plus contrôles appris. La différence aussi : la mémoire delta LIT son état (v̂ = S′ᵀk) et écrit l’erreur ; un SSM classique filtre le signal sans lecture associative. Même famille de motivations, équations distinctes.

Pourquoi / à quel prix — Lien avec Mamba

Le parallèle guide l’intuition et le transfert d’outils (chunking, portes). Le prix de l’analogie facile : des conclusions non transférables — un résultat Mamba ne prouve rien sur Gated DeltaNet, et réciproquement. Comparer exige les deux implémentations, même tâche, même budget.

Contrôle : Mamba et Gated DeltaNet ont tous deux un état récurrent et des contrôles dépendants de l’entrée. Nommez une chose que fait l’étape lire-comparer (v̂ = S′ᵀk, e = v − v̂) et que « état récurrent + porte » ne suffit pas à décrire.

Cas guidé — trace complète

Avec α=0,8, une trace de valeur 1 devient 0,8 puis 0,64 sans nouvelle écriture. Une correction β=0,5 n’ajoute ensuite que la moitié de l’erreur observée.

S₀ = [[2 ; 3],[5 ; 1]]   (état hérité des séances 13-14)

── A. Décroissance seule, α = 0,8, aucune écriture ────────────────
  t+1 : S = 0,8·S₀        = [[1,60 ; 2,40],[4,00 ; 0,80]]
  t+2 : S = 0,8·S        = [[1,28 ; 1,92],[3,20 ; 0,64]]
  la trace de valeur 1 suit 1 → 0,80 → 0,64 → 0,512 …
  demi-vie : ln(0,5)/ln(0,8) = 3,106 → ≈ 3,1 tokens   ✅ borne mesurable

── B. Décroissance PUIS correction, α=0,8 β=0,5, k=[1,0] v=[9,9] ──
  S′  = [[1,60 ; 2,40],[4,00 ; 0,80]]
  v̂   = S′ᵀk = [1,60 ; 2,40]
  e   = [9−1,60 ; 9−2,40] = [7,40 ; 6,60]
  β k eᵀ = [[3,70 ; 3,30],[0 ; 0]]
  S₁  = [[5,30 ; 5,70],[4,00 ; 0,80]]
  lecture q=[1,0] → [5,30 ; 5,70]   ❌ pas [9,9]
  erreur résiduelle = [3,70 ; 3,30] = exactement (1−β)·e   ✅ prévisible
  ligne 2 : jamais écrite, mais décrue de 0,8 → l’oubli, lui, est GLOBAL

── C. ❌ Porte non bornée, α = 1,05 ────────────────────────────────
  1,05⁴⁰ ≈ 7,0   ;   1,05¹⁰⁰ ≈ 131,5
  sans écriture, l’état diverge : le bornage de α dans [0,1] n’est pas
  cosmétique, c’est ce qui rend la récurrence stable sur 100 000 tokens

── D. ❌ Ordre inversé : corriger PUIS décroître ───────────────────
  S = 0,8·([[2 ; 3],[5 ; 1]] + 0,5·k(v−S₀ᵀk)ᵀ) = 0,8·[[5,5 ; 6,0],[5 ; 1]]
    = [[4,40 ; 4,80],[4,00 ; 0,80]]  ≠  [[5,30 ; 5,70],[4,00 ; 0,80]]
  la correction fraîche subit un oubli qu’elle n’a pas vécu : même
  formule, autre modèle. L’ordre est une décision d’architecture.

CONTRÔLE D’UNITÉS : α et β sont des scalaires SANS unité ; e est dans
l’unité de v ; α·S et βk eᵀ sont donc homogènes à S. Un α négatif ferait
osciller le signe de la mémoire — d’où la borne, pas seulement |α|≤1.

Régimes de la porte de décroissance et durée utile de la mémoire

α_t Demi-vie (tokens) Comportement et risque
0,99 ≈ 69 quasi-rétention : interférence accumulée, saturation
0,80 ≈ 3,1 oubli rapide : bon pour un contexte local, perd le début
0,50 1,0 mémoire de travail : ne retient guère plus que le token précédent
1,05 aucune (divergence) ×7 en 40 tokens, ×131 en 100 : NaN quasi assuré

Laboratoire causal

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

/interactives/curriculum/chunk-gate-memory.html?lang=fr

Erreurs fréquentes

« Oublier fait perdre de l’information, donc il faut garder α le plus près possible de 1. »

À α=0,99 la demi-vie est ≈ 69 tokens : les vieilles associations restent et se superposent aux nouvelles — c’est exactement l’interférence de la séance 13. La décroissance libère de la capacité ; elle ne détruit pas une mémoire par ailleurs infinie.

« Gated DeltaNet, c’est Mamba avec un autre nom. »

Le parallèle est conceptuel : état récurrent + contrôles dépendants de l’entrée. Mais l’étape v̂ = S′ᵀk puis e = v − v̂ suppose une lecture associative de l’état, ce que « modèle d’état » ne dit pas. Même famille de motivations, équations distinctes.

Frontière, preuve et sources

Le parallèle avec Mamba est conceptuel. Il ne faut pas conclure que Gated DeltaNet et Mamba sont interchangeables.

Statut de preuve : Établis : règle delta, décroissance exponentielle et demi-vies calculées ici. Pédagogiques : les valeurs α, β et les matrices 2×2 de la trace. Rapportés : les choix de portes exacts des modèles nommés.

  • Dossier de cours bilingue fourni par le propriétaire, chapitre 11.
  • Yang, Kautz & Hatamizadeh, “Gated Delta Networks: Improving Mamba2 with Delta Rule”, ICLR (2025), arXiv:2412.06464.
  • Gu & Dao, “Mamba: Linear-Time Sequence Modeling with Selective State Spaces”, arXiv:2312.00752 (2023).
  • 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

Un assistant de support doit retenir le nom du client — posé une fois vers le token 20 — pendant environ 2 000 tokens d’échanges.

  1. Avec un α constant, quelle valeur faut-il pour garder ≥ 50 % de la trace à 2 000 tokens ? (résolvez α²⁰⁰⁰ = 0,5)
  2. Ce α est-il vivable pour le reste de la mémoire ? Citez le régime de la table.
  3. Proposez la solution par portes apprises : que doivent faire α_t et β_t aux moments clés ?

Synthèse et ticket de sortie

  • Pourquoi oublier
  • Porte de décroissance
  • Porte d’écriture
  • Stabilité
  • Capacité effective
  • Lien avec Mamba

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: Ouvrir sur l’exemple vécu avant tout mécanisme : « votre interlocuteur a déménagé — que faites-vous de l’ancienne adresse ? ». La salle répond « je l’oublie » sans hésiter ; noter que personne ne considère cela comme une perte.

Notes formateur: Ne pas présenter l’oubli comme une contrainte technique. Demander d’abord un exemple vécu où se souvenir de tout serait nuisible (un changement d’adresse, une correction dans un mail). Le mécanisme se justifie ensuite tout seul.

Notes formateur: Réponse attendue : le nouveau sujet hérite d’associations de l’ancien — p. ex. un personnage disparu qui resurgit dans la génération ; le mécanisme correcteur est la porte de décroissance α. Erreur attendue : invoquer la règle delta seule — elle corrige une clé à la fois, pas l’accumulation globale.

Notes formateur: Demander : « l’oubli doit-il aller à la même vitesse dans un SMS et dans un contrat ? ». Le non unanime justifie la porte APPRISE avant même d’en écrire la formule.

Notes formateur: Faire calculer 0,8ⁿ à la calculatrice jusqu’à passer sous 0,1, puis introduire la demi-vie comme raccourci. L’ordre inverse — formule d’abord — ne laisse aucune trace mémorielle.

Notes formateur: Réponse : 0,8ⁿ < 0,1 → n = 11 tokens depuis l’écriture ; demi-vie = ln(0,5)/ln(0,8) = 3,106. Erreur attendue : raisonner linéairement (« encore deux fois deux pas ») sur un processus géométrique — renvoyer à la courbe du support visuel.

Notes formateur: Faire vérifier le point 0,10 à la calculatrice (0,8¹¹ ≈ 0,086) puis refaire la courbe de tête pour α = 0,99 : elle devient presque plate — c’est la ligne « quasi-rétention » de la table des régimes.

Notes formateur: Faire chercher deux tokens réels : un qui ne mérite pas d’écrire (« le ») et un qui l’exige (« en fait, le prix est passé à 9 »). Les deux exemples serviront de bornes β≈0 et β=1 pour tout le beat.

Notes formateur: Poser β=0 et β=1 sur un même exemple et faire chercher un token réel du corpus pour chacun. Tant que β reste un nombre abstrait, la « porte » n’est qu’un mot.

Notes formateur: Réponse : β=0 → S = S′, aucune écriture (token redondant, « le ») ; β=1 → ligne 1 = [1,6+7,4 ; 2,4+6,6] = [9 ; 9] exactement (correction critique). Erreur attendue : appliquer la correction aussi à la ligne 2 — k = [1,0] ne la sélectionne pas.

Notes formateur: Annoncer le chiffre avant l’explication : « 5 % d’écart sur α, et l’état est multiplié par 131 en 100 tokens ». Laisser l’énormité s’installer, puis demander d’où elle vient — la géométrie de l’exponentielle fait le travail.

Notes formateur: Écrire les deux ordres d’opérations au tableau sans dire lequel est le bon, faire calculer les deux, puis révéler l’écart 5,30 contre 4,40. C’est le moment où « détail d’implémentation » cesse d’être une excuse.

Notes formateur: Réponse : seul l’ORDRE change — décroître puis corriger contre corriger puis décroître ; dans le second cas la correction fraîche subit un oubli qu’elle n’a pas vécu. Sans l’ordre, « S = αS + βk eᵀ » ne dit ni ce que voit la lecture (S ou S′) ni qui subit α : les nombres sont irreproductibles. Erreur attendue : « les deux finissent par converger ».

Notes formateur: Préciser que e′ est l’erreur mesurée sur l’état décru S′, e celle mesurée sur S₀ : les deux ordres changent aussi ce que voit la lecture. Faire cocher dans un pseudo-code réel où se joue la différence.

Notes formateur: Écrire au tableau « S : 2×2 hier, 2×2 aujourd’hui » et demander ce qui a bien pu changer. Le paradoxe apparent (même taille, autre mémoire) est l’accroche du beat — ne pas le résoudre trop vite.

Notes formateur: Faire traduire un argument marketing de contexte long en demi-vie estimée. Exercice court, effet durable : ils ne reliront plus jamais une annonce de « contexte » de la même façon.

Notes formateur: Réponse : la durée utile a changé, pas la capacité physique — demi-vie 69 contre 3,1 tokens. Reformulation attendue : « le contexte affiche 1 M de tokens, mais une trace non réécrite y survit ~69 tokens à α=0,99 ». Erreur attendue : répondre en gigaoctets.

Notes formateur: Faire placer un cas d’usage réel sur la règle (dialogue court, résumé de rapport, base de code) avant de donner la lecture. Chaque placement exige de choisir une demi-vie — c’est l’exercice.

Notes formateur: Afficher les deux argumentaires marketing (SSM / delta) côte à côte, mots identiques surlignés. Demander : « peut-on choisir sur cette base ? ». Le non collectif motive la recherche de la différence d’équation.

Notes formateur: Sur Mamba, résister à la tentation d’unifier. Demander explicitement « qu’est-ce que l’un fait que l’autre ne fait pas ? » et accepter un « je ne sais pas » collectif plutôt qu’une analogie fausse qu’ils répéteront.

Notes formateur: Réponse : la lecture associative de l’état suivie de l’écriture de l’erreur — un simple « état récurrent + porte » décrit aussi un filtre qui ne lit jamais sa mémoire. Erreur attendue : répondre par un écart de performance rapporté plutôt que par une différence de mécanisme.

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 : (1) α = 0,5^(1/2000) ≈ 0,99965 — pratiquement 1 ; (2) non : c’est le régime « quasi-rétention » de la table — tout le reste s’accumule aussi, interférence et saturation garanties ; (3) portes apprises : α_t proche de 1 par défaut, abaissé aux changements de sujet, et β_t élevé quand le nom réapparaît — la vraie réponse est « réécrire ce qui doit durer », pas « ne jamais oublier ». Idée fausse à récolter : chercher LE α parfait. 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é.