Moins de bits, plus de contexte : le cache KV et la quantification reprennent la main

💡 En résumé

La journée technique du 8 octobre tient dans une équation unique : réduire les ressources consommées sans dégrader la réponse. Le cache KV concentre l’effort — trois papiers attaquent ses trois angles morts (l’accès séquentiel, le coût de l’indexeur, le critère d’élagage), et un quatrième pousse la quantification jointe jusqu’à W2A4KV2 (2 bits de poids, 4 bits d’activation, 2 bits de cache). Côté entraînement, Q-PACE alloue dynamiquement la précision par couche, TAP élague 60 % des canaux FFN d’un agent RL en gardant 99,2 % de réussite, et GraphOPD distille des agents par graphe de dépendances.

Deux résultats de fond émergent : le décodage contraint peut se faire sans table (3 Mo au lieu de 1,5 Go), et la profondeur d’un transformeur cache un encodage positionnel que l’on croyait du bruit — la « malédiction de la profondeur » serait en fait une géométrie à exploiter. En marge, LiquidAI livre des modèles de décision à 16 ms sur Jetson, et Nvidia obtient l’or à l’IOI et l’IMO 2026 avec une recette de spécialisation réutilisable.

🔥 Tendances : le cache KV, angle mort structurel de l’inférence longue

KVFetch : la compression a oublié la moitié du problème

KVFetch (arXiv:2610.08811) part d’une observation décisive. Les méthodes de compression du cache KV se rangent en trois familles — éviction par score, compensation par résumé, déport-et-rappel — et toutes décident quoi garder ou rappeler par pertinence de contenu vis-à-vis de la requête courante. Or un cache supporte deux modes d’accès : la recherche associative par contenu, et la traversée séquentielle par position. Les compresseurs actuels n’implémentent que le premier.

Cette lacune devient critique partout où le modèle doit reproduire un identifiant, une valeur de champ ou un token de code verbatim — RAG, complétion de code, extraction structurée. Sous compression, l’éviction par contenu retient la tête de la séquence mais rejette sa continuation, et la copie verbatim casse irréversiblement à mi-chemin : c’est le sequential forgetting. Ce mode d’échec résiste à un meilleur scoring, un plus grand budget, un résumé compensateur et le re-scoring dynamique — il est la source dominante de perte de qualité résiduelle sous compression. KVFetch ouvre un canal de rappel temporel sans entraînement : les candidats évincés descendent dans un palier froid quantifié, un pointeur de lecture monotone détecte la copie active, et les successeurs positionnels sont préchargés dans des slots chauds de taille fixe — sans surcoût d’attention. Sur RULER-16K à budget iso, KVFetch fait passer la copie verbatim de 0,8 à 78,4 et gagne +8,4 sur la moyenne de 13 tâches. Sur LongBench, où aucune tâche n’exige d’accès séquentiel, le canal reste dormant et ne coûte rien.

SPIN : ne plus scorer tout le cache à chaque pas

SPIN (arXiv:2610.09025) attaque le goulot de l’attention sparse par indexeur. Le principe : un indexeur sélectionne un petit nombre de tokens importants à passer à l’attention — mais pour cela, il doit scorer tout le cache KV à chaque pas de décodage, surcoût qui devient majeur avec la longueur de contexte. SPIN remplace ce scoring exhaustif par une prédiction légère fondée sur l’historique : il identifie les blocs KV importants sans rescanner tout le cache. Traitant blocs KV et décodage spéculatif comme des considérations de conception de premier ordre, SPIN atteint 30-40 % de sparsité en préservant la qualité, et en service vLLM bout-en-bout il améliore le débit de sortie jusqu’à +14,9 % et réduit la latence inter-token médiane jusqu’à 13,2 %.

Self-Pruning Transformer : 10× la compression, pas la dégradation

A Self-Pruning Transformer (arXiv:2610.09051) propose un cadre unificateur de mécanismes de décroissance (decay) complémentaires, préservant les embeddings positionnels RoPE expressifs et l’attention Softmax. Le mécanisme composite agit comme un critère d’élagage adaptatif naturel, retirant les tokens qui contribuent le moins au calcul d’attention. Résultat : 10× de compression sur langage naturel et données synthétiques en améliorant la performance aval par rapport aux meilleurs baselines et aux oracles non élagués, et une généralisation long-contexte inédite à 25× de compression pour une longueur de 16k.

