💬 NLP

ZetaGPT: A Reference Implementation of Positional--Encoding--Free State--Space--Attention Language Models

Dit artikel introduceert ZetaGPT, een open-source klein taalmodel dat expliciete positionele coderingen elimineert door causale state-space-vergelijkingen te integreren om sequentiële informatie impliciet te coderen vóór de self-attention, terwijl het een volledige end-to-end trainingspipeline biedt voor onderzoeks- en educatieve doeleinden.

Oorspronkelijke auteurs: Róisín Luo

Gepubliceerd 2026-08-11

📖 7 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Róisín Luo

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

Stel je voor dat je een robot probeert te leren een verhaal te lezen. Lange tijd was de beste manier om dit te doen een robot een speciale "sticker" geven voor elk woord dat het las. Als de robot het woord "kat" zag, zou het weten dat het het eerste woord was omdat het een "Eerste Woord"-sticker had, en als het later het woord "hond" zag, zou het een "Vijfde Woord"-sticker hebben. Zonder deze stickers zou de robot in de war raken en denken dat "De kat jaagde de hond na" hetzelfde was als "De hond jaagde de kat na", omdat de woorden slechts een rommelige verzameling ingrediënten waren. Deze methode van het plakken van labels op woorden wordt "positional encoding" genoemd, en het is de standaardregelboek geworden voor bijna elk slim taalmodel dat we vandaag de dag gebruiken.

Maar wat als de robot helemaal geen stickers nodig had? Wat als de robot, in plaats van naar een label te kijken, de volgorde van het verhaal simpelweg zou kunnen voelen terwijl hij het leest? Dat is de grote vraag die dit artikel stelt. Het onderzoekt een nieuwe manier om taalmodellen te bouwen die niet afhankelijk zijn van die externe stickers. In plaats daarvan gebruikt het een "geheugenlus" die zichzelf bijwerkt terwijl het leest, waardoor het vanzelf onthoudt wat eraan voorafging. Dit is belangrijk omdat als we modellen kunnen bouwen die volgorde begrijpen zonder dat ze expliciet verteld hoeven te worden waar elk woord zich bevindt, we ze slimmer, efficiënter en beter kunnen maken in het afhandelen van zeer lange verhalen zonder de draad kwijt te raken.

Het Grote Idee van het Papier: ZetaGPT

De auteur van dit artikel introduceert ZetaGPT, een klein, open-source taalmodel dat precies dat probeert te doen: het leest zonder stickers. De belangrijkste bevinding is dat door een speciale "causale state-space module" direct vóór het aandachtmechanisme van het model te plaatsen, het model de volgorde van woorden impliciet kan leren via zijn eigen interne dynamiek.

Denk aan een standaard taalmodel als een student die een toets maakt waarbij hij een referentieblad (de positional encoding) mag inzien waarop staat: "Vraag 1", "Vraag 2", enzovoort. ZetaGPT is als een student die volledig moet vertrouwen op zijn geheugen van het verhaal tot nu toe. Terwijl de student elk woord leest, verandert zijn interne staat, wat een unieke "vingerafdruk" creëert voor dat moment in het verhaal. Het artikel suggereert dat deze interne vingerafdruk voldoende is om het model te vertellen: "Hé, dit woord komt na dat andere woord," zonder dat er externe hulp nodig is.

Hoe het Werkt: De Geheugenlus

Om te begrijpen hoe ZetaGPT dit voor elkaar krijgt, stel je een estafette voor. In een normale race wordt de stok overgedragen en rent iedereen gewoon door. In de versie van ZetaGPT draagt de loper (het model) een speciale rugzak (de state-space module) die van vorm en gewicht verandert afhankelijk van waar hij net langs is gerend.

