🤖 machine learning

Pipeline-Native Transformers: Co-Designing Model Architecture and CPU Inference for Bandwidth-Efficient Autoregressive Decode

Dit artikel introduceert cflow, een CPU-first streaming engine die is medeontworpen met pipeline-native transformer-architecturen om geheugenbandbreedte-bottlenecks bij single-token autoregressieve decodering te overwinnen, waarbij tot 2,00x reductie in kritieke pad gewichtsbandbreedte en 5,94 tokens/s op een 32-vCPU server wordt bereikt door gebruik te maken van L2-grootte gewichtstiling, top-k expert selectie en asynchrone I/O overlap.

Oorspronkelijke auteurs: Tom Poperszky

Gepubliceerd 2026-08-26

📖 6 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Tom Poperszky

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

In de wereld van kunstmatige intelligentie worden de krachtigste computerprogramma's vaak beschreven als het hebben van een "brein" dat bestaat uit miljarden kleine schakelaars. Deze schakelaars, of gewichten, worden opgeslagen in het hoofdgeheugen van de computer, zoals boeken op een enorme bibliotheekplank. Om een voorspelling te doen of een enkel woord tekst te genereren, moet de computer de juiste boeken van de plank halen, ze lezen en een berekening uitvoeren. Jarenlang hebben ingenieurs ervan uitgegaan dat de snelheid van deze berekeningen de beperkende factor was, in de veronderstelling dat als ze de processor maar sneller konden laten denken, het programma sneller zou draaien. Echter, een nieuwe lijn onderzoek suggereert dat deze aanname onjuist is voor de meest voorkomende manier waarop deze programma's worden gebruikt: het genereren van één woord per keer. In deze specifieke modus wacht de processor niet tot zijn brein heeft nagedacht; hij wacht tot het geheugen de gegevens levert. De processor is zo snel dat hij het grootste deel van de tijd stilzit, starend naar een lege plank, wachtend tot het volgende boek arriveert. Dit creëert een bottleneck waarbij de snelheid van het hele systeem niet wordt bepaald door hoe snel de computer kan rekenen, maar door hoe snel hij gegevens van de geheugenshelf naar de processor kan verplaatsen.

Een onderzoeker genaamd Tom Poperszky heeft dit probleem aangepakt door te beseffen dat de standaard manier waarop deze "boeken" op de plank worden georganiseerd, is ontworpen voor een heel ander soort computer. De meeste moderne AI-modellen zijn gebouwd om te draaien op gespecialiseerde grafische chips, die uitblinken in het tegelijkertelijk lezen van veel boeken. Wanneer deze modellen op standaard computerprocessoren worden uitgevoerd, zorgt de oude organisatie ervoor dat de processor tijd verspilt door over de plank te springen, waarbij hij gegevens in een chaotische volgorde ophaalt die de hardware niet kan voorspellen. Poperszky's werk stelt een radicale oplossing voor: in plaats van te proberen de oude modellen beter te laten werken op nieuwe hardware, heeft hij zowel het model als de software die het uitvoert vanaf de grond af aan herontworpen om samen te werken. Hij creëerde een nieuwe manier om de gegevens van het model op te slaan in kleine, nette brokjes die perfect passen in de directe werkruimte van de processor, en hij schreef de interne instructies van het model zo om dat het deze brokjes in een vloeiende, continue lijn kan lezen zonder ooit te stoppen om te wachten.

De kern van deze nieuwe aanpak is een systeem genaamd cflow, dat fungeert als een uiterst efficiënte bibliothecaris voor de computer. In een standaardopstelling moet de computer, wanneer hij een woord wil genereren, vaak de volledige set instructies voor een specifiek deel van het model laden, zelfs als hij slechts een fractie daarvan nodig heeft. Dit is vergelijkbaar met het openen van een hele encyclopedie om één enkel feit te vinden. Poperszky's systeem verandert dit door de gegevens te organiseren in kleine tegels, ongeveer zo groot als een enkele pagina, en ze in de exacte volgorde op te slaan waarin de computer ze nodig zal hebben. Wanneer de computer om het volgende stuk informatie vraagt, schuift het systeem de volgende tegel direct op zijn plaats, waardoor de processor bezig blijft. Bovendien laadt het nieuwe systeem voor modellen die gebruikmaken van een "mixture of experts" — een techniek waarbij het model een paar gespecialiseerde subroutines voor elke taak kiest — alleen de specifieke subroutines die op dat moment nodig zijn, terwijl de rest op de plank blijft liggen. Dit elimineert de verspilling van het laden van duizenden ongebruikte instructies voor elk gegenereerd woord.

