🤖 machine learning

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

Het artikel introduceert CART, een parameter-efficiënt taalmodel dat een enkel kernblok hergebruikt via geleerde stabiliteitsmechanismen, maar stelt vast dat hoewel de diepte van de prelude de prestaties domineert, de architectuur uiteindelijk onderpresteert ten opzichte van met parameters overeenkomende dichte baselines en faalt in het ondersteunen van effectieve dieteschaling tijdens de testtijd.

Oorspronkelijke auteurs: Chad A. Capps

Gepubliceerd 2026-06-02

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Chad A. Capps

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Het Grote Idee: Een "Lussen" Taalmodel

Stel je voor dat je een verhaal probeert te schrijven. De standaard manier waarop AI dit doet (een Transformer genoemd), is als het inhuren van een team van 12 verschillende redacteuren. Redacteur 1 leest de eerste zin, Redacteur 2 leest wat Redacteur 1 heeft geschreven, Redacteur 3 leest wat Redacteur 2 heeft geschreven, enzovoort. Elke redacteur heeft zijn eigen unieke stijl en aantekeningen. Dit werkt goed, maar het is duur omdat je voor 12 verschillende mensen moet betalen.

CART (Context-Anchored Recurrent Transformer) probeert een andere aanpak. Het huurt slechts één redacteur in en vraagt diegene om het verhaal zes keer te lezen (of vaker).

Het Doel: Dezelfde kwaliteit van schrijven krijgen, maar met een veel kleiner team (minder parameters), wat geld en geheugen bespaart.
De Haken en Ogen: Als je dezelfde persoon zes keer hetzelfde laat lezen, kan diegene zich vervelen en dezelfde fouten gaan herhalen. De uitdaging is om die enkele redacteur bij elke ronde slimmer te laten worden zonder nieuwe mensen nodig te hebben.

Hoe CART Werkt: Het "Anker" en de "Poort"

CART heeft drie speciale trucs om dit lussen werkend te krijgen:

Het "Anker" (De Bevroren Kaart):
- Standaard Lussen: In andere lussenmodellen tekent de redacteur elke keer dat hij het verhaal leest, de kaart van waar de belangrijke woorden staan opnieuw. Dit is traag en redundant.
- De Manier van CART: Voordat het lussen begint, leest een klein team van "pre-redacteuren" (de Prelude) het verhaal één keer en tekent een perfecte, gedetailleerde kaart van de belangrijke woorden. Deze kaart is bevroren.
- De Lus: De enkele lussen-redacteur kijkt vervolgens elke keer dat hij het verhaal leest naar deze zelfde, bevroren kaart. Hij tekent de kaart niet opnieuw; hij gebruikt hem als een stabiel anker om zijn begrip te verfijnen. Dit bespaart veel rekenkracht.
De "Poort" (De Stabiliteitsschakelaar):
- Het Probleem: Als je iemand keer op keer over hetzelfde onderwerp laat nadenken, kan diegene in de war raken of beginnen te hallucineren (gek worden).
- De Oplossing van CART: Er is een "poort" die regelt hoeveel van de vorige gedachte de redacteur behoudt. Het is als een volumeknop. Als de redacteur te chaotisch wordt, draait de poort het volume iets zachter.
- De Ontdekking: De paper vond dat deze poort leert te landen op een heel specifiek "sweet spot" (een getal tussen 0,79 en 0,83). Dit is niet opgelegd door de ingenieurs; de AI heeft deze specifieke instelling zelf geleerd om stabiel te blijven.
De "Loop Index" (De Stapenteller):
- De redacteur krijgt een teller (1, 2, 3...) zodat hij weet welke ronde hij aan het maken is. Dit helpt hem te weten of hij zich in de vroege stadia van het denken bevindt of in de laatste afwerking.

De Experimenten: Wat Er Gebeurde

De onderzoekers testten dit op een enkele consumenten-grafische kaart (zoals een high-end gaming PC) met behulp van twee fasen van training.

Fase 1: De Snelle Test (De "Hunch")

Ze trainden veel kleine versies van CART snel.
De Hunch: Ze dachten dat voor grotere, complexere modellen, het vaker lussen (bijv. 8 keer in plaats van 6) veel beter zou zijn. Het leek alsover: "meer lussen = slimmere AI."

Fase 2: De Volledige Training (De "Reality Check")