De Rugzak (State-Space Module): Voordat het model naar de hele zin kijkt om verbindingen te begrijpen (een proces dat "self-attention" wordt genoemd), haalt het eerst de woorden door deze rugzak. De rugzak is een "recurrent" systeem, wat betekent dat het het verleden onthoudt. Terwijl elk nieuw woord binnenkomt, werkt de rugzak zijn interne staat bij op basis van de voorgaande woorden.
De Evolutie: Het artikel laat zien dat de rugzak, terwijl het model traint, leert om verschillende "geheugenhorizonten" te ontwikkelen. Sommige delen van de rugzak onthouden slechts de laatste paar woorden (kortetermijngeheugen), terwijl andere een lang stuk van het verhaal onthouden (langetermijngeheugen).
Het Resultaat: Tegen de tijd dat het woord de rugzak verlaat en de hoofd-attentionlaag binnenkomt, is het niet langer slechts een rauw woord; het is een "positie-bewust" woord. Het draagt de geschiedenis met zich mee van waar het zich in de zin bevond. Het artikel merkt op dat het model tijdens de training natuurlijk leert om deze verschillende geheugensnelheden te gebruiken om de sequentie te coderen, waardoor de noodzaak voor de "stickers" (positional encodings) die andere modellen gebruiken, effectief wordt vervangen.

Wat het Papier Uitsluit en Vindt

Het artikel spreekt zich expliciet uit tegen het idee dat we moeten gebruikmaken van expliciete positional encodings (zoals de eerder genoemde "stickers") om een werkend taalmodel te bouwen. Het verwerpt het concept dat positionele informatie een "architecturaal verworven capaciteit" moet zijn die van buitenaf wordt geïnjecteerd. In plaats daarvan stelt het voor dat deze informatie een "inherente eigenschap" kan zijn van de eigen dynamiek van het model.

De auteur heeft vastgesteld dat ZetaGPT werkt. Er zijn drie versies van het model getraind (Small, Medium en Large) met respectievelijk 34,4 miljoen, 159,2 miljoen en 479,9 miljoen parameters. Ze hebben aangetoond dat deze modellen het volgende woord in een zin kunnen voorspellen zonder ooit een positional encoding te hebben gekregen.

Het artikel is echter voorzichtig in zijn zelfvertrouwen. Het beweert niet het probleem van taalmodellering te hebben "opgelost" of dat ZetaGPT beter is dan de enorme modellen die door grote techbedrijven worden gebruikt. Sterker nog, de auteur geeft toe dat hun modellen klein zijn en zijn getraind op een relatief bescheiden dataset (de WikiText-103 corpus). Er wordt opgemerkt dat omdat de modellen klein zijn, ze alleen getraind zijn op korte contexten (256, 512 en 1024 tokens). Het artikel suggereert dat hoewel de architectuur werkt op deze kleine schaal, we nog niet weten of het ook even goed zal werken voor de gigantische modellen die miljoenen woorden tegelijk lezen.

De Volledige Reis: Van Af aan tot Redeneren

Een van de meest speelse en complete onderdelen van dit artikel is dat het niet alleen het model laat zien, maar ook het hele "recept" voor het bouwen ervan. De auteur biedt een volledige, open-source pijplijn die je van ruwe tekst naar een model brengt dat kan redeneren.

De Tokenizer: Eerst bouwden ze een "tokenizer" (een vertaler die tekst in getallen omzet) vanaf de basis, beginnend met ruwe bytes en het samenvoegend tot een vocabulaire van 50.259 symbolen.
De Training: Ze hebben het model voorgetraind, daarna gefinetuned om instructies op te volgen, en zelfs een "reward model" getraind om de AI te helpen leren van menselijke feedback (RLHF).
Het "Aha"-moment: Ten slotte gebruikten ze een techniek genaamd Group Relative Policy Optimization (GRPO) om het model "Chain-of-Thought" redeneren te leren. Dit is het deel waarbij het model leert om stap voor stap te denken, zoals een mens een wiskundig probleem oplost, zonder dat de stappen vooraf expliciet zijn getoond. Het artikel suggereert dat deze redeneercapaciteit direct kan "emergeren" door middel van reinforcement learning.

De Beperkingen

De auteur is zeer eerlijk over de grenzen van hun werk. Er wordt gesteld dat de belangrijkste beperkingen te wijten zijn aan de computationele middelen die zij hadden, en niet aan een fout in het idee zelf. Omdat ze geen toegang hadden tot supercomputers met oneindige kracht, konden ze niet trainen op de enorme datasets (biljoenen tokens) die moderne reuzen gebruiken. Bijgevolg hebben hun modellen niet de enorme wereldkennis van die grotere systemen.

Ze wijzen ook erop dat omdat ze niet op zeer lange teksten konden trainen, ze niet volledig hebben getest of deze "no-sticker" benadering ook werkt voor extreem lange verhalen. Het artikel concludeert dat ZetaGPT een "compacte referentie-implementatie" is: een bewijs van concept en een speeltuin voor onderzoekers om te bestuderen hoe positionele informatie impliciet geleerd kan worden, in plaats van een afgewerkt product dat klaar is om de grootste AI-modellen van de wereld te vervangen.

