Synthèse : architecture hybride long contexte

Assembler entraînement, Q/K/V, mémoires, caches, experts et chemins résiduels en un préfill puis un décodage complets.

Applied AI · advanced · Session 21

Carte du mécanisme

AVANT : pré-formation fige embeddings, W_Q/K/V, routeurs, portes
════════════════════════════════════════════════════════════════
 texte ─▶ tokens ─▶ embeddings ─▶ FLUX RÉSIDUEL x₀
                                        │
 ┌────────────────────────────────────────▼──────────────────────┐
 │ BLOC ×48   (motif : 3 couches delta, puis 1 exacte)           │
 │  ┌───────────────┐         ┌───────────────┐                  │
 │  │ MÉLANGE SÉQ.  │  ou     │ ATTENTION MLA │ ← cache c_t      │
 │  │ état delta S  │         │ exacte, Q/K/V │   (1 Kio/token)  │
 │  │ (32 Kio fixe) │         └───────────────┘                  │
 │  └───────┬───────┘                 │                          │
 │          └────────────┬────────────┘                          │
 │                       ▼  ⊕ résiduel                           │
 │              ┌────────────────┐                               │
 │              │ ROUTEUR top-2  │──▶ E_i, E_j (+ partagé)       │
 │              └────────┬───────┘    capacité C, all-to-all     │
 │                       ▼  ⊕ résiduel                           │
 └───────────────────────┬───────────────────────────────────────┘
        checkpoints x₀,x₁₂,x₂₄,x₃₆ ──▶ mélange profondeur (softmax)
                         ▼
              norme ─▶ W_vocab ─▶ softmax ─▶ token suivant
 PRÉFILL : chunks parallèles remplissent caches + états
 DÉCODAGE : 1 token, lit le passé, met à jour S et le cache, boucle

Le problème — Avant l’inférence

Douze sessions de mécanismes, et une question piège en réunion : « donc le modèle apprend pendant qu’on lui parle ? ». Sans un tri net entre ce qui est appris et ce qui est écrit, toute l’architecture qui suit sera mal lue.

L’idée — Avant l’inférence

Le tri : la pré-formation apprend puis FIGE embeddings, projections, routeurs et portes. À l’inférence, ces paramètres s’appliquent ; seuls évoluent le contexte, le cache MLA, l’état delta S et les checkpoints — l’état de travail, remis à zéro à la requête suivante.

Pourquoi / à quel prix — Avant l’inférence

Ce partage rend le système analysable : tout comportement se rattache soit aux poids (hors ligne), soit à l’état (cette requête). Le prix : aucune mémoire entre conversations sans machinerie externe — un choix de conception, pas un oubli.

Contrôle : Le routeur, W_DKV et les portes sont figés à l’inférence ; seuls le cache MLA, l’état delta S et les checkpoints évoluent. Classez ces six objets en « appris hors ligne » et « écrit pendant la requête », puis dites lequel se remet à zéro entre deux conversations.

Le problème — Entrée et représentation

48 blocs hétérogènes — delta, MLA, MoE, récupération — doivent coopérer sans se connaître. Il faut un support commun que chacun lit et enrichit, sinon l’assemblage n’est qu’une pile de modules incompatibles.

L’idée — Entrée et représentation

Ce support est le flux résiduel : le texte devient tokens puis embeddings, et un vecteur de d_model = 4096 par position traverse les 48 blocs, chacun AJOUTANT sa contribution (session 20). Le flux est le bus de données de toute l’architecture.

Pourquoi / à quel prix — Entrée et représentation

Un contrat d’interface unique — c’est ce qui rend l’hybride composable. Le prix, connu : environ 96 additions (deux par bloc) diluent les contributions anciennes ; la question de la session 20 — que reste-t-il de x₀ ? — se repose ici à l’échelle du système.

Contrôle : Le flux résiduel transporte un vecteur de 4096 par position à travers 48 blocs. Combien d’additions ce vecteur subit-il avant W_vocab dans cette conception, et quelle grandeur de la séance 20 cela vous fait-il craindre ?

Le problème — Mélange séquentiel

Le poste mémoire dominant vient du mélange de séquence : tout exact = 24 Gio à 131 072 tokens (session 18) ; tout delta = 1 Mio mais rappel approché (sessions 13-16). Aucun des deux purs n’est vivable. Comment doser ?

L’idée — Mélange séquentiel

Le motif hybride : trois couches delta (état fixe, longueur quasi gratuite) puis une couche exacte sous MLA (rappel fidèle, cache réduit). Résultat de la trace : 1,5 Gio de cache et 1,1 Mio d’état — ÷16 sur le poste dominant.

