🤖 AI

A Symbolic Neural CPU for Quantization-Simulated Writeback and Interpretable Program Execution

Dit artikel introduceert een trace-gesuperviseerde symbolische neurale CPU die recurrente controle combineert met een expliciete operatierouter en een differentiële rekenkundig-logische eenheidbank om interpreteerbare, laag-precisie en verifieerbare programma-executie mogelijk te maken door gedetailleerde toestands-transities te ontsluiten en exacte reproductie van referentieseantiek te demonstreren via kwantisatie-gesimuleerde writeback.

Oorspronkelijke auteurs: Jose Luis Lima de Jesus Silva

Gepubliceerd 2026-07-14

📖 6 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Jose Luis Lima de Jesus Silva

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 robotkok hebt die een recept kan volgen om een perfecte taart te maken. Meestal geven we bij het trainen van deze AI-chefs alleen om het feit of de uiteindelijke taart lekker smaakt. Het maakt ons niet uit hoe ze de ingrediënten hebben gemengd, of ze halverwege stiekem suiker voor zout hebben geruild, zolang het eindresultaat er maar uitziet als een taart. Maar wat als je precies moet weten wat er in de keuken is gebeurd? Wat als je het proces moet auditeren om te controleren of de robot geen stap heeft verzonnen?

Dat is het probleem dat dit artikel aanpakt. De auteurs hebben een nieuw soort "Neural CPU" (een brein voor een computer) gebouwd die niet alleen het antwoord raadt, maar ook zijn werk laat zien, stap voor stap, zoals een student die zijn huiswerk voor wiskunde laat zien.

De "Laat je werk zien" Robotchef

De meeste AI-modellen zijn als zwarte dozen: je stopt er data in, en er komt een antwoord uit. Je kunt de raderen binnenin niet zien draaien. Dit nieuwe model, een Symbolic Neural CPU, is anders. Het is gebouwd als een transparante machine met duidelijke, gelabelde tandwielen.

Zo werkt het:

Het Recept (Instructies): De robot krijgt een lijst met instructies, zoals "Voeg Register A toe aan Register B."
De Versnellingsbak (De Router): In plaats van blindelings getallen te verwerken, heeft de robot een speciale schakelbord. Bij elke stap moet hij expliciet kiezen welk tandwiel hij draait: "Voeg ik toe? Trek ik af? Vermenigvuldig ik?" Hij moet roepen: "Ik kies het ADD-tandwiel!"
De Voorraadkast (Registers): Het heeft een reeks genummerde potten (registers) die getallen bevatten. Het verandert alleen de pot die het moet veranderen, en laat de rest precies zoals ze waren.
Het Auditspoor: Omdat de robot moet aankondigen welk tandwiel hij koos en welke pot hij veranderde, kunnen mensen de hele film van de berekening bekijken. Ze kunnen zien of de robot op het juiste moment het juiste tandwiel koos.

De "Gepixelde" Test (Kwantisering)

De auteurs wilden zien of deze robot nog steeds kon werken als ze hem dwongen om "gepixelde" wiskunde te gebruiken. Stel je voor dat je probeert een gladde cirkel te tekenen met alleen een raster van grote, blokkerige pixels. Dit wordt kwantisering genoemd. In de echte wereld gebruiken computers vaak rekenkunde met lage precisie om energie te besparen en sneller te draaien, maar dat maakt het meestal rommelig en onnauwkeurig.

De auteurs simuleerden dit door hun robot te dwingen zijn getallen af te ronden naar een 8-bit raster (zoals een zeer laag-resolutie afbeelding) voordat hij het resultaat terug in de pot schrijft.

De Grote Verrassing:
Zelfs met deze "blokkerige" wiskunde raakte de robot niet in de war over welk tandwiel hij moest draaien.

Het Pad: De robot koos de juiste operatie (zoals ADD of SUBTRACT) 100% van de tijd voor programma's tot 1.000 stappen lang. Hij vergat het recept nooit.
De Getallen: De werkelijke getallen in de potten weken een beetje af door de "blokkerige" wiskunde. De gemiddelde fout was ongeveer 0,002 (een klein piekje op een schaal van 0 tot 1).
De Fix: De auteurs realiseerden zich dat deze afwijking geen fout van de robot was; het was simpelweg het verschil tussen "gladde wiskunde" en "blokkerige wiskunde". Wanneer ze de blokkerige resultaten van de robot vergeleken met een referentie-robot die ook blokkerige wiskunde gebruikte, kwamen de resultaten perfect overeen. De robot deed precies wat hij moest doen; hij werkte gewoon in een andere "resolutie".

