🤖 AI

NeuronFabric: A Software Reference Architecture for On-Chip Transformer Training with Local Adam

Dit artikel introduceert NeuronFabric, een softwarematige referentiearchitectuur en een C#-prototype voor on-chip transformer-training met lokale Adam-updates, die de numerieke correctheid valideert en aantoont dat een BF16W-configuratie (BF16-gewichten met FP32-optimizer-momenten) de geheugeneisen vermindert om binnen de BRAM-capaciteit van een Xilinx ZCU102-device te passen voor toekomstige FPGA- en ASIC-implementaties.

Oorspronkelijke auteurs: Evgeny Ukladchikov

Gepubliceerd 2026-06-16

📖 6 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Evgeny Ukladchikov

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 Zelfstandige Leermachine

Stel je voor dat je probeert een robot te leren om Shakespeare te schrijven. Momenteel werkt het trainen van de meeste AI als een student met een zeer trage leraar.

De student (de chip) leest een zin en probeert het volgende woord te raden.
De student maakt een fout en berekent hoe hij fout zat.
De student moet helemaal naar de directiekamer van de leraar rennen (de hostcomputer) om het antwoordmodel te krijgen.
De leraar werkt de aantekeningen van de student bij, en de student rent terug om het opnieuw te proberen.

Dit "heen en weer rennen" is traag en verspilt veel energie.

NeuronFabric stelt een ander idee voor: Een student die het antwoordmodel in zijn eigen zak heeft.
In dit systeem raadt de chip niet alleen; hij berekent zijn eigen fouten, kijkt naar zijn eigen aantekeningen en werkt zijn eigen geheugen onmiddellijk bij, zonder ooit de kamer te verlaten. Het paper bewijst dat deze "zelf-bijwerkende" wiskunde correct werkt in software, wat de weg vrijmaakt voor een toekomstige chip die dit fysiek kan uitvoeren.

Kernconcepten Uitgelegd

1. De "Local Adam" (Het Zelfcorrectiemechanisme)

In standaard AI leeft de "optimizer" (het deel dat fouten herstelt) meestal op een aparte computer. NeuronFabric plaatst de optimizer binnenin elke individuele neuron.

Analogie: Stel je een klaslokaal voor waar elke student zijn eigen privé-whiteboard heeft. Wanneer ze een vraag fout beantwoorden, wachten ze niet tot de leraar langskomt. Ze wissen onmiddellijk hun fout uit, schrijven de correctie op en gaan verder.
De claim van het paper: De auteurs hebben hiervan een softwareversie gebouwd in C# (een programmeertaal). Ze hebben bewezen dat wanneer elke neuron zichzelf lokaal bijwerkt, de wiskunde nog steeds klopt en de robot coherent tekst leert schrijven.

2. De "BF16W"-truc (De Rugzakstrategie)

Om dit zelf-bijwerkende systeem op een kleine chip (zoals een FPGA) te laten passen, is geheugen het grootste probleem.

Het Probleem: Normaal gesproken heeft een robot, om te leren, drie zware rugzakken nodig voor elke stukje kennis:
1. De kennis zelf (Weights/Gewichten).
2. Een verslag van hoe snel het leerde (Momentum).
3. Een verslag van hoeveel het varieerde (Variance).
- Als de rugzakken te zwaar zijn, past de robot ze niet allemaal in zijn kleine kamer (SRAM).
De Oplossing (BF16W): De auteurs realiseerden zich dat ze de "Kennis"-rugzak konden verkleinen. In plaats van een zware, uiterst precieze rugzak (32-bit) te dragen, dragen ze een lichte, iets minder precieze rugzak (16-bit).
Het Resultaat: Ze hielden de "leerverslagen" zwaar en precies, maar maakten de "kennis"-rugzak de helft kleiner.
- Analogie: Het is als pakken voor een reis. Je bewaart je dure, breekbare sieraden (de leerstatistieken) in een zware, beveiligde kist. Maar je vervangt je zware winterjas (de gewichten) door een dunne, lichtgewicht jasje. Je bespaart genoeg ruimte in je koffer om je slaapzak (de activatiebuffers) mee te nemen, zodat je niet op de grond hoeft te slapen.
De claim van het paper: Deze truc bespaarde precies genoeg ruimte om het volledige leersysteem op een middenklasse chip (ZCU102) te laten passen zonder verbinding te hoeven maken met extern geheugen.