Ze trainden de modellen veel langer (met ongeveer 1 miljard woorden tekst).
De Verrassing: De hunch klopte niet. Toen ze de modellen volledig trainden, maakte het meer vaak lussen de model zelfs iets slechter of helemaal niet beter.
De Analogie: Stel je voor dat je een student vraagt om een hoofdstuk uit een tekstboek 10 keer te lezen. In een snelle test lijkt 10 keer geweldig. Maar na een heel semester studeren besef je dat 6 keer lezen genoeg is. Het 8 of 10 keer lezen leidt alleen maar tot verminderde meeropbrengst of zelfs verwarring. Het model leerde dat "meer lussen" niet gelijk stond aan "meer intelligentie" in deze specifieke opstelling.

Het Grote Eindoordeel: Heeft Het Gewonnen?

De onderzoekers vergeleken hun "Eén Redacteur, Zes Lussen" model met een standaard "Zes Verschillende Redacteuren" model (een Dense Transformer) dat evenveel geheugen gebruikte.

Het Resultaat: Het standaard model (6 verschillende redacteuren) versloeg het CART-model.
- Het standaard model was ongeveer 10% beter in het begrijpen van taal.
- Zelfs toen ze het standaard model dezelfde "effectieve" kracht gaven (door het 12 redacteuren lang te maken), verpletterde het nog steeds CART.

Waarom verloor CART?
De onderzoekers deden een "autopsie" (diagnostische ablaties) om te ontdekken waarom:

De Bevroren Kaart was niet het probleem: Zelfs als ze de redacteur de kaart elke keer opnieuw lieten tekenen, hielp dat niet veel.
De "Machinerie" was nutteloos: De speciale gadgets die ze toevoegden (de stabiliteitspoort, de stapenteller, het mengen van eerdere gedachten) bleken grotendeks decoratief te zijn. Het verwijderen ervan schaadde de prestaties nauwelijks.
Het Echte Probleem: Het hoofdzakelijke probleem was het delen van dezelfde gewichten. Het idee dat "één redacteur die zes rondes doet" net zo goed is als "zes verschillende redacteuren", hield simpelweg geen stand. De gedeelde gewichten vormden een bottleneck. Het "heterogene" ontwerp (het mixen van pre-redacteuren, een bevroren anker en een lussen-redacteur) was gewoon te complex en minder efficiënt dan een simpele, uniforme stapel redacteuren.

Samenvatting in één zin

CART is een slim, geheugenefficiënt idee dat probeert een enkel AI-blok herhaaldelijk te laten "denken" door een bevroren referentiekaart te gebruiken, maar uiteindelijk blijkt dat het hebben van een team van unieke specialisten (het standaard model) nog steeds beter werkt dan één specialist die rondjes draait, en de extra gadgets die werden toegevoegd om het lussen stabiel te maken waren grotendeels overbodig.

Belangrijkste les voor de toekomst:
De paper concludeert dat hoewel het "bevroren anker" wat rekenkracht bespaart, de belofte dat het simpelweg lussen van een gedeelde blok code enorme intelligentiewinsten zou opleveren, op deze schaal niet is uitgekomen. De architectuur is stabiel en interessant, maar het versloeg de standaard aanpak niet in termen van pure prestatie per dollar.

Technische Samenvatting: CART (Context-Anchored Recurrent Transformer)

Probleemstelling

Het dominante paradigma in taalmodellering, de gestapelde transformer, schaalt het aantal parameters lineair met de diepte ( $L$ unieke lagen), wat zorgt voor geheugenbottlenecks bij implementatie op beperkte hardware. Diepte-recurrente (of geloopte) transformers proberen dit aan te pakken door een enkele set parameters hergebruiken over meerdere passes ( $R$ ) door een gedeelde blok. Naïeve gewichtsdeling presteert echter vaak minder goed dan modellen met unieke diepte, omdat een enkel blok dat identiek wordt toegepast, zijn gedrag niet kan aanpassen over de loop-iteraties heen. Eerdere oplossingen, zoals hyper-verbindingen, loop-index embeddings en expliciete stabiliteitsrestricties, hebben geprobeerd dit te verzachten, maar er blijft een kritische architecturale kloof bestaan: de meeste gelijktijdige geloopte architecturen (bijv. Hyperloop, Parcae, OpenMythos) berekenen key-value (K, V) representaties opnieuw vanuit de evoluerende verborgen staat bij elke iteratie, waardoor ze het scheiden van context-codering van iteratieve verfijning verwaarlozen.