Pourquoi / à quel prix — Mélange séquentiel

Chaque couche reçoit le mécanisme adapté à son rôle. Le prix : le RATIO devient un hyperparamètre d’architecture — 1 sur 4 ? 1 sur 2 ? — qui se paie en Gio et se justifie en qualité de rappel : un choix à tester, pas à déclarer.

Contrôle : Le motif est « 3 couches delta puis 1 exacte », soit 12 exactes sur 48. Recalculez le cache pour un motif « 1 sur 2 » : quel poste passe de 1,5 Gio à quoi, et quel bénéfice de qualité justifierait ce doublement ?

Support visuel — Mélange séquentiel

motif « 3 delta, 1 exacte » répété 12 fois sur 48 couches

D D D E   D D D E   D D D E   …        E = exacte sous MLA
                                       D = delta, état fixe
cache : 12 E × 1 Kio/token = 12 Kio/token → 1,5 Gio à 131 072 t
état  : 36 D × 32 Kio      ≈ 1,1 Mio      → indépendant de n

tout E (48) : 24 Gio   ‖   tout D : ≈ 1,5 Mio, rappel approché
le ratio E/D est le curseur fidélité ↔ mémoire

Le problème — Experts

La capacité du FFN doit grandir sans que chaque token paie le bloc entier — la session 19 a posé le problème, et son piège : confondre paramètres actifs et vitesse.

L’idée — Experts

Chaque bloc route ses tokens : top-2 parmi 64 experts plus un partagé — 26 Md de paramètres résidents, 1,2 Md actifs par token. Dans le budget global, le MoE n’apparaît pas dans la mémoire de contexte : il vit dans le budget poids et dans la latence all-to-all.

Pourquoi / à quel prix — Experts

Capacité conditionnelle massive. Le prix : trois budgets distincts à tenir — poids (26 Md), calcul (1,2 Md), réseau (all-to-all, capacité C) — et le ratio 21× n’en gouverne qu’un seul.

Contrôle : Le tableau annonce 26 Md en poids pour 1,2 Md actifs par token. Ce ratio 21× apparaît-il quelque part dans le budget mémoire de la trace, et si non, dans quel budget distinct faut-il l’inscrire ?

Le problème — Profondeur et sortie

Après 48 blocs, les représentations précoces sont diluées (session 20) — et c’est la sortie, W_vocab, qui en a parfois besoin. Comment offrir un accès au passé de profondeur sans refaire exploser le budget que MLA vient de comprimer ?

L’idée — Profondeur et sortie

Des checkpoints espacés — x₀, x₁₂, x₂₄, x₃₆ : quatre ici, l’espacement de 12 de la session 20 prolongé sur 48 couches — qu’un mélange softmax resélectionne, puis norme → W_vocab → softmax du token suivant.

Pourquoi / à quel prix — Profondeur et sortie

La récupération se choisit. Le prix, découvert dans la trace : non bornés, les checkpoints coûtent 4 Gio — 73 % du budget total — et réintroduisent le O(n) éliminé ; fenêtrés à 8 192 tokens, 256 Mio. Le dernier composant ajouté peut dominer toute la facture.

Contrôle : Les 4 checkpoints de profondeur coûtent 4 Gio non bornés, soit 73 % du budget, contre 256 Mio fenêtrés à 8 192 tokens. Qu’est-ce que la fenêtre rend impossible à récupérer, et pour quelle tâche ce renoncement serait-il inacceptable ?

Support visuel — Profondeur et sortie

budget mémoire à 131 072 tokens — hybride de la trace

cache MLA (12 E)      ██████ 1,5 Gio
état delta (36 D)     ▏ ≈ 1,1 Mio
checkpoints bruts     ████████████████ 4 Gio   ← 73 % du total
  → fenêtrés 8 192 t  █ 256 Mio

total révisé ≈ 1,76 Gio    (référence tout-exact : 24 Gio, ÷13,6)
le dernier composant ajouté dominait la facture

Le problème — Préfill puis décodage

Le même assemblage doit avaler un prompt entier puis générer token par token. Si l’on ne mesure qu’un régime, le verdict de conception est faux pour l’autre — préfill et décodage ne saturent pas les mêmes ressources.

L’idée — Préfill puis décodage

Préfill : des chunks parallèles (session 15) remplissent caches et états — régime limité par le calcul. Décodage : un token relit tout le passé disponible, met à jour S et le cache — régime limité par la bande passante mémoire. Deux profils, un seul code.