3. Het "Vocabulaire Budget" (De Ruimte voor Gedachten)

De auteurs ontdekten een verborgen valkuil bij het bouwen van kleine AI-modellen.

De Valkuil: Als je een heel klein budget hebt voor geheugen, en je probeert de robot een enorme woordenlijst (vocabulaire) te leren, neemt de woordenlijst bijna alle ruimte in beslag. Er is dan geen ruimte meer over voor de robot om daadwerkelijk te denken of grammatica te leren.
Analogie: Stel je voor dat je een klein notitieboekje hebt. Als je 90% van de pagina's gebruikt om alleen het alfabet en een woordenboek op te schrijven, heb je nog maar een paar pagina'jes over om een verhaal te schrijven. Het verhaal zal onzinnig zijn.
De Fix: De auteurs gebruikten een "byte-level" aanpak (waarbij elke letter als een enkele token wordt behandeld) en een kleine vocabulaire (256 tekens). Dit betekende dat de "woordenlijst" slechts een klein hoekje van het notitieboek innam, waardoor er genoeg ruimte overbleef voor de robot om te leren hoe hij Shakespeareaanse zinnen schrijft.
De claim van het paper: Ze toonden aan dat als je deze "vocabulairebelasting" niet beheert, kleine modellen geen zinvolle output produceren, ongeacht hoe goed de wiskunde is.

4. Het "No-Host" Doel (De Onafhankelijke Chip)

Het uiteindelijke doel van dit onderzoek is een chip die geen computer (CPU) nodig heeft om hem te vertellen hoe hij moet leren.

Huidige Status: Het paper beschrijft een softwareprototype. Het draait op een standaard computer om te bewijzen dat de wiskunde klopt.
Toekomstige Status: Het doel is om exact dezelfde softwarelogica op een fysieke chip (FPGA) te plaatsen.
De Claim: Als zij de fysieke chip in staat stellen dit te doen, zal deze in staat zijn om zichzelf te trainen op nieuwe gegevens zonder ooit data naar een server te sturen of te wachten op een computer die zijn gewichten bijwerkt. Het zou een echt "on-chip" lerende machine zijn.

Wat hebben ze daadwerkelijk bereikt?

Ze hebben een proof-of-concept gebouwd: Ze schreven een programma in C# dat een klein AI-model (334.000 parameters) volledig zelfstandig traint.
Ze hebben bewezen dat de wiskunde werkt: De AI leerde tekst te genereren die lijkt op Shakespeare (bijv. "HAMLET: Break him of him..."). Het was niet perfect, maar het was coherent.
Ze hebben bewezen dat de geheugenwiskunde werkt: Ze berekenden exact hoeveel ruimte nodig is en toonden aan dat met hun "lichtgewicht jasje" (BF16W)-truc, het hele systeem op een specifieke chip (ZCU102) past met ruimte over.
Wat ze NIET hebben gedaan: Ze hebben de fysieke chip nog niet gebouwd. Ze hebben de snelheid of het verbruik van de chip ook niet gemeten. Ze hebben alleen de software gemeten die op een normale computer draait.

Samenvatting

Beschouw dit paper als de blauwdruk en de simulatie voor een nieuw type automotor.
De auteur zegt: "Ik heb een motor ontworpen waarbij de brandstofinjectie en de bougies direct met elkaar communiceren zonder een centrale computer. Ik heb een computersimulatie van deze motor gebouwd, en deze rijdt perfect. Ik heb ook berekend dat deze motor klein genoeg is om in een compacte auto te passen. Nu moet ik de eigenlijke metalen motor bouwen om te bewijzen dat hij echt loopt."