Wat deze Robot Niet Kan (Nog)

Het is belangrijk om de grenzen te kennen. Het artikel sluit expliciet een paar dingen uit:

Het is geen magische geest: De robot is geweldig in het volgen van een specifieke lijst instructies waarop hij is getraind. Maar als je de instructie (de "opcode") verbergt en hem vraagt te raden wat hij moet doen op basis van alleen de getallen, heeft hij moeite. Als je het "Add"-label weghaalt en alleen de getallen laat zien, raakt de robot de weg kwijt, vooral als de taak vereist dat hij dingen voor een lange tijd onthoudt (zoals een "memory pressure" test).
Het is geen afgewerkte hardwarechip: De auteurs zijn heel duidelijk: dit is een simulatie. Ze hebben nog geen fysieke chip van silicium gebouwd. Ze testen het idee van hoe een dergelijke chip zou gedrag vertonen.
Het is geen algemeen brein: Deze robot is gespecialiseerd in "symbolische executie" (het volgen van regels). Het is geen algemene AI die poëzie kan schrijven of met je kan chatten.

De Limiet van de "Trainingshorizon"

De auteurs speelden ook een leuk spel met de training van de robot. Ze trainden één versie van de robot op korte recepten (tot 40 stappen) en vroegen hem vervolgens om een enorme 1.000-stappen maaltijd te koken.

Het Resultaat: De robot deed het goed voor de eerste 400 stappen, maar daarna begon hij in de war te raken.
De Oorzaak: Het was niet dat de robot "te klein" was om de grote maaltijd aan te kunnen. Het was dat hij nooit zo lang had leren koken. Toen ze een vergelijkbare robot hertrainden op langere recepten (tot 160 stappen), kon hij de 1.000-stappen maaltijd perfect bereiden. Dit suggereert dat de limieten van de robot gaan over wat hij heeft geleerd, niet over een harde muur in zijn brein.

De Kern van het Verhaal

Dit artikel introduceert een manier om AI te bouren die je niet alleen een antwoord geeft, maar ook bewijst hoe het tot dat antwoord kwam.

Het Goede Nieuws: In deze simulaties kan de robot complexe instructies van 1.000 stappen perfect volgen, zelfs wanneer hij gedwongen wordt om met lage-precisie, "blokkerige" wiskunde te werken. Hij houdt zijn logische pad schoon en controleerbaar.
De Haken en Ogen: Het heeft nog steeds de instructies nodig die zichtbaar zijn. Als je de instructies verbergt en hem laat raden, faalt hij. En op dit moment vindt dit alles plaats in een computersimulatie, niet op een fysiek apparaat.

Beschouw het als het bouwen van een transparante, zelf-auditerende rekenmachine die kan draaien op hardware met een laag vermogen zonder zijn verstand te verliezen. Het is een veelbelovende stap naar het maken van AI die we echt kunnen vertrouwen om de wiskunde stap voor stap uit te voeren.

Technische Samenvatting: Een Symbolische Neurale CPU voor Kwantisatie-gesimuleerde Writeback en Interpreteerbare Programma-executie

1. Probleemstelling

Moderne neurale netwerken blinken uit in het leren van continue input-output-mappings, maar functioneren vaak als "black boxes" waarbij interne toestandsveranderingen verborgen blijven in dichte activaties of parameters. Deze opaakheid maakt het moeilijk om geleerde executoren te vertrouwen, vooral wanneer de taak algoritmisch redeneren vereist of implementatie op beperkte hardware mogelijk moet maken. Hoewel geheugen-augmenterende netwerken (zoals Neural Turing Machines) en neurosymbolische benaderingen de redeneerkracht hebben verbeterd, missen ze over het algemeen een audit-spoor op registerniveau. Specifiek is er een tekort in de evaluatie van de vraag of een geleerd systeem de specifieke symbolische operatie selecteert, het exacte register bijwerkt, en of het tussenliggende executiepad getrouw blijft aan een referentiemachine, met name onder beperkingen van lage-precisie (gekwantiseerde) rekenkunde. Huidige benchmarks evalueren vaak alleen de eindtoestand-nauwkeurigheid, waardoor ze niet het onderscheid kunnen maken tussen een model dat een algoritmisch pad correct volgt en een model dat slechts het eindpunt benadert.