Om dit systeem te laten werken, moest de onderzoeker de architectuur van het model zelf veranderen. Standaardmodellen zijn gebouwd als een strikte lopende band waarbij één stap volledig moet worden afgerond voordat de volgende kan beginnen. Deze structuur dwingt de computer om te wachten tot de hele band klaar is voordat hij de volgende set instructies kan gaan lezen. Poperszky ontwierp het model opnieuw om een "verticale pijplijn" mogelijk te maken, waarbij de computer kan beginnen met het lezen van de instructies voor de volgende stap terwijl hij nog bezig is met de huidige stap. Dit is alleen mogelijk omdat het model getraind is om een iets vertraagde versie van de informatie van de vorige stap te accepteren, een verandering die fouten zou veroorzaken in een standaardmodel, maar perfect werkt in dit nieuwe ontwerp. Door vijf verschillende versies van deze herontworpen modellen te trainen, ontdekte de onderzoeker dat één specifieke configuratie de hoeveelheid gegevens die de computer moet verplaatsen met de helft kon verminderen. Deze reductie in gegevensverplaatsing vertaalt zich direct naar snelheid, aangezien de computer minder tijd doorbrengt met wachten en meer tijd met werken.

De resultaten van deze co-design werden gemeten op echte hardware, wat een duidelijk voordeel liet zien ten opzichte van bestaande software. Op een standaard servercomputer genereerde het nieuwe systeem tekst met een snelheid van bijna zes woorden per seconde, waarmee het de beste beschikbare alternatieven versloeg die op dezelfde machine slechts ongeveer vier en een half woord per seconde haalden. Deze verbetering was niet slechts een theoretische berekening; het was een reële snelheidswinst die werd bereikt door het aantal keren dat het geheugen van de computer moest worden geraadpleegd te verminderen. De studie testte ook verschillende andere ideeën, zoals het gebruik van expliciete instructies om de computer te vertellen waar hij de volgende gegevens moet zoeken. Verrassend genoeg lieten de tests zien dat deze instructies niet hielpen en het systeem zelfs vertraagden, omdat de eigen hardware van de computer al beter deed in het voorspellen wat er als volgende nodig was. Deze bevinding is cruciaal, omdat het een veelvoorkomende optimalisatietechniek uitsluit en bevestigt dat de werkelijke winst komt van de fundamentele reorganisatie van de gegevens en het model.

Het onderzoek onderzocht ook hoe deze veranderingen stand zouden houden naarmate de modellen groter worden. De analyse suggereert dat hoewel de snelheidswinst aanzienlijk is voor de geteste modellen, de specifieke voordelen afhangen van de grootte van het model en het type computer. Voor zeer grote modellen kan de bottleneck opnieuw verschuiven, maar het principe blijft hetzelfde: door de structuur van het model af te stemmen op de manier waarop de computer het geheugen leest, is het mogelijk om snelheden te ontsluiten die voorheen als onmogelijk werden beschouwd op standaard processors. Het werk demonstreert dat de beperkingen van de huidige kunstmatige intelligentie op alledaagse computers geen vaste natuurwetten zijn, maar ontwerpkeuzes die kunnen worden gewijzigd. Door het model en de runtime als één enkel, verenigd systeem te behandelen in plaats van als twee afzonderlijke onderdelen, is het mogelijk om een systeem te creëren dat gegevens verplaatst met de efficiëntie van een goed georganiseerde bibliotheek, waardoor de computer kan nadenken met de snelheid van zijn eigen hardware. Deze aanpak biedt een duidelijke weg voorwaarts om krachtige AI te draaien op apparaten zonder gespecialiseerde chips, wat geavanceerde intelligentie toegankelijker en responsiever maakt in de echte wereld.

Technische Samenvatting: Pipeline-Native Transformers

1. Het Probleem: De Bandbreedte-bottleneck bij CPU-inferentie

Het paper betoogt dat autoregressieve decodering van een enkel token op CPU's fundamenteel wordt beperkt door geheugenbandbreedte, niet door rekenkracht (arithmetic compute). Terwijl moderne CPU's ongeveer 1 TFLOP/s aan rekenkracht kunnen leveren, bieden ze doorgaans slechts ~50 GB/s aan hoofdgeheugenbandbreedte.

Voor een decodestap van een enkel token is de rekenintensiteit ongeveer 4 FLOP/byte (ervan uitgaande dat Q4-kwantisatie wordt gebruikt), wat vijf keer lager is dan de machinebalans van 20 FLOP/byte. Gevolgelijk brengt de CPU het grootste deel van de tijd door met wachten tot gewichtbytes vanuit het RAM naar de processor stromen, in plaats van berekeningen uit te voeren.

Bestaande CPU-inferentieruntimes (bijv. llama.cpp, ExLlama2) erven grotendeens ontwerpbeslissingen die gericht zijn op GPU-architecturen. Deze omvatten:

Row-major gewichtslayouts: Geoptimaliseerd voor gebatchte toegang maar inefficiënt voor single-token streaming, wat leidt tot L1-cachemissers die proportioneel zijn aan de grootte van de gewichtsmatrix.
Standaard Mixture-of-Experts (MoE) laden: Het laden van alle expert-gewichten voor een laag, zelfs als slechts een subset (top-k) actief is, wat tot wel 15x bandbreedte verspilt in modellen zoals Gemma 4.
Strikte laagafhankelijkheid: Standaard transformers vereisen de volledige output van laag $\ell$ voordat laag $\ell+1$ kan beginnen, wat verticale pipelining verhindert waarbij stadia van verschillende lagen gelijktijdig worden verwerkt.

Het paper stelt dat het behandelen van de modelarchitectuur en de inferentieruntime als onafhankelijke entiteiten een nadeel is in het CPU-regime. In plaats daarvan is een co-design benadering vereist om het totaal aantal verplaatste bytes per token te verminderen.

2. Methodologie: Co-design van Architectuur en Runtime

De voorgestelde oplossing bestaat uit twee nauw gekoppelde componenten: de cflow runtime en een familie van pipeline-native transformer-architecturen.

2.1 De cflow Runtime

cflow is een CPU-georiënteerde inferentie-engine geschreven in Rust, ontworpen rond de CPU-geheugenhiërarchie.

Tile-Native Gewichtsformaat: Gewichten worden opgeslagen als L2-grote tiles (128×256 matrices, ~18 KB bij Q4) in de volgorde van consumptie van de berekening. Dit zorgt ervoor dat terwijl een tile wordt verwerkt, de activatievector (die in L1 verblijft) over alle rijen van de tile wordt hergebruikt, wat L1-d cachemissers minimaliseert.
Bestandsformaten:
- .cflow: Een per-laag formaat voor standaard streaming.
- .vflow: Een stage-major formaat waarbij tiles gegroepeerd zijn per executiefase over lagen heen, wat verticale pipelining mogelijk maakt.
Conditioneel Expert Laden: De runtime gebruikt een expert-offsettabel om alleen de geselecteerde top-k expert-tiles te laden, waardoor de rest wordt overgeslagen.
Fused Kernels: Het fuseert QKV-projecties en gate+up-projecties om het herladen van activaties te verminderen.
Staged Direct-I/O: Voor disk-resident expert-tiers wordt asynchrone direct I/O gebruikt om het ophalen van experts te overlappen met de berekening van tussenliggende lagen.

2.2 Pipeline-Native Architecturen

Het paper introduceert een formele analyse van de laagafhankelijkheid Directed Acyclic Graph (DAG) in standaard pre-norm transformers. Het demonstreert dat standaard afhankelijkheden verticale pipelining verhinderen. Om dit mogelijk te maken, stelt de auteur DAG-herwriting voor via twee delay-transformaties:

Dense Delay ( $\delta_d$ ): De dense FFN bij laag $\ell$ consumeert de residual stream van laag $\ell - \delta_d$ in plaats van de output van de huidige laag.
Expert Delay ( $\delta_e$ ): Expert-outputs berekend bij laag $\ell$ worden geïnjecteerd in de residual stream bij laag $\ell + \delta_e$ .

Deze transformaties verbreken de strikte sequentiële keten, waardoor de runtime de gewichten voor laag $\ell+1$ kan ophalen terwijl laag $\ell$ nog aan het rekenen is, mits de afhankelijkheden door de vertraagde buffers worden voldaan.

Vijf kandidaat-architecturen werden getraind op de TinyStories dataset om de bandwidth-quality trade-off te verkennen:

Arch1 & Arch3: Baselines zonder delays (1.00× reductie in bandbreedte).
Arch2_4_combined: Combineert $\delta_d=1$ en $\delta_e=2$ . Dit bereikt de maximale reductie in bandbreedte.
Arch4 (AsyncExperts): Gebruikt $\delta_e=2$ met pre-dense routing (routing vóór de dense FFN). Dit behaalt de beste perplexiteit maar geen reductie in bandbreedte.
Arch5: Gebruikt weight sharing over iteraties voor parameterefficiëntie.

3. Belangrijkste Bijdragen

De cflow Runtime: Een volledige, productiewaardige Rust-implementatie met tile-native formaten, fused kernels en conditioneel expert laden. Het bereikt numerieke pariteit met PyTorch-referenties.
Pipeline-Native Taxonomie: Een formele definitie van afhankelijkheids-ontspannende transformaties (dense en expert delays) en vijf getrainde architecturen die aantonen dat deze structurele wijzigingen stabiele training en convergentie mogelijk maken.
Delay-Aware Scheduler: Een runtime scheduler die een ring-buffered residual history construeert om vertraagde inputs en expert-injecties te beheren, wat een verticale pipeline-planning mogelijk maakt.
Empirische Validatie: Een uitgebreide evaluatie over acht specifieke design-claims, inclusief negatieve resultaten waar hypothesen werden weerlegd.

4. Resultaten

4.1 Bandbreedte en Cache-efficiëntie

Reductie van het Kritieke Pad: De arch2_4_combined architectuur bereikt een 2.00× reductie in de kritieke pad gewichtsbandbreedte (van 9.00 MB/token naar 4.50 MB/token) vergeleken met een sequentieel schema.
Cache Locality: De tile-streaming layout vermindert L1-d read missers met een factor 7.29× vergeleken met een row-major baseline op een Xeon E5-2650 (gemeten via hardware performance counters).
Conditioneel Laden: Structurele garanties zorgen ervoor dat alleen top-k expert-tiles worden gelezen, wat een tot 16× reductie biedt in de expert-gewichtsbandbreedte voor grote MoE-modellen.

4.2 End-to-End Performance

Doorvoersnelheid (Throughput): Op een 30.9B parameter pipeline-native MoE draaiend op een AWS r6i.8xlarge (Ice Lake, 32 vCPUs), bereikt cflow 5.94 tokens/seconde.
Vergelijking: Dit presteert beter dan llama.cpp (4.75 tok/s op een vergelijkbare dense 32B model) en de vLLM CPU-backend (1.65 tok/s) op dezelfde hardware.
Expert Overlap: Op serverhardware met NVMe-opslag maakt de expert-delay window asynchronous I/O overlap mogelijk, wat een netto versnelling oplevert van tot 1.68× ten opzichte van een synchroon blokkerend schema.

4.3 Negatieve Resultaten en Weerleggingen

Het paper rapporteert expliciet weerlegde claims om een volledig beeld te geven:

Claim 6 (PREFETCHT0): Expliciete prefetching instructies boden geen voordeel en waren soms zelfs nadelig (4% trager) wanneer de bottleneck de storage-to-RAM bandbreedte was. De hardware prefetcher verzadigt lineaire RAM-toegang al, en expliciete hints voegen cachedruk toe zonder overlap.
Claim 8 (Stage-Major Readahead): Het theoretische readahead voordeel van de .vflow layout was onconcluderend bij de geteste schalen. Het voordeel vereist asynchronous I/O overlap die niet volledig is geïmplementeerd voor de niet-expert gewichten; de geobserveerde variantie werd toegeschreven aan SSD-cachetoestanden.

5. Betekenis en Claims

De centrale stelling van het paper is dat het co-designen van de modelarchitectuur en de inferentieruntime noodzakelijk is om de geheugenbandbreedte-bottleneck bij CPU-inferentie te overwinnen.

Haalbaarheid: Het werk bewijst dat het herschrijven van de inter-laag afhankelijkheidsgraaf van een transformer het effectieve leren niet verhindert; de getrainde architecturen convergeren met concurrerende perplexiteit.
Mechanisme: De bandbreedtereductie is geen benadering maar een analytisch gevolg van de delay-parameters en de modelgeometrie.
Praktische toepasbaarheid: De resultaten laten zien dat een pipeline-native MoE kan presteren boven standaard dense modellen op standaard CPU-hardware wanneer de runtime is geoptimaliseerd voor de specifieke architectuur.

De auteur concludeert dat hoewel de "pipeline-native" benadering wijzigingen in de architectuur tijdens de training vereist (waardoor het niet achteraf bruikbaar is voor bestaande checkpoints), de principes van conditioneel expert laden en tile-streaming gewichtslayouts direct toepasbaar zijn op bestaande runtimes om bandbreedte te verminderen en cache-lokaliteit te verbeteren. Het werk vestigt de stelling dat de afhankelijkheidsgraaf van de transformer een ontwerpkeuze is, en geen vaste beperking, en dat het exploiteren van deze keuze samen met runtime-optimalisatie resultaten oplevert die noch de een, noch de ander alleen had kunnen bereiken.