Het paper is het bewijs dat het ontwerp deugt; de fysieke chip is de volgende stap.

Technische Samenvatting: NeuronFabric

Probleemstelling

Huidige publiekelijk gedocumenteerde neurale versnellers scheiden over het algemeen de berekeningsfase van de optimizer state-update. Alleen voor inferentie bedoelde chips (bijv. Groq LPU, Apple ANE, IBM NorthPole) missen on-chip gradiëntberekening, terwijl trainingsversnellers (bijv. Cerebras, Tenstorrent) typisch gewichtupdates uitbesteden aan een host-CPU of externe GPU. Deze architecturale scheiding creëert significante bottlenecks:

Gewichtsverkeer: Inferentie vereist het laden van alle gewichten vanuit extern geheugen (HBM) voor elke forward pass.
Trainingslatentie: De chip die gradiënten berekent, past deze niet toe; updates worden apart georkestreerd, wat vaak datamovering buiten de chip vereist.
Beperkingen voor continu leren: Inferentiechips kunnen gewichten niet bijwerken op basis van nieuwe data zonder het volledige model opnieuw te laden vanuit een extern cluster, een proces dat minuten tot uren duurt.

Het paper stelt dat een siliciumchip waarbij elke neuron zijn eigen gewichten vasthoudt en lokaal de Adam-optimizer uitvoert, de off-chip traffic kan minimaliseren en echt on-chip training mogelijk kan maken. Echter, voordat er een besluit wordt genomen over silicium, moet de wiskundige geldigheid en numerieke correctheid van een dergelijke "lokale Adam"-architectuur worden vastgesteld.

Methodologie

De auteurs hebben NeuronFabric ontwikkeld, een volledige software-referentiearchitectuur geïmplementeerd in C# zonder externe machine learning-frameworks. Het systeem is ontworpen zodat elke software-abstractie direct naar een hardwareblok mapt (bijv. NeuronCore naar BRAM, Forward() naar DSP48-ketens).

Kernarchitectuur:

Lokale Adam: Elke NeuronCore slaat zijn eigen gewichtsvector $w$ en bias $b$ op. Tijdens de backward pass berekent het gradiënten en werkt het gewichten in-place bij met behulp van het Adam-algoritme. Er is geen gewichtsbus tussen de cores.
Modelconfiguratie: Een autoregressieve transformer met 334K parameters (Pre-LN) getraind op de Shakespeare-corpus.
- Dimensies: Embedding $d=88$ , 4 koppen, Feedforward $f=264$ , 4 lagen.
- Vocabulaire: 256 (byte-niveau).
- Technieken: Gewichtstyping (de output projectie hergebruikt de embedding matrix) om parameters te besparen.

BF16W Precisieschema:
Om de strikte SRAM-beperkingen van FPGA-training aan te pakken, hebben de auteurs BF16W (Brain Floating Point 16 Weights) geïntroduceerd.

Opslag: Gewichten worden opgeslagen als BF16 (2 bytes).
Berekening: Gewichten worden gecast naar FP32 voor forward/backward-berekeningen en Adam moment-updates.
Moments: De Adam eerste ( $m$ ) en tweede ( $v$ ) moments blijven in FP32 (4 bytes elk) om stabiliteit te garanderen.
Update: Na de Adam-stap wordt het bijgewerkte FP32-gewicht afgerond naar BF16 en teruggeschreven naar de opslag.

Vocabulaire-Budgetbeperking:
Het paper identificeert een kritieke beperking voor modellen met weinig parameters: de embedding-tabel ( $|V| \times d$ ) verbruikt een onevenredig groot deel van het parameterbudget ("vocabulary tax"), waardoor er onvoldoende capaciteit overblijft voor de transformer-lagen om structurele patronen te leren. Dit werd gekwantificeerd over drie domeinen, waarbij werd aangetoond dat wanneer de resterende redeneercapaciteit ( $P_{reason}$ ) onder ~20K daalt, coherente tekstgeneratie faalt.