Methodologie: CART Architectuur

CART introduceert een parameter-efficiënte architectuur die een enkele gedeelde kernblok $R$ keer hergebruikt over de diepte, onderscheiden door drie specifieke architecturale bijdragen:

Eénmalig berekende KV-anker: In tegenstelling tot eerdere werken die K en V bij elke loopstap opnieuw berekenen, berekent CART K en V éénmaal vanuit een multi-laag "prelude" (een unieke set van $P$ transformer lagen) en houdt deze vast. De recurrente kern voert vervolgens cross-attention uit tegen deze bevroren tensoren. Dit scheidt context-codering (prelude) van iteratieve verfijning (core), wat per-loop FLOPs vermindert door redundante KV-projecties te elimineren.
Geleerde Stabiliteit via Sigmoid-Gated LTI: Om te garanderen dat de recurrente berekening convergeert, gebruikt CART een geleerde Lineaire Tijdsinvariante (LTI) gate: $h_{\ell} = \sigma(a) \odot h_{in} + f_{transformer}(h)$ . In tegen tegenstelling tot architecturale restricties (bijv. zero-order hold discretisatie) die in andere werken worden gebruikt, leert deze gate zijn convergentiesnelheid (spectrale radius $\varrho$ ) direct van de data, wat garandeert dat $\varrho < 1$ zonder structurele rigiditeit.
Causale Cross-Attention Constraint: Het papier identificeert een cruciale restrictie voor autoregressieve recurrente modellen: cross-attention van de core naar de prelude moet causaal zijn. Niet-causale attention laat toekomstige tokens (uit de context van de prelude) in de recurrente staat lekken, wat leidt tot loss-collaps.

De architectuur volgt een "prelude $\to$ anchor $\to$ core $\to$ coda" topologie. De prelude ( $P$ unieke lagen) genereert de context-anker $e$ . De core (gedeelde gewichten, $R$ iteraties) verfijnt de staat met behulp van de bevroren K, V van $e$ . Een enkele unieke "coda" laag produceert de uiteindelijke logits.

Experimentele Opstelling

De auteurs evalueerden CART in twee stadia op consumenten-GPU's (RTX 3050 en RTX 3090) met een single-pass corpus van $\sim$ 1B tokens (TinyStories, Wikipedia, FineWeb-Edu).

Stadium 1: Een hyperparameter screen van 64 configuraties ( $d \in \{256, 512, 768, 1024\}$ , $R \in \{2, 4, 6, 8\}$ , $P \in \{2, 3, 4, 6\}$ ) getraind voor 3.000 stappen ( $\sim$ 49M tokens).
Stadium 2: Volledige training van 36 configuraties ( $P=6$ , $R \in \{6, 8, 10\}$ , 3 seeds elk) voor 30.500 stappen ( $\sim$ 1B tokens).
Baselines: Bij de bindingsschaal ( $d=1024$ ) werd CART vergeleken met Dense transformers die gematcht waren op zowel opgeslagen parameters (7-laags) als effectieve parameters (12-laags).

Belangrijkste Resultaten

1. Stabiliteit en Spectrale Radius

Over alle 36 Stadium 2 configuraties stabiliseerde de spectrale radius $\varrho$ van de geleerde LTI gate zich in een smalle band van $[0.79, 0.83]$ . Deze waarde is geen vast ontwerpdoel maar ontstaat uit de training. $\varrho$ stijgt monotoon met de modelbreedte ( $d$ ) en zwak met het aantal loops ( $R$ ). De "universele" $\varrho \approx 0.893$ waargenomen in Stadium 1 werd geïdentificeerd als een transiënte fase tijdens de training die afneemt tijdens de volledige training.

2. De Omkering van de Recurrente Voordelen ( $R$ )

Een cruciale bevinding is de omkering van trends tussen Stadium 1 en Stadium 2:

Stadium 1 (3k stappen): Suggeerde dat de diepte van de recursie ( $R$ ) waardevoller wordt naarmate de modelbreedte ( $d$ ) toeneemt, waarbij $R=8$ significant beter presteerde dan $R=2$ bij $d=1024$ .
Stadium 2 (30.5k stappen): Deze trend keerde om. Bij volledige training was $R=6$ de beste configuratie voor alle schalen $d \ge 512$ . Het verhogen van $R$ naar 8 of 10 resulteerde in prestatievermindering (tot 1% regressie op perplexiteit).
Inference Scaling: Variable- $R$ inference op het beste $d=1024$ model (getraind bij $R=6$ ) toonde aan dat het draaien van meer iteraties dan getraind, consequent de prestaties verslechterde op HellaSwag, LAMBADA en PIQA. Dit duidt op een helder negatief resultaat voor de rekenkracht-schaling (compute scaling) tijdens de testfase onder het huidige trainingsrecept.