CanonQ : la quantification jointe jusqu’à W2A4KV2

Few Bits, One Law (arXiv:2610.09202) s’attaque au cas le plus dur : quand poids, activations et cache KV sont quantifiés ensemble, leurs distributions diffèrent et les erreurs interagissent à travers tout le réseau. CanonQ, framework de QAT, sépare la canonicalisation de source de l’adaptation orientée tâche : rotations fixes et normalisation d’énergie ramènent des tenseurs hétérogènes à des coordonnées canoniques, permettant de réutiliser des codebooks gaussiens figés à travers couches et modèles ; un entraînement joint adapte ensuite le réseau aux erreurs couplées. Sous compression jointe W2A4KV2, CanonQ-Omni obtient jusqu’à 14,28× de perplexité WikiText-2 en moins et jusqu’à 57,9 % de précision zero-shot en plus que l’état de l’art. Sur MobileLLM-Pro-1B à W2A16KV16, il gagne +41,7 % en HumanEval pass@1 et +39,1 % en GSM8K exact match.

Q-PACE : allouer la précision là où elle compte

Q-PACE (arXiv:2610.09183) répond au choix de précision par couche dans le QAT mixte. Il fournit un modèle de sensibilité du second ordre qui prédit l’augmentation de perte comme une somme de MSE de bruit de quantification pondérée par des coefficients de courbure par couche, recalculés périodiquement. Sur des LLM jusqu’à 4B, Q-PACE améliore constamment les recettes mixtes existantes et atteint une perte comparable à des budgets mémoire nettement plus bas. Découverte utile : la sensibilité à la quantification est très prévisible par profondeur et type de couche, et sa stabilité permet une recalibration peu fréquente et bon marché.

🤖 Nouveaux outils : décodage contraint, élagage et profondeur

Décodage contraint sans table : 3 Mo au lieu de 1,5 Go

Breaking the Space Barrier (arXiv:2610.09139) part d’un détail de complexité théorique. Quand un lexique doit forcer un format — JSON conforme à un schéma, appel d’outil à arguments typés — une petite machine (un automate) interdit les tokens qui casseraient la structure. Cette machine a une propriété rare : de tout état, chaque token mène le long d’exactement un chemin. Les auteurs montrent qu’on peut décider si un tel graphe connecte deux points tout en vérifiant qu’il a peu de chemins, avec très peu de mémoire — le problème tombe dans ReachUL, LOGDCFL, C=L et SC₂, et ne requiert que O(log²n / log log n) d’espace, sous le classique O(log²n) du théorème de Savitch. Les constructions deviennent un moteur d’inférence : le texte que le format impose s’écrit sans exécuter le modèle, le masque se recalcule sur GPU sans table, les formats récursifs utilisent une petite pile, et les champs indépendants se décodent en parallèle. Sur un Apple M2 Pro 16 Go avec Qwen3.5-2B/4B face à MLX+llguidance, l’extraction contrainte par schéma finit 1,2-1,3× plus tôt à réponses identiques, une grammaire coûte 3 Mo au lieu de jusqu’à 1,5 Go, un serveur tient seize grammaires là où les tables saturent la mémoire, et seize agents d’appel d’outils finissent 2,5× plus tôt.

TAP : élaguer un agent RL sans casser sa trajectoire

TAP (arXiv:2610.09074) trace l’échec des méthodes d’élagage classiques appliquées aux agents : ce qu’on élague, et comment on récupère. Les estimations d’importance en un coup ne suivent pas l’adaptation du modèle élagué ; la distillation hors ligne ne couvre que les préfixes du professeur, et la distillation on-policy de trajectoire complète laisse les erreurs de l’élève se composer sur les tours. TAP couple élagage structurel et récupération on-policy efficace : chaque interaction est ancrée sur les trajectoires du professeur tandis que l’élève génère sa réponse, un professeur dense gelé supervise les préfixes, et au lieu d’un élagage unique, TAP re-score les canaux par gradients de l’objectif de récupération sur l’élève récupéré. Avec 60 % des canaux FFN supprimés, TAP retient 99,2 % et 88,0 % des taux de réussite d’agents 7B denses sur ALFWorld et WebShop, en réduisant le temps GPU par tâche réussie d’environ 22 % et 17 %.