Kortom, ZetaGPT is een kleine, sticker-vrije robot die bewijst dat je een machine kunt leren de volgorde van een verhaal te begrijpen door het simpelweg de reis te laten onthouden, één woord per keer. Het is een kleine stap, maar het opent een nieuwe deur voor hoe we de volgende generatie taalmodellen kunnen bouwen.

Technische Samenvatting: ZetaGPT

Probleemstelling

Transformer-gebaseerde grote taalmodellen (LLM's) vertrouwen op zelf-aandachtsmechanismen die inherent permutatie-equivariant zijn, wat betekent dat ze een intrinsiek gebrek hebben aan het vermogen om de volgorde van tokens te representeren. Bijgevolg moeten bestaande architecturen positionele informatie expliciet injecteren via geleerde embeddings of handmatig vervaardigde coderingen (bijv. sinusvormig, RoPE). Hoewel deze methoden effectief zijn, behandelen ze positionele informatie als een extern architecturaal component in plaats van een inherente eigenschap van het model. Deze afhankelijkheid creëert uitdagingen voor contextextensie, waarbij vaak specifieke aanpassingen aan het coderingsmechanisme vereist zijn (bijv. interpolatie of schaling) in plaats van dat dit natuurlijk voortvloeit uit de dynamiek van het model. Recente ontwerpfilosofieën zijn verschoven naar architecturen zonder positiecodering, waarbij sequentiële informatie impliciet ontstaat door computationele dynamiek, maar open-source, compacte referentie-implementaties voor dergelijke modellen blijven schaars.

Methodologie

ZetaGPT introduceert een hybride State–Space–Attention (SSA) architectuur die is ontworpen om positionele informatie impliciet te coderen vóór de zelf-aandachtscomputatie. De kernmethodologie bestaat uit de volgende componenten:

1. Architecturaal Ontwerp

Elke Transformer-block in ZetaGPT bestaat uit drie pre-genormaliseerde residuele sub-lagen gerangschikt in een specifieke volgorde:

Causale State-Space Module (SSM): Geplaatst vóór de zelf-aandacht, deze module verwerkt de input via recurrente staat-dynamiek.
Gated Multi-Head Self-Attention: Werkt op de positie-bewuste representaties gegenereerd door de SSM.
Feed-Forward Network (FFN): Voert niet-lineaire feature-transformatie uit.

2. Impliciete Positiecodering via State-Space Dynamiek

Het model maakt gebruik van selectieve state-space vergelijkingen om positie-agnostische token-representaties te transformeren naar positie-bewuste representaties. Gegeven een inputsequentie $\{x_t\}$ , evolueert de verborgen staat $h_t$ recursief:
$h_t = A(x_t)h_{t-1} + B(x_t)x_t$
$y_t = C(x_t)h_t + D(x_t)x_t$

In de implementatie van ZetaGPT:

De state-transitie operator $A(x_t)$ is gedefinieerd als een diagonale matrix met input-afhankelijke vervalcoëfficiënten $a_t = \exp(-\text{softplus}(W_a x_t + b_a))$ .
Het inputpad omvat een projectie, een depthwise causale convolutie en een SiLU-activatie.
De output wordt gestuurd door een input-afhankelijke gate $g_t$ .

Omdat de verborgen staat $h_t$ recursief de causale prefix $\{x_1, \dots, x_t\}$ samenvat, bevatten de resulterende representaties inherent de sequentiële volgorde. Dit stelt de daaropvolgende zelf-aandacht laag in staat om op positie-bewuste data te opereren zonder dat expliciete positiecoderingen nodig zijn.

3. Gated Attention Mechanisme

Om attention sinks en activatie-instorting te beperken, gebruikt ZetaGPT een gated multi-head attention mechanisme. Een input-afhankelijke gate moduleert de attention output vóór projectie, wat de selectiviteit en stabiliteit in pre-layer-genormaliseerde Transformers verbetert.

4. End-to-End Trainingspipeline

ZetaGPT biedt een volledig open-source pipeline die de volgende onderdelen dekt:

Tokenizer: Byte-level Byte-Pair Encoding (BPE) getraind op de pretraining-corpus, resulterend in een vocabulaire van 50.259 tokens.
Pretraining: Getraind op de WikiText-103 corpus.
Supervised Fine-Tuning (SFT): Uitgelijnd met de Alpaca-GPT4 instructie-volgende dataset.
Reinforcement Learning (RLHF): Omvat reward model training en preference optimalisatie.
Chain-of-Thought (CoT): Ontwikkeld via pure reinforcement learning met behulp van Group Relative Policy Optimization (GRPO) op de GSM8K benchmark, wat redeneervermogens mogelijk maakt zonder gesuperviseerde CoT-demonstraties.

Belangrijkste Bijdragen

Positional-Encoding-Free State-Space–Attention Model: ZetaGPT is een compact taalmodel waarbij causale state-space vergelijkingen elke block voorafgaan aan de zelf-aandacht. Dit ontwerp maakt het mogelijk dat de recurrente staat-evolutie impliciet positionele informatie representeert, waardoor de noodzaak voor expliciete positiecoderingen vervalt.
Referentie-implementatie: Naar weten van de auteur is ZetaGPT de eerste open-source kleine taalmodel zonder expliciete positiecodering. Het dient als een compacte, reproduceerbare referentie voor de empirische studie van positional-encoding-vrije architecturen.
Volledige Trainingspipeline: Het werk presenteert een volledige pipeline van datasetconstructie en tokenizer-training tot pretraining, SFT, RLHF en CoT-redeneren via reinforcement learning, wat een verenigde receptuur biedt voor het bouwen van moderne kleine LLM's.

Resultaten en Observaties

Het paper rapporteert over de trainingsdynamiek van de state-space modules tijdens de pretraining (over 12.800 stappen):

Emergentie van Multi-Scale Geheugen: Het model leert meerdere geheugenschaal-tijdsschalen. Ondiepe lagen behouden langere geheugenhorizonten, terwijl intermediaire lagen kortere horizonten ontwikkelen, wat een hiërarchie van temporele representaties creëert.
Input Selectiviteit: De vervalcoëfficiënten worden steeds meer input-afhankelijk, waardoor de geheugenhorizon zich kan aanpassen aan de lokale context.
Residuele Bijdrage: De bijdrage van de state-space module aan de residual stream groeit gedurende de training, wat aangeeft dat het netwerk steeds meer vertrouwt op deze geleerde dynamiek.
Heterogene Kanalen: De vervalverdeling evolueert om zowel long-memory ( $a > 0.99$ ) als short-memory ( $a < 0.5$ ) kanalen te bevatten, wat een automatische organisatie in verschillende temporele bereiken demonstreert.

De modelconfiguraties variëren van ZetaGPT-S (34.4M parameters, 6 lagen) tot ZetaGPT-L (479.9M parameters, 24 lagen). Contextlengtes worden behandeld als trainingsconfiguraties (256, 512, 1024 tokens) in plaats van architecturale beperkingen.

Betekenis en Beperkingen

Betekenis:
ZetaGPT vestigt een compacte, reproduceerbare baseline voor de ontwikkeling van positional-encoding-vrije taalmodellen. Door aan te tonen dat positionele informatie impliciet gerepresenteerd kan worden via architecturale dynamiek in plaats van geïnjecteerde priors, biedt het een nieuwe weg voor onderzoek naar long-context modellering en context extrapolatie die niet afhankelijk is van het modificeren van expliciete coderingsmechanismen.

Beperkingen:
De auteur merkt expliciet op dat beperkingen voortvloeien uit computationele restricties in plaats van de architectuur zelf:

Schaalgrootte van Data: De pretraining-corpus (WikiText-103) is bescheiden en mist de diversiteit en wereldkennis van modellen die getraind zijn op biljoenen tokens.
Model Schaal: De standaardconfiguratie (34.4M parameters) is klein; de geobserveerde dynamiek wordt hier niet direct overdraagbaar naar veel grotere modellen.
Context Lengte: Pretraining is beperkt tot korte contexten (tot 1024 tokens), wat een uitgebreide evaluatie van long-context modellering of extrapolatievermogen verhindert.

Dit werk positioneert ZetaGPT primair als een instrument voor onderzoek, snelle prototyping, algoritmeverificatie en educatie, in plaats van een productie-waardig grootschalig taalmodel.