3. Claims over Parameter-efficiëntie

Bij de bindings-test ( $d=1024$ , $\sim$ 1B tokens):

Opgeslagen-Parameter Pariteit: Een Dense 7-laags model (gematcht aan CART's opgeslagen parameters) presteerde 1–2% beter dan CART ( $P=6, R=6$ ) op perplexiteit-metrieken.
Effectieve-Parameter Pariteit: Een Dense 12-laags model (gematcht aan CART's effectieve parameters) presteerde $\sim$ 10% beter dan CART op natuurlijke taal-sets.
Conclusie: De hypothese dat gewichtsdeling-recursie $R$ -voudige effectieve capaciteit biedt, hield niet stand bij deze schaal en trainingsbudget.

4. Diagnostische Ablaties

De auteurs deconstrueerden de prestatiekloof tussen de CART en de Dense baseline:

Bevroren K, V: Het ongefixeerd maken van K, V (het opnieuw berekenen ervan bij elke stap) verbeterde de prestaties niet significant, wat de bevroren anker als de primaire bottleneck uitsluit.
Recurrente Diepte: Het reduceren van $R$ naar 1 (verwijderen van recursie) veroorzaakte slechts een $\sim$ 1% daling, wat suggereert dat de recurrente core marginaal bijdraagt voorbij de eerste iteratie.
Gedeelde Gewichten: Het niet delen van de core-gewichten (elke iteratie unieke parameters geven) verbeterde de prestaties met $\sim$ 5%, wat bevestigt dat gewichtsdeling een significante capaciteitsbottleneck is.
Machinerie Componenten: Ablaties van de HyperConnection, LTI gate en de Loop Index Embedding (LIE) toonden aan dat deze vestigiaal zijn in de gedeelde-gewicht configuratie; het individueel verwijderen ervan had geen meetbaar effect op de perplexiteit.
Residuele Kloof: De resterende $\sim$ 5% kloof tot de Dense baseline wordt toegeschreven aan de heterogene "prelude $\to$ anchor $\to$ core $\to$ coda" inkadering zelf, in plaats aan een specifieke mechanisme.

Betekenis en Claims

Het papier claimt CART als een rigoureuze empirische onderzoek naar diepte-recurrente transformers, met drie hoofdbijdragen:

Architecturaal Onderscheid: CART is de eerste in zijn familie die K, V éénmaal berekent vanuit een prelude en deze hergebruikt als een bevroren anker, waardoor context-codering wordt gescheiden van verfijning.
Geleerde Stabiliteit: Het demonstreert dat een sigmoid-gated LTI-filter een stabiele convergentieratio ( $\varrho \in [0.79, 0.83]$ ) kan leren zonder structurele restricties, aanpasend aan modelbreedte en loop-aantal.
Empirische Realiteitscheck: Het papier biedt een "helder negatief resultaat" met betrekking tot de parameter-efficiëntie van gedeelde-gewicht recursie op de geteste schaal. Het demonstreert dat:
- Het voordeel van de recursie-diepte ( $R$ ) niet noodzakelijkerwijs groeit met de modelbreedte bij volledige training; het kan zelfs omkeren.
- Test-time compute scaling (het verhogen van $R$ tijdens inference) nadelig is als dit niet overeenkomt met de training.
- De "shared-weight leverage" thesis (dat $R$ iteraties van een gedeeld blok gelijk zijn aan $R$ unieke lagen) faalt bij $d=1024$ met $\sim$ 1B tokens, waarbij de architectuur verliest van een parameter-gematchte Dense baseline.

De auteurs concluderen dat hoewel CART een deterministische latentie en vast geheugengebruik biedt (gunstig voor implementatie), de huidige formulering niet de vereiste parameter-efficiëntie levert om standaard Dense transformers op de geteste schaal te overtreffen. De bevindingen suggereren dat de heterogene architecturale inkadering en gewichtsdeling de primaire bottlenecks zijn, en niet de specifieke recursie-machinerie (HyperConnection, LTI, LIE).