GraphOPD : distiller l’agent par graphe de dépendances

GraphOPD (arXiv:2610.08959) corrige une intuition fausse de la distillation on-policy : allouer les conseils selon la divergence professeur-élève à chaque étape suppose qu’un grand désaccord marque une erreur à corriger. Dès que les décisions s’enchaînent, cette règle se trompe — une dérive précoce entre dans tous les contextes suivants, le professeur devient cohérent avec la trajectoire dérivée au lieu d’en signaler la cause, et les étapes interchangeables enregistrent des divergences grandes mais sans effet sur le résultat. Sur un benchmark agentique, distiller les étapes à plus forte divergence n’apporte aucun bénéfice sur la sélection aléatoire. GraphOPD lit quelles étapes ont rendu possibles quelles suivantes depuis l’enregistrement des changements d’état de l’environnement, les organise en graphe de dépendances, score chaque étape par une distribution stationnaire de marche aléatoire, et fusionne ce crédit structurel avec le signal de divergence. Sur trois échelles de modèles et onze baselines (ALFWorld, WebShop, SearchQA), il gagne jusqu’à +5,8 pp sur le meilleur baseline, avec un transfert vers le raisonnement outillé hors domaine.

LayerRoPE : la croissance de norme n’est pas un bug

LayerRoPE (arXiv:2610.09179) renverse un dogme. À mesure que les données traversent un transformeur, la norme des états cachés croît de plusieurs ordres de grandeur avec la profondeur — phénomène traité quasi universellement comme une pathologie à supprimer. Sur 16 LLM pré-entraînés de 9 familles (dense, MoE, hybride ; Pre-, Peri-, Post-Norm), les auteurs constatent que cette croissance reflète un encodage positionnel de profondeur émergent, porté par le seul gain appris par couche sur le flux résiduel : la normalisation γ, dont la magnitude grandit et la direction tourne avec la profondeur. LayerRoPE explicite cet encodage comme un analogue implicite de RoPE le long de l’axe de profondeur, remplaçant tous les vecteurs γ par un seul vecteur partagé et des scalaires conditionnés par la profondeur — moins de paramètres, <0,02 % de FLOPs en plus. Sur une échelle jusqu’à 100B+ tokens, il atteint la perte de Pre-Norm à 1,3B avec 3,4× moins de calcul, améliore la sensibilité au taux d’apprentissage de 3-10×, et se transfère naïvement aux modèles latents bouclés et aux Vision Transformers.

Le coût de la mémoire longue, la profondeur dynamique, l’optimiseur selon le batch

Trois autres papiers complètent la journée. The Cost of Long Memory (arXiv:2610.08816) établit des bornes d’approximation appariées (supérieures et inférieures) pour la mémoire prédictive : la meilleure erreur de prévision à r modes décroît comme e^{-Θ(√r)}, si bien qu’atteindre une erreur τ exige r=Θ(log²(1/τ)) états ou modes — reliant précision de prévision, complexité d’état et criticité dynamique. Enabling Dynamic Computation in Looped LMs (arXiv:2610.09013) comble l’écart entre la promesse des LMs bouclés et la réalité : une stratégie de cache KV « meilleur disponible » permet jusqu’à 30 % de réduction de FLOPs et de mémoire KV en conservant la performance pleine profondeur, avec des tokens sortant à des profondeurs vraiment hétérogènes. Et The Best Optimizer Depends on Batch Size (arXiv:2610.08975) contredit l’idée qu’une règle d’échelle de hyperparamètres préserve la performance : aucune règle pour Muon ne marche systématiquement, et le meilleur optimiseur change avec la taille de batch même après un réglage étendu.

PEFT : des méthodes finalement peu différentes, et des modèles de décision

