🤖 machine learning

CART: Context-Anchored Recurrent Transformer -- A Parameter-Efficient Architecture with Learned Stability

L'article présente CART, un modèle de langage à efficacité de paramètres qui réutilise un bloc central unique via des mécanismes de stabilité appris, mais constate que si la profondeur du prélude domine la performance, l'architecture sous-performe finalement les bases denses aux paramètres équivalents et ne parvient pas à supporter une mise à l'échelle efficace de la profondeur au moment du test.

Auteurs originaux : Chad A. Capps

Publié 2026-06-02

📖 6 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Chad A. Capps

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

L'idée principale : Un modèle de langage en « boucle »

Imaginez que vous essayez d'écrire une histoire. La méthode standard utilisée par l'IA (appelée Transformer) revient à embaucher une équipe de 12 éditeurs différents. L'éditeur 1 lit la première phrase, l'éditeur 2 lit ce que l'éditeur 1 a écrit, l'éditeur 3 lit ce que l'éditeur 2 a écrit, et ainsi de suite. Chaque éditeur possède son propre style et ses propres notes. Cela fonctionne bien, mais c'est coûteux car vous devez payer pour 12 personnes différentes.

CART (Context-Anchored Recurrent Transformer) tente une approche différente. Il n'embauche qu'un seul éditeur et lui demande de lire l'histoire six fois (ou plus).

L'objectif : Obtenir la même qualité d'écriture mais avec une équipe beaucoup plus petite (moins de paramètres), afin d'économiser de l'argent et de la mémoire.
Le piège : Si vous demandez à la même personne de lire la même chose six fois, elle risque de s'ennuyer et de répéter les mêmes erreurs. Le défi est de faire en sorte que cet éditeur unique devienne plus intelligent à chaque passage sans avoir besoin de nouvelles personnes.

Comment fonctionne CART : L'« Ancre » et la « Porte »

CART possède trois astuces spéciales pour faire fonctionner cette boucle :

L'« Ancre » (La carte gelée) :
- Boucle standard : Dans les autres modèles à boucle, chaque fois que l'éditeur lit l'histoire, il redessine la carte des mots importants. C'est lent et redondant.
- La méthode de CART : Avant que la boucle ne commence, une petite équipe de « pré-éditeurs » (appelée le Prelude) lit l'histoire une fois et dessine une carte parfaite et détaillée des mots importants. Cette carte est gelée.
- La boucle : L'éditeur unique qui boucle consulte ensuite cette même carte gelée à chaque fois qu'il lit l'histoire. Il ne redessine pas la carte ; il l'utilise simplement comme une ancre stable pour affiner sa compréhension. Cela permet d'économiser beaucoup de puissance de calcul.
La « Porte » (L'interrupteur de stabilité) :
- Le problème : Si vous demandez à quelqu'un de réfléchir de manière répétée à la même chose, il peut s'embrouiller ou commencer à halluciner (devenir fou).
- La solution de CART : Il y a une « porte » qui contrôle la quantité de la pensée précédente que l'éditeur conserve. C'est comme un bouton de volume. Si l'éditeur devient trop chaotique, la porte baisse légèrement le volume.
- La découverte : L'article a découvert que cette porte apprend à se stabiliser sur un « point d'équilibre » très précis (un nombre entre 0,79 et 0,83). Ce n'est pas imposé par les ingénieurs ; l'IA a appris ce réglage spécifique par elle-même pour rester stable.
L'« Index de boucle » (Le compteur d'étapes) :
- L'éditeur dispose d'un compteur (1, 2, 3...) pour savoir à quel passage il se trouve. Cela l'aide à savoir s'il est dans les premières étapes de la réflexion ou dans la touche finale.

Les expériences : Qu'est-ce qui s'est passé ?

Les chercheurs ont testé cela sur une seule carte graphique grand public (comme un PC de jeu haut de gamme) en utilisant deux étapes d'entraînement.