Pourquoi / à quel prix — Préfill puis décodage

Lire les deux régimes sépare latence du premier token et débit de génération. Le prix méthodologique : tout verdict exige des mesures — qualité, latence par régime, mémoire — sur la tâche réelle ; un schéma, aussi cohérent soit-il, reste une hypothèse.

Contrôle : Le préfill traite des chunks de 2048 positions, le décodage une seule. Le même code passe de FLOP-bound à bande-passante-bound : lequel des quatre postes du tableau domine chaque régime, et lequel mesureriez-vous en premier pour rendre le verdict de conception ?

Support visuel — Préfill puis décodage

PRÉFILL (une fois par requête)     DÉCODAGE (à chaque token)
──────────────────────────────     ─────────────────────────────
chunks de 2048 en parallèle        1 position
remplit cache + états              relit cache + états, écrit 1
limité par : FLOPs                 limité par : bande passante
métrique : latence 1ᵉʳ token       métrique : tokens/seconde

   un verdict de conception doit citer LES DEUX colonnes

Cas guidé — trace complète

Conception bornée : couches d’attention exacte périodiques pour récupération fidèle, couches delta entre elles pour état fixe, MLA pour réduire le cache par token, MoE pour capacité conditionnelle, checkpoints de profondeur espacés. Le verdict dépend de mesures qualité/latence/mémoire sur la tâche réelle.

CONCEPTION BORNÉE : 48 couches, 1 exacte sur 4 (12 exactes, 36 delta),
MLA (c divise le terme par token par 4), MoE top-2 + 1 partagé,
checkpoints de profondeur tous les 12. Contexte n = 131 072 tokens.

BASE DE RÉFÉRENCE — 48 couches d’attention pleine, 8 têtes KV, d_head=128, BF16
  par token/couche = 2 × 8 × 128 × 2 = 4 096 o = 4 Kio
  48 couches → 192 Kio/token
  × 131 072 tokens = 24 Gio                                   ❌ intenable

HYBRIDE — poste par poste
  12 couches exactes en MLA : 1 Kio/token/couche → 12 Kio/token
    × 131 072 = 1 572 864 Kio = 1 536 Mio = 1,5 Gio           ✅ ÷16
  36 couches delta, état fixe 128×128×2 = 32 Kio/couche
    36 × 32 Kio = 1 152 Kio ≈ 1,1 Mio, indépendant de n       ✅
  4 checkpoints, d_model = 4096, BF16, sur tout le contexte
    4 × 4096 × 2 o × 131 072 = 4 294 967 296 o = 4 Gio        ❌
  TOTAL = 1,5 + 0,001 + 4 = 5,5 Gio
  → le poste « profondeur », ajouté en dernier, pèse 73 % du budget
    et réintroduit exactement la croissance O(n) que MLA venait de
    diviser. Correctif borné : checkpoints sur la fenêtre récente
    (8 192 tokens) → 4 × 4096 × 2 × 8 192 = 256 Mio             ✅
  TOTAL RÉVISÉ = 1,5 Gio + 1,1 Mio + 256 Mio ≈ 1,76 Gio  (÷13,6 vs base)

CALCUL PAR PAS DE DÉCODAGE
  FFN : 64 experts × 0,4 Md, actifs (2 + 1) × 0,4 = 1,2 Md sur 26 Md
  mais la latence est cadencée par l’expert saturé et le all-to-all,
  pas par le ratio 21×.                                        ❌ piège

CONTRÔLE D’UNITÉS ET DE FORME
  1 Gio = 1 024 Mio ; 4 Kio ÷ 4 = 1 Kio (MLA), pas 4 Mio.
  Préfill : [chunk=2048, d_model] en parallèle → écrit 2048 entrées de cache.
  Décodage : [1, d_model] → écrit 1 entrée. Même code, batch 2048 contre 1 :
  le décodage est limité par la bande passante mémoire, pas par les FLOPs.

Budget mémoire par poste à 131 072 tokens, et ce qu’il achète

Poste Coût à n = 131 072 Ce qu’il achète / son risque
12 couches exactes + MLA 1,5 Gio, O(n) rappel fidèle des tokens lointains ; reste linéaire
36 couches delta ≈ 1,1 Mio, constant longueur quasi gratuite ; interférence entre écritures
MoE top-2 + partagé 26 Md en poids (≈ 52 Gio BF16), 1,2 Md actifs capacité conditionnelle ; latence all-to-all et rejets
4 checkpoints profondeur 4 Gio → 256 Mio si fenêtrés récupération choisie ; réintroduit du O(n) si non borné