Are Parameter-Efficient Fine-tuning Methods Really Different? (arXiv:2610.09122) compare six méthodes en langage et en diffusion. Les méthodes de la famille LoRA préservent déjà approximativement la géométrie pré-entraînée, et restaurer leur spectre de valeurs singulières légèrement dérivé ne change pas la performance — ce qui questionne la nécessité d’une préservation géométrique explicite. LoRA limite le plus constamment l’oubli à performance compétitive, DoRA obtient de meilleurs scores moyens que LoRA dans la plupart des comparaisons, PiSSA coûte plus cher en rétention. Deux livraisons de modèles complètent la journée : LiquidAI publie les modèles de décision open d1-3B et d1-omni-600M (meilleur modèle de décision < 10B sur le Decision Index 0.2.1, score 48,57, devant Decider 35B-A3B), qui ne produisent pas de tokens mais répondent en une seule passe avant — 16 ms sur Jetson AGX Thor, 26 ms Orin, 50 ms Orin Nano. Et Nvidia montre qu’une même famille (Nemotron) atteint l’or à l’IOI 2026 (535,4/600, seuil or 361,12, meilleur humain 498,27) avec SFT et GenCorrect, et à l’IMO 2026 (30/42, seuil or 29) via un système générer-vérifier-raffiner.

📊 Analyse : l’efficacité est redevenue une discipline de mesure

Ce que ces travaux partagent, c’est un déplacement de la frontière de l’efficacité. Pendant deux ans, la compression du cache KV s’est concentrée sur ce qu’il fallait retirer. KVFetch rappelle que le cache a deux modes d’accès et que l’éviction par contenu est structurellement incomplète : il ne s’agit pas de mieux scorer, mais d’ouvrir un canal que l’architecture avait oublié. De même, SPIN déplace le coût hors du scoring exhaustif, le Self-Pruning Transformer transforme la fonction de décroissance en critère d’élagage, et CanonQ réconcilie des distributions hétérogènes avant de les quantifier ensemble.

Trois conséquences pratiques :

1. La compression n’est plus une perte à minimiser mais un choix d’accès à structurer. Le sequential forgetting montre qu’une meilleure sélection ne répare pas un canal manquant. Concevoir un cache, c’est décider quels modes de lecture l’inférence doit supporter.

2. La quantification extrême devient utilisable. W2A4KV2 avec -14,28× de perplexité montre qu’en séparant canonicalisation et adaptation, le plancher de bits recule. Pour l’edge (Jetson à 16 ms, Dev Box à 6 000 $), la latence et la mémoire cessent d’être le facteur limitant de la décision locale.

3. Le déploiement se simplifie structurellement. Un décodage contraint sans table (3 Mo vs 1,5 Go) et seize agents d’appel d’outils 2,5× plus rapides sur un seul serveur, c’est moins d’ingénierie de contraintes et plus de grammaires tenables en mémoire. À l’inverse, le résultat sur la taille de batch rappelle une humilité nécessaire : il n’existe pas d’optimiseur universel, et toute règle d’échelle est une hypothèse à revérifier à chaque régime.

🎯 À retenir

• KVFetch révèle le sequential forgetting : les compresseurs de cache KV ne gèrent que l’accès associatif, pas la traversée séquentielle. La copie verbatim passe de 0,8 à 78,4, +8,4 sur 13 tâches, sans coût quand la séquence n’est pas requise.
• SPIN supprime le scoring exhaustif de l’indexeur : 30-40 % de sparsité, +14,9 % de débit, -13,2 % de latence inter-token.
• Self-Pruning Transformer atteint 10× de compression en améliorant la performance, et 25× à 16k de contexte.
• CanonQ pousse à W2A4KV2 : jusqu’à 14,28× moins de perplexité et +57,9 % de précision zero-shot ; +41,7 % HumanEval et +39,1 % GSM8K sur MobileLLM-Pro-1B.
• Q-PACE alloue dynamiquement la précision par couche ; la sensibilité est prévisible par profondeur et type de couche, donc la recalibration peut être rare.
• Décodage contraint sans table : 3 Mo au lieu de 1,5 Go par grammaire, 1,2-1,3× plus rapide, seize agents d’outils 2,5× plus rapides sur un M2 Pro.
• TAP élague 60 % des FFN d’un agent RL en gardant 99,2 % (ALFWorld) et 88,0 % (WebShop) de réussite, pour -22 % et -17 % de temps GPU par tâche.
• LayerRoPE montre que la « malédiction de la profondeur » est un encodage positionnel à exploiter : la perte de Pre-Norm à 1,3B avec 3,4× moins de calcul, et une convergence jusqu’à 512 couches.
• Pas d’optimiseur universel : le meilleur optimiseur change avec la taille de batch, même après réglage étendu.