Étape 1 : Le test rapide (L'« intuition »)

Ils ont entraîné de nombreuses petites versions de CART rapidement.
L'intuition : Ils pensaient que pour des modèles plus grands et plus complexes, boucler plus de fois (par exemple 8 fois au lieu de 6) serait bien meilleur. Cela semblait indiquer que « plus de boucles = une IA plus intelligente ».

Étape 2 : L'entraînement complet (Le « retour à la réalité »)

Ils ont entraîné les modèles beaucoup plus longtemps (en utilisant environ 1 milliard de mots de texte).
La surprise : L'intuition était fausse. Lorsqu'ils ont entraîné les modèles complètement, boucler plus de fois rendait en fait le modèle légèrement moins bon ou n'apportait aucune amélioration.
L'analogie : Imaginez demander à un étudiant de lire un chapitre de manuel 10 fois. Lors d'un test rapide, lire 10 fois semble excellent. Mais après avoir étudié pendant tout un semestre, on réalise que lire 6 fois est suffisant. Lire 8 ou 10 fois conduit simplement à des rendements décroissants ou même à la confusion. Le modèle a appris que « plus de boucles » ne signifiait pas « plus d'intelligence » dans ce contexte spécifique.

Le verdict final : A-t-il gagné ?

Les chercheurs ont comparé leur modèle « Un éditeur, six boucles » à un modèle standard de « Six éditeurs différents » (un Transformer Dense) possédant la même quantité de mémoire.

Le résultat : Le modèle standard (6 éditeurs différents) a battu le modèle CART.
- Le modèle standard était environ 10 % meilleur pour comprendre le langage.
- Même en donnant au modèle standard la même puissance « effective » (en le faisant passer à 12 éditeurs), il a quand même écrasé CART.

Pourquoi CART a-t-il perdu ?
Les chercheurs ont réalisé une « autopsie » (ablations diagnostiques) pour comprendre pourquoi :

La « Carte gelée » n'était pas le problème : Même s'ils laissaient l'éditeur redessiner la carte à chaque fois, cela n'aidait pas beaucoup.
La « Machinerie » était inutile : Les gadgets spéciaux qu'ils avaient ajoutés (la porte de stabilité, le compteur d'étapes, le mélange des pensées passées) se sont avérés être principalement décoratifs. Les retirer n'a pas beaucoup affecté les performances.
Le vrai problème : Le problème principal était le partage des mêmes poids. L'idée que « un éditeur faisant six passages » soit aussi bon que « six éditeurs différents » n'a tout simplement pas tenu. Les poids partagés constituaient un goulot d'étranglement. La conception « hétérogène » (mélangeant pré-éditeurs, une ancre gelée et un éditeur en boucle) était simplement trop complexe et moins efficace qu'une pile simple et uniforme d'éditeurs.

Résumé en une phrase

CART est une idée ingénieuse et économe en mémoire qui tente de faire « réfléchir » de manière répétée un seul bloc d'IA en utilisant une carte de référence gelée, mais en fin de compte, il s'avère qu'avoir une équipe de spécialistes uniques (le modèle standard) fonctionne toujours mieux qu'un spécialiste tournant en boucle, et les gadgets supplémentaires ajoutés pour stabiliser la boucle étaient largement inutiles.

Le point clé pour l'avenir :
L'article conclut que, bien que l'« ancre gelée » économise de la puissance de calcul, la promesse d'obtenir des gains d'intelligence massifs en faisant simplement boucler un bloc de code partagé n'a pas porté ses fruits à cette échelle. L'architecture est stable et intéressante, mais elle n'a pas battu l'approche standard en termes de performance brute par dollar investi.

Résumé technique : CART (Context-Anchored Recurrent Transformer)

Énoncé du problème

Le paradigme dominant de la modélisation du langage, le transformer empilé, fait croître le nombre de paramètres de manière linéaire avec la profondeur ( $L$ couches uniques), ce qui crée des goulots d'étranglement de mémoire pour le déploiement sur du matériel contraint. Les transformers à profondeur récurrente (ou en boucle) tentent de remédier à cela en réutilisant un ensemble unique de paramètres sur plusieurs passages ( $R$ ) à travers un bloc partagé. Cependant, le partage de poids naïf est souvent moins performant qu'un modèle à profondeur unique correspondante, car un bloc unique appliqué de manière identique ne peut pas adapter son comportement au cours des itérations de la boucle. Des solutions antérieures, telles que les hyper-connexions, les plongements d'index de boucle ou les contraintes de stabilité explicites, ont tenté d'atténuer ce problème, mais une lacune architecturale critique subsiste : la plupart des architectures concurrentes (par exemple, Hyperloop, Parcae, OpenMythos) recomputent les représentations clé-valeur (K, V) à partir de l'état caché évolutif à chaque itération, échouant ainsi à séparer l'encodage du contexte du raffinement itératif.