2. Methodologie

De auteurs introduceren een trace-gesuperviseerde symbolische neurale CPU, een gefactoriseerde architectuur die ontworpen is om het executieproces controleerbaar te maken. Het systeem werkt op een gecontroleerde register-machine-interface waarbij de machine-toestand een registerbestand is $r_t \in [0, 1]^{R \times W}$ , en instructies tuples zijn van een operatie en bron-/bestemmingsregister-indices.

Kernarchitectuur:

Instructie-codering: Instructies worden gecodeerd als one-hot operatie-labels gecombineerd met genormaliseerde register-indices.
Recurrente Controller: Een controller (voornamelijk een GRU, met vergelijkingen met Transformers, TCN's en State-Space modellen) verwerkt de instructie en optionele geheugen-leesvectoren om verborgen toestanden te genereren.
Expliciete Operatie-router: In plaats van een monolithische output gebruikt het model een router om logits te voorspellen over een vaste set genoemde operaties ( $O = \{AND, OR, XOR, ADD, SUB, SHL, SHR, MUL\}$ ).
Differentieerbare ALU-bank: Een bank van vaste, differentieerbare continue rekenkundige en logische operaties (bijv. $A_{ADD}(u,v) = \text{clip}(u+v, 0, 1)$ ) genereert kandidaat-outputs.
Gemaskeerde Writeback: Het model selecteert een bestemmingsregister en werkt alleen dat register bij, waardoor de lokaliteitsrestrictie van traditionele CPU's behouden blijft.
Kwantisatie-gesimuleerde Writeback (QAT8): In de primaire experimentele setting wordt de geselecteerde ALU-output geprojecteerd op een 8-bit fixed-point rooster voordat deze naar het bestemmingsregister wordt geschreven.

Trainings- en Evaluatieprotocollen:

Trace-supervisie: Het model wordt niet alleen getraind op de eindtoestand, maar op het volledige traject van registertoestanden, operatie-labels en bestemmingsmaskers.
Gumbel-Softmax Relaxatie: Tijdens de training wordt stochastische operatie-selectie gebruikt om gradiëntstroom mogelijk te maken. Tijdens de evaluatie worden deterministische harde argmax-poorten gebruikt om een inspecteerbaar, symbolisch executiepad te garanderen.
Matched Fixed-Point Replay: Om de prestaties bij lage precisie te evalueren, definiëren de auteurs een "matched replay" referentie. Dit is een onafhankelijke, fixed-point reimplementatie van de referentie-interpreter, uitgevoerd met dezelfde 8-bit precisie als het model. Dit scheidt "mismatch in referentie-semantiek" (drift door kwantisatie) van "executiefout" (verkeerde operaties).
Benchmarks: Het systeem wordt geëvalueerd op synthetische programma's van variërende lengtes (tot 1000 instructies), breedtes (16 en 32 registers) en taakfamilies, waaronder zichtbare-opcode executie, verborgen-opcode geheugendruk en equivalent-programma energie-keuze taken.

3. Belangrijkste Bijdragen

Auditeerbare Executie-interface: De paper vestigt een kader waar het executieproces is gedecomposeerd in inspecteerbare componenten: operatiepoorten, bestemmingsmaskers, registertrajecten en geheugensignalen.
Kwantisatie-gesimuleerde Writeback met Matched Replay: De auteurs tonen aan dat een neurale executor de symbolische operatie-pad exact kan behouden, zelfs wanneer numerieke waarden driften door 8-bit kwantisatie, mits de evaluatie een gematchte lage-precisie referentie gebruikt in plaats van een full-precision continue referentie.
Gefactoriseerde Architectuurontwerp: Het werk laat zien dat het scheiden van de controller, de operatie-router en de vaste ALU-bank noodzakelijk is voor interpreteerbare executie. Ablaties onthullen dat het verwijderen van gate-supervisie leidt tot oninterpreteerbare latente paden, zelfs als de eindnauwkeurigheid behouden blijft.
Uitgebreide Interfaces: Het framework wordt uitgebreid met ValueMemory (voor hidden-opcode taken), spiking controllers (gebruikmakend van leaky integrate-and-fire dynamiek voor controle-geheugen alleen), en een semantische brug naar RV32I basis-integer instructies.

4. Resultaten

Lengtestabiliteit en Logische Correctheid: Op het primaire 16-brede registerprofiel reproduceert de niet-gekwantiseerde executor de referentie-executie exact. De 8-bit kwantisatie-gesimuleerde (QAT8) executor behoudt het symbolische operatiepad (gate agreement) op 100% voor programma's tot 1000 instructies, ondanks continue-register numerieke drift (Final MAE $\approx 2.5 \times 10^{-3}$ ).
Matched Replay Getrouwheid: Wanneer geëvalueerd tegen de matched fixed-point replay (de 8-bit referentie), bereikt de QAT8 executor 100% scalaire-grid getrouwheid en nul trace-fout. Dit bevestigt dat de geobserveerde drift in continue scoring een referentie-semantiek mismatch is, en geen executiefout.
Architectuurvergelijkingen: Recurrente controllers (GRU) presteren over het algemeen beter dan of gelijk aan Transformers en andere varianten op deze taken. Cruciaal is dat ablaties laten zien dat het verwijderen van de expliciete gate-supervisie loss ervoor zorgt dat gate agreement instort (naar ~74,5%), zelfs als het model leert de eindtoestand te benaderen.
Geheugendruk en Verborgen Opcodes: Wanneer opcode-aanwijzingen verborgen zijn (memory-pressure taken), verslechtert de prestatie aanzienlijk, wat de grenzen van vertraagde state-gebruik en temporele binding blootlegt. ValueMemory-varianten verbeteren de prestaties op stack-achtige taken, maar worstelen met lange verborgen geheugen-omkeringen.
Extrapolatiegrenzen: Een 32-breed profiel getraind op korte programma's (max 40 stappen) faalt bij het generaliseren naar lange horizonten (boven ~500 stappen), wat aantoont dat de limiet de trainingshorizon is, en niet de state-breedte. Her-training op langere horizonten herstelt de exactheid.
Kostenbewuste Executie: Het model leert succesvol om lagere kosten equivalent-programma's te selecteren (min-energy paden) wanneer getraind met energie-keuze doelstellingen, waardoor de proxy-energie met ~38% wordt verminderd terwijl de correctheid behouden blijft.

5. Betekenis en Claims

De paper claimt een trace-verifieerbaar kader te hebben vastgesteld voor interpreteerbare, lage-precisie en controleerbare neurale executie. De primaire betekenis ligt in het verschuiven van het evaluatieparadigma van "eindpunt nauwkeurigheid" naar "transitie-niveau getrouwheid".

De auteurs claimen bescheiden dat hun resultaten het volgende aantonen:

Audibiliteit: Geleerde executoren kunnen worden ontworpen om hun interne symbolische keuzes (operaties en register-updates) te ontsluiten in plaats van ze te verbergen in continue toestanden.
Lage-precisie Robuustheid: Neurale executoren kunnen logische correctheid (symbolisch pad) behouden, zelfs wanneer de numerieke precisie is beperkt tot 8-bit, mits de evaluatiemetrieken rekening houden met kwantisatie-semantiek.
Controle: Het framework ondersteunt uitbreidingen voor closed-loop controle en hardware-bewuste restricties (energie/delay proxies).

De paper stelt expliciet dat deze niet claimt een fysieke processorimplementatie, een volledige integer-only inference engine, of een volledige RISC-V compliant emulator te zijn. In plaats daarvan dient het als een semantische brug en een diagnostisch substraat om te verifiëren of geleerde systemen de stap-voor-stap machine-trace behouden die vereist is voor betrouwbare implementatie in device-facing runtimes. Het werk benadrukt dat voor neurale systemen om te functioneren als co-processoren of controllers, hun operatiekeuzes en toestandsveranderingen zichtbaar en verifieerbaar moeten zijn vóór hardware-implementatie.