Belangrijkste Bijdragen

Software Referentie Implementatie: Een volledige, framework-vrije C#-implementatie van een transformer met volledige backpropagation en lokale Adam-updates, die training, evaluatie en checkpointing in één enkele binary uitvoert.
BF16W Validatie: Demonstratie dat het opslaan van gewichten in BF16 terwijl de moments in FP32 blijven, het SRAM-gebruik vermindert van 12 bytes/parameter naar 10 bytes/parameter met een verwaarloosbare convergentiepenalty (+0,020 validatieverlies op Shakespeare).
Kwantificering van het Vocabulaire-Budget: Empirisch bewijs dat voor hardware met een vast budget de embedding-tabel domineert, wat ofwel kleine vocabularia of gespecialiseerde multi-chip architecturen (bijv. aparte embedding chips) noodzakelijk maakt.
FPGA Haalbaarheidstarget: Een concrete configuratie (334K BF16W model) die volledig in de 4,0 MB on-chip BRAM van een Xilinx ZCU102 FPGA past, waarbij 660 KB overhead overblijft voor activatiebuffers, zonder dat DDR-toegang nodig is tijdens de training.

Resultaten

Het systeem werd gevalideerd op een Windows 11-machine (AMD Ryzen 9 9900X CPU, NVIDIA RTX 4090 GPU) met de Shakespeare-corpus (80K samples).

Correctheid: Numerieke gradiëntcontroles (eindige verschillen versus analytische gradiënten) slaagden voor alle componenten, wat de wiskundige correctheid van de lokale Adam-implementatie bevestigt.
Convergentie:
- GPU FP32 (Oracle): Bereikte een validatieverlies van 1,5224.
- CPU BF16W: Bereikte een validatieverlies van 1,5426.
- Het verschil van +0,020 wordt toegeschreven aan het precisieverschil tussen BF16-gewichtopslag en FP32-berekening.
Generatieve Kwaliteit: Het model produceerde coherente karakter-niveau tekst met herkenbare Shakespeareaanse dialoogstructuren en naamgegeven patronen, wat bevestigt dat de trainingslus convergeert naar een functionele oplossing.
SRAM Efficiëntie:
- FP32 Adam (12 bytes/param): 4,00 MB totaal (vult de ZCU102 BRAM exact, waardoor er nul ruimte overblijft voor activaties).
- BF16W Adam (10 bytes/param): 3,34 MB totaal (laat 660 KB vrij voor activaties en de control state).

Betekenis en Claims

Het paper benadrukt expliciet de bescheiden reikwijdte: NeuronFabric is een onderzoeks-prototype, geen productie-accelerator. Het bevat geen FPGA-metingen of timing closure-resultaten.

De primaire betekenis van het paper ligt in:

Het Vaststellen van Prior Art: Het dient als een publieke architecturale openbaarmaking en software-referentie om de "lokale Adam-update" architectuur als prior art te vestigen voor toekomstige FPGA/ASIC-implementaties.
Proof of Concept: Het demonstreert dat de wiskunde klopt en de cijfers juist zijn voor een transformer die volledig on-chip traint met een lokale optimizer state, zonder een host-CPU in de update-loop.
De Weg Vooruit Definiëren: Het stelt de 334K BF16W Shakespeare-model in als een falsifieerbaar doel voor toekomstige FPGA-implementaties. Als hetzelfde verliescurven bereikt kan worden op de FPGA zonder host-interventie, wordt de haalbaarheid van on-chip transformer-training een gemeten feit in plaats van een softwarematige projectie.

De auteurs concluderen dat de directe volgende stap is om deze specifieke trainingslus op de ZCU102 FPGA te implementeren om te verifiëren dat de softwareresultaten vertalen naar hardware, waarmee de "geen host-CPU" training-paradigma wordt gevalideerd.