Méthodologie : Architecture CART

CART introduit une architecture efficace en paramètres qui réutilise un bloc central unique partagé $R$ fois à travers la profondeur, se distinguant par trois contributions architecturales spécifiques :

Ancre KV calculée une seule fois : Contrairement aux travaux précédents qui recomputent K et V à chaque étape de la boucle, CART calcule K et V une seule fois à partir d'un « prélude » multi-couches (un ensemble unique de $P$ couches de transformer) et les maintient fixes. Le cœur récurrent effectue ensuite une attention croisée contre ces tenseurs gelés. Cela sépare l'encodage du contexte (prélude) du raffinement itératif (cœur), réduisant les FLOPs par boucle en élimin la redondance des projections KV.
Stabilité apprise via LTI à porte sigmoïde : Pour garantir la convergence du calcul récurrent, CART emploie une porte LTI (système invariant dans le temps) apprise : $h_{\ell} = \sigma(a) \odot h_{in} + f_{transformer}(h)$ . Contrairement aux contraintes architecturales (par exemple, la discrétisation par maintien d'ordre zéro) utilisées dans d'autres travaux, cette porte apprend son taux de convergence (rayon spectral $\varrho$ ) directement à partir des données, garantissant $\varrho < 1$ sans rigidité structurelle.
Contrainte d'attention croisée causale : L'article identifie une contrainte critique pour les modèles récurrents autorégressifs : l'attention croisée du cœur vers le prélude doit être causale. Une attention non causale laisse fuiter les jetons futurs (du contexte du prélude) dans l'état récurrent, provoquant l'effondrement de la perte (loss collapse).

L'architecture suit une topologie « prélude $\to$ ancre $\to$ cœur $\to$ coda ». Le prélude ( $P$ couches uniques) génère l'ancre de contexte $e$ . Le cœur (poids partagés, $R$ itérations) raffine l'état en utilisant les K, V gelés de $e$ . Une couche « coda » unique produit les logits finaux.

Configuration expérimentale

Les auteurs ont évalué CART en deux étapes sur des GPU de classe grand public (RTX 3050 et RTX 3090) en utilisant un corpus à passage unique de $\sim$ 1 milliard de jetons (TinyStories, Wikipedia, FineWeb-Edu).

Étape 1 : Un criblage d'hyperparamètres de 64 configurations ( $d \in \{256, 512, 768, 1024\}$ , $R \in \{2, 4, 6, 8\}$ , $P \in \{2, 3, 4, 6\}$ ) entraîné pendant 3 000 étapes ( $\sim$ 49M de jetons).
Étape 2 : Entraînement complet de 36 configurations ( $P=6$ , $R \in \{6, 8, 10\}$ , 3 graines chacune) pendant 30 500 étapes ( $\sim$ 1 milliard de jetons).
Baselines : À l'échelle de liaison ( $d=1024$ ), CART a été comparé à des transformers denses appariés à la fois sur les paramètres stockés (7 couches) et les paramètres effectifs (12 couches).

Résultats clés

1. Stabilité et rayon spectral

À travers les 36 configurations de l'Étape 2, le rayon spectral $\varrho$ de la porte LTI apprise s'est stabilisé dans une bande étroite de $[0,79, 0,83]$ . Cette valeur n'est pas une cible de conception fixe mais émerge de l'entraînement. $\varrho$ augmente de manière monotone avec la largeur du modèle ( $d$ ) et faiblement avec le nombre de boucles ( $R$ ). Le $\varrho \approx 0,893$ « universel » observé à l'Étape 1 a été identifié comme un transitoire de milieu d'entraînement qui décroît lors de l'entraînement complet.

2. L'inversion du bénéfice de la récurrence ( $R$ )

Une découverte critique est l'inversion des tendances entre l'Étape 1 et l'Étape 2 :

Étape 1 (3k étapes) : Suggérait que la profondeur de récurrence ( $R$ ) devient plus précieuse à mesure que la largeur du modèle ( $d$ ) augmente, avec $R=8$ surpassant significativement $R=2$ à $d=1024$ .
Étape 2 (30,5k étapes) : Cette tendance s'est inversée. Lors de l'entraînement complet, $R=6$ était la meilleure configuration pour toutes les échelles $d \ge 512$ . Augmenter $R$ à 8 ou 10 entraînait une dégradation des performances (régression allant jusqu'à 1 % sur la perplexité).
Mise à l'échelle de l'inférence : L'inférence à $R$ variable sur le meilleur modèle $d=1024$ (entraîné à $R=6$ ) a montré que l'exécution de plus d'itérations que celles de l'entraînement dégradait systématiquement les performances sur HellaSwag, LAMBADA et PIQA. Cela indique un résultat négatif clair pour la mise à l'échelle du calcul au moment du test sous la recette d'entraînement actuelle.

3. Revendications d'efficacité des paramètres

À l'échelle de liaison ( $d=1024$ , $\sim$ 1 milliard de jetons) :

Parité des paramètres stockés : Un modèle dense à 7 couches (apparié aux paramètres stockés de CART) a surpassé CART ( $P=6, R=6$ ) de 1 à 2 % sur les métriques de perplexité.
Parité des paramètres effectifs : Un modèle dense à 12 couches (apparié aux paramètres effectifs de CART) a surpassé CART d'environ 10 % sur les ensembles de langage naturel.
Conclusion : L'hypothèse selon laquelle la récurrence à poids partagés fournit une capacité effective $R$ fois supérieure n'a pas tenu à cette échelle et ce budget d'entraînement.

4. Ablations diagnostiques

Les auteurs ont décomposé l'écart de performance entre la baseline Dense et CART :

K, V gelés : Le dégel de K, V (recalcul de ceux-ci à chaque étape) n'a pas amélioré significativement les performances, excluant l'ancre gelée comme principal goulot d'étranglement.
Profondeur de récurrence : Réduire $R$ à 1 (suppression de la récurrence) n'a causé qu'une chute de $\sim$ 1 %, suggérant que le cœur récurrent contribue marginalement au-delà de la première itération.
Poids partagés : Le fait de ne pas partager les poids du cœur (donner à chaque itération des paramètres uniques) a amélioré les performances d'environ 5 %, confirmant que le partage de poids est un goulot d'étranglement de capacité important.
Composants de la machinerie : Les ablations de l'HyperConnection, de la porte LTI et du Loop Index Embedding (LIE) ont montré qu'ils sont vestigiels dans la configuration à poids partagés ; les supprimer individuellement n'a eu aucun effet mesurable sur la perplexité.
Écart résiduel : L'écart restant de $\sim$ 5 % par rapport à la baseline Dense est attribué au cadrage hétérogène « prélude $\to$ ancre $\to$ cœur $\to$ coda » lui-même, plutôt qu'à un mécanisme spécifique.

Signification et revendications

L'article présente CART comme une investigation empirique rigoureuse des transformers à profondeur récurrente, offrant trois contributions principales :

Distinction architecturale : CART est le premier de sa famille à calculer K, V une seule fois à partir d'un prélude et à les réutiliser comme une ancre gelée, séparant l'encodage du contexte du raffinement.
Stabilité apprise : Il démontre qu'un filtre LTI à porte sigmoïde peut apprendre un taux de convergence stable ( $\varrho \in [0,79, 0,83]$ ) sans contraintes structurelles, s'adaptant à la largeur du modèle et au nombre de boucles.
Réalité empirique : L'article fournit un « résultat négatif clair » concernant l'efficacité des paramètres de la récurrence à poids partagés à l'échelle testée. Il démontre que :
- Le bénéfice de la profondeur de récurrence ( $R$ ) ne croît pas nécessairement avec la largeur du modèle ( $d$ ) lors de l'entraînement complet ; en fait, il peut s'inverser.
- La mise à l'échelle du calcul au moment du test (augmenter $R$ lors de l'inférence) est préjudiciable si elle n'est pas assortie de l'entraînement.
- La thèse du « levier de poids partagés » (que $R$ itérations d'un bloc partagé équivalent à $R$ couches uniques) échoue à $d=1024$ avec $\sim$ 1 milliard de jetons, l'architecture perdant face à une baseline Dense aux paramètres appariés.

Les auteurs concluent que bien que CART offre une latence déterministe et une utilisation de la mémoire fixe (bénéfique pour le déploiement), sa formulation actuelle ne délivre pas l'efficacité de paramètres requise pour surpasser les transformers denses standards à l'échelle testée. Les résultats suggèrent que le cadrage architectural hétérogène et le partage de poids sont les principaux goulots d'étranglement, et non la machinerie de récurrence spécifique (HyperConnection, LTI, LIE).