Laboratoire causal

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

/interactives/curriculum/cache-mla-comparison.html?lang=fr

Erreurs fréquentes

« Cette architecture hybride est la bonne : elle combine le meilleur de chaque mécanisme. »

La trace montre le contraire d’un cumul d’avantages : MLA divise le cache par 16, puis les checkpoints de profondeur ajoutent 4 Gio et réintroduisent le O(n) tout juste éliminé — 73 % du budget pour le dernier composant ajouté. Un schéma est une hypothèse ; seuls des tests contrôlés qualité/latence/mémoire sur la tâche réelle décident. Aucun assemblage n’est universellement meilleur.

« Le modèle apprend pendant la conversation : le cache et l’état delta, c’est de la mémoire. »

Deux choses distinctes portent le même mot. Les poids appris hors ligne — embeddings, W_Q/K/V, W_DKV, routeur, experts — ne bougent pas d’un octet pendant l’inférence. Ce qui change est l’état de travail : cache MLA, état S, checkpoints, tous remis à zéro à la requête suivante. Le préfill remplit cet état, le décodage le lit et le met à jour ; rien de tout cela n’est un apprentissage.

Frontière, preuve et sources

Il n’existe pas de meilleur assemblage universel. Un schéma est une hypothèse ; seuls tests contrôlés, profils matériels et évaluations utilisateur établissent sa valeur.

Statut de preuve : Mixte : mécanismes établis + choix de type Kimi K3 rapportés par la source.

  • Dossier de cours bilingue fourni par le propriétaire, chapitre 16.
  • Vaswani et al., “Attention Is All You Need”, NeurIPS (2017).
  • DeepSeek-AI, “DeepSeek-V2” (Multi-head Latent Attention), arXiv:2405.04434 (2024).
  • Yang, Kautz & Hatamizadeh, “Gated Delta Networks: Improving Mamba2 with Delta Rule”, ICLR (2025).
  • 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

Votre équipe doit servir un contexte de 1 M de tokens avec le même budget mémoire (~2 Gio par requête).

  1. Reprenez les quatre postes du tableau : lesquels explosent à 1 M, lesquels tiennent ?
  2. Proposez UNE modification par poste qui explose, et nommez ce qu’elle sacrifie.
  3. Rendez un verdict borné : les trois mesures qui décideraient, et votre seuil de retour arrière.

Synthèse et ticket de sortie

  • Avant l’inférence
  • Entrée et représentation
  • Mélange séquentiel
  • Experts
  • Profondeur et sortie
  • Préfill puis décodage

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 par la question piège entendue en réunion : « donc il apprend pendant qu’on lui parle ? ». Faire répondre la salle à chaud et garder les réponses affichées — le beat les reclasse toutes, une par une.

Notes formateur: Ouvrir la synthèse par un tri au tableau en deux colonnes, « figé » et « écrit maintenant », et faire placer les six objets par la salle. Toute confusion résiduelle sur ce point rend le reste de la séance inaudible.

Notes formateur: Réponse : appris hors ligne — routeur, W_DKV, portes ; écrit pendant la requête — cache MLA, état S, checkpoints ; et les trois derniers se remettent à zéro entre conversations. Erreur attendue : classer l’état delta en « appris » parce qu’il ressemble à des poids — rappel session 14 : poids rapides.

Notes formateur: Demander : « quel objet traverse TOUS les blocs ? », puis faire deviner sa taille (4096 par position) et son rôle de bus. Si le mot « résiduel » ne vient pas, trente secondes de rappel de la session 20 suffisent.

Notes formateur: Faire suivre un seul token au feutre, du texte jusqu’à la sortie softmax, une personne par bloc du schéma. Le relais oblige chacun à nommer ce qui entre et ce qui sort de son étage.

Notes formateur: Réponse : environ 96 additions — deux par bloc, mélange puis FFN/MoE. La grandeur à craindre : la dilution de la session 20 — la part des contributions précoces s’effondre, et c’est précisément ce que les checkpoints de profondeur viendront corriger. Erreur attendue : 48, une seule addition par bloc.

Notes formateur: Faire voter le motif avant tout calcul : tout exact, tout delta, ou mélange ? Chaque camp donne sa raison — les chiffres du beat arbitrent ensuite (24 Gio / 1 Mio / 1,5 Gio).

Notes formateur: Faire voter le motif exacte/delta avant de montrer le chiffre : « 1 sur 4, 1 sur 2, ou tout exact ? » Puis dévoiler 1,5 Gio contre 24 Gio. Le vote transforme un paramètre en décision assumée.

Notes formateur: Réponse : 24 couches exactes × 1 Kio = 24 Kio/token → 3 Gio à 131 072 tokens : le poste cache double (1,5 → 3 Gio), les autres postes ne bougent pas. Justification exigible : un gain MESURÉ de rappel lointain sur la tâche réelle — pas « plus d’exact, c’est forcément mieux ». Erreur attendue : recalculer tout le budget au lieu du seul poste concerné.

Notes formateur: Faire recalculer la ligne cache pour un motif 1 sur 2 (24 E → 3 Gio) : c’est exactement le contrôle qui suit. Souligner que « tout E » n’utilise pas MLA dans la référence de la trace — d’où 24 Gio et non 6.

Notes formateur: Question de rappel de la session 19 : « le ratio 21×, il gouverne quoi déjà ? ». Attendu : les FLOPs, et seulement eux. Le beat replace ensuite le MoE dans ses trois budgets.

Notes formateur: Rappeler la séance 19 par une seule question : « où est le MoE dans ce budget mémoire ? » L’absence du ratio 21× dans le tableau est le point ; laisser le silence faire le travail.

Notes formateur: Réponse : non — le 21× ne figure pas dans la mémoire de contexte : les 26 Md vivent dans le budget POIDS (≈ 52 Gio en BF16, ligne du tableau) et le 1,2 Md dans le budget CALCUL. Trois budgets, trois lignes distinctes. Erreur attendue : chercher le 21× dans la colonne cache.

Notes formateur: Présenter d’abord les checkpoints comme la victoire de la session 20, puis faire calculer leur coût sur 131 072 tokens AVANT d’afficher les 4 Gio. La chute — 73 % du budget — doit être découverte par la salle.

Notes formateur: Présenter les 4 Gio de checkpoints comme une victoire avant de faire calculer leur part du total. Découvrir soi-même les 73 % vaut tous les avertissements sur les optimisations qui s’annulent.

Notes formateur: Réponse : la fenêtre rend irrécupérable tout état de profondeur au-delà de 8 192 tokens en arrière — inacceptable pour une tâche qui cite le début d’un très long document (contrat, base de code). Pont utile : quatre checkpoints ici (x₃₆ ajouté) contre trois en session 20 — même espacement de 12, réseau plus profond. Erreur attendue : confondre fenêtre sur les tokens et sélection des couches.

Notes formateur: Faire vérifier le 73 % (4 / 5,5) et le ÷13,6 (24 / 1,76) à la calculatrice. Puis demander : « quel poste réexplose si le contexte passe à 1 M ? » — le cache MLA, seule ligne encore en O(n).

Notes formateur: Demander : « votre benchmark mesure le débit de génération — que rate-t-il ? ». Attendu : la latence du premier token, donc le préfill. Les deux colonnes du support visuel structurent tout le beat.

Notes formateur: Clore en exigeant un verdict borné, formulé en trois mesures nommées et un seuil chiffré. Refuser « ça dépend » comme réponse finale : le livrable de la séance est une hypothèse testable, pas une architecture.

Notes formateur: Réponse : préfill — dominé par le calcul (attention en chunks, MoE) ; décodage — dominé par la relecture du cache MLA, donc la bande passante. Première mesure pour le verdict : le débit de décodage sous longueur croissante, là où cache et all-to-all se cumulent. Accepter toute réponse argumentée qui nomme UNE mesure par régime.

Notes formateur: Faire classer trois optimisations dans la bonne colonne : chunking (préfill), MLA (surtout décodage), quantisation du cache (décodage). Une optimisation mal classée est un benchmark mal lu.

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: Attendus : (1) le cache MLA explose — 12 Kio/token × 1 048 576 ≈ 12 Gio ; les checkpoints fenêtrés tiennent (256 Mio, indépendants de n), l’état delta tient (1,1 Mio), les poids MoE ne bougent pas. (2) p. ex. motif 1 sur 8 (cache ÷2, rappel exact raréfié), c plus étroit (reconstruction plus contrainte), fenêtre d’attention exacte (perd le rappel lointain fidèle). (3) mesures : rappel long-contexte de type needle, débit de décodage à 1 M, mémoire pic ; seuil p. ex. « rappel < 95 % de la référence → retour arrière ». Idée fausse à récolter : « on garde tout et on quantise » — la quantisation divise par 2 à 4, pas par 8. 12 minutes, groupes de trois.

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é.