Hoe Cerebras AI-modellen met biljoenen parameters implementeert

Een van de meest gestelde vragen die we krijgen, is hoe we grote modellen implementeren op de wafer-scale chips van Cerebras. Een enkele Cerebras WSE-3T wafer heeft 44 GB aan on-chip geheugen, terwijl frontier-modellen met biljoenen parameters alleen al terabytes aan ruimte nodig hebben voor hun gewichten.

In dit artikel leggen we uit hoe we een groot frontier-model verdelen over meerdere WSE-3T wafers, om modellen met meerdere biljoenen parameters te kunnen draaien met een snelheid van 1000-2000+ tokens per seconde.

We gebruiken het open-source model Kimi K3, met ongeveer 3 biljoen parameters, als illustratief voorbeeld. Aan het einde van dit artikel begrijpt u:

• Hoe we het volledige model in het on-chip geheugen passen.
• Hoe we het model over meerdere chips verdelen.
• Hoe we een groot aantal gelijktijdige verzoeken afhandelen.

Analyse aan de hand van Kimi K3

Kimi K3 is een open-source model met 3 biljoen parameters, bestaande uit 69 linear-attention lagen en 24 dense lagen.

Het model behaalt indrukwekkende scores: 88,3% op Terminal-Bench 2.1 (tegenover 88,8% voor GPT-5.6 Sol) en 91,2% op BrowseComp (tegenover 90,4% voor GPT-5.6 Sol). Deze resultaten tonen frontier-niveau capaciteiten op het gebied van coderen en agentische functies, waarbij het op sommige benchmarks zelfs leidende propriëtaire modellen overtreft.

Voor dit voorbeeld hanteren we de volgende uitgangspunten:

• Een gemiddelde verzoekgrootte van 256k.
• 4-bit gewichtsquantisatie (vergelijkbaar met de Hugging Face-implementatie).
• Een 8-bit KV-cache.

1. De grootte van elke laag

Om te berekenen hoeveel Cerebras WSE-3T wafers er nodig zijn om Kimi K3 te ondersteunen, berekenen we eerst de grootte van elke modellaging.

Kimi K3 heeft 3 biljoen parameters. Als alle 3 biljoen parameters worden opgeslagen in 4 bits per stuk, is de ruwe parameter-payload aanzienlijk. Door deze payload te delen door de 93 lagen, komen we tot de grootte per laag.

2. Aantal wafers

Nu we weten dat elke laag ongeveer 16 GB nodig heeft, kunnen we bepalen hoeveel lagen er op elke 44 GB wafer passen. Het antwoord hangt af van het type laag:

• Dense lagen: Deze hebben extra ruimte nodig voor een KV-cache, omdat elke dense laag (full-attention) de keys en values opslaat voor elk token in elk actief verzoek. Daarom plaatsen we één dense laag per wafer en reserveren we de resterende SRAM voor de KV-cache.
• Linear-attention lagen: Deze vereisen geen extra ruimte voor een KV-cache. In plaats van keys en values voor elk token op te slaan, houdt een linear-attention laag een kleine, vaste staat per verzoek bij, ongeacht de contextlengte. Dit laat ruimte over voor twee lineaire lagen per wafer (2 × 16 GB = 32 GB).

Voor Kimi K3, met 69 lineaire lagen en 24 dense lagen, resulteert dit in:

• 69 lineaire lagen / 2 per wafer = 35 wafers (afgerond).
• 24 dense lagen / 1 per wafer = 24 wafers.

Dit brengt het totale aantal wafers op 35 + 24 = 59 wafers.

3. Het verbinden van de wafers

Cerebras voert modellen uit in een pipeline. Nadat de Cerebras-compiler de modellagen over regio's van wafers heeft verdeeld, bepaalt de runtime het pad dat de tokens tussen de wafers afleggen. Voor een ultrafast latentie hoeven alleen de activaties tussen de wafers te worden doorgegeven; dit gebeurt via RDMA over Ethernet. Dit kost ongeveer 2 microseconden per 'hop'.

Het is belangrijk om te benadrukken dat omdat elke Cerebras-wafer 44 GB on-chip SRAM heeft en elke laag slechts 16 GB is, we doorgaans in staat zijn om volledige lagen van het model direct op de chip te plaatsen. Dit betekent dat de modelgewichten in de meeste gevallen niet hoeven te bewegen en lagen niet over wafers hoeven te worden gesplitst. Alleen de activaties gaan van de ene wafer naar de volgende.

4. Hoe we één verzoek verwerken

Nu de wafers zijn verbonden en het model is ingedeeld, kunnen we elke wafer zien als een stap in een assemblagelijn: de modelgewichten voor elke stap blijven op hun plek, en de tussenresultaten van het verzoek bewegen door de lagen.

Bijvoorbeeld: Wafer 1 voert modellagen 1–2 uit en stuurt de activaties naar wafer 2. Wafer 2 voert lagen 3–4 uit en geeft de resultaten door aan Wafer 3, enzovoort, totdat de laatste wafer het volgende token produceert.

5. Hoe we meerdere verzoeken verwerken

Dit leidt vaak tot een misverstand: als een token in volgorde door elke wafer moet reizen, staat elke wafer dan niet stil terwijl hij wacht op zijn beurt? Zou het systeem dan niet effectief draaien met een batch size van één?

Nee. Als we slechts één verzoek tegelijk door de lijn zouden sturen en zouden wachten tot dit voltooid is voordat we het volgende starten, zou dit een inefficiënt gebruik van de pipeline zijn. In plaats daarvan houden we de volledige pipeline vol met verschillende verzoeken. Omdat het model al is opgesplitst in pipeline-fasen, kan elke fase tegelijkertijd aan een ander verzoek werken.

Terwijl fase 3 een token verwerkt voor verzoek A, verwerkt fase 2 er een voor verzoek B, en fase 1 er een voor verzoek C. In ons voorbeeld is elke fase een laag. In productie gebruikt Cerebras veel fijnmaziger fasen, en aanzienlijk meer ervan.

Elke fase kan bovendien een micro-batch (een kleine groep verzoeken) verwerken in plaats van een enkel verzoek. Het aantal verzoeken dat gelijktijdig in behandeling is, is dus ongeveer het aantal fasen vermenigvuldigd met de micro-batch grootte.

Wat betreft de afweging: kleinere micro-batches maken elk individueel verzoek sneller, terwijl grotere micro-batches de totale doorvoersnelheid (throughput) verhogen.

6. Hoeveel verzoeken kunnen we bedienen?

De hoeveelheid on-chip geheugen die is toegewezen aan de KV-cache bepaalt het maximaal aantal gelijktijdige verzoeken. Elk actief verzoek heeft zijn eigen KV-cache nodig op elke wafer met een dense laag. De grootte van het on-chip geheugen vormt dus het plafond voor gelijktijdige verzoeken. Zoals eerder uitgelegd, hoeven we de KV-cache vereisten alleen te berekenen voor de dense lagen.

Voor elke 44 GB wafer die al één dense laag bevat, berekenen we de resterende ruimte voor de KV-cache als volgt: Totaal wafer-geheugen - grootte van één dense laag In dit geval: 44 GB - 16 GB = 28 GB.

Berekening van het aantal gelijktijdige verzoeken: Om het aantal ondersteunde gelijktijdige verzoeken voor een specifieke modelmapping te vinden, berekenen we eerst hoeveel cache een enkel verzoek van 256k in beslag neemt. Vervolgens delen we de totale beschikbare cache-ruimte door de ruimte die één verzoek inneemt.

Het totale aantal gelijktijdige verzoeken vertegenwoordigt de hoeveelheid verzoeken die op elk gegeven moment door de pipeline bewegen. In tegenstelling tot een GPU-batch wachten deze verzoeken niet op elkaar om klaar te zijn; ze stromen continu door de pipeline.

Natuurlijk zeggen noch concurrency, noch batch size precies hoe efficiënt een inferentiesysteem presteert. Bij het evalueren van de doorvoersnelheid is de meest zinvolle metriek de totale token-throughput per eenheid vermogen (bijv. tokens per seconde per megawatt), gemeten bij dezelfde output-generatiesnelheid.

Schalen naar meer dan 3 biljoen parameters

Deze aanpak is uitbreidbaar naar grotere modellen: bereken het benodigde geheugen voor gewichten en de status van het verzoek, verdeel het model over de wafers en verbind ze in een pipeline. Elke extra wafer voegt rekenkracht en on-chip geheugen toe, waardoor we modellen kunnen accommoderen die de capaciteit van een enkele chip overschrijden.