Hoe train je een AI-model op duizenden GPU's tegelijk?

Een groot AI-model train je door het werk te verdelen over honderden tot duizenden grafische chips (GPU’s) die tegelijk rekenen en na elke stap hun resultaten met elkaar delen. Eén chip heeft simpelweg te weinig geheugen, en zou er bovendien jaren over doen. Die verdeling is de reden dat AI-training in enorme datacenters gebeurt, veel stroom vraagt en voorbehouden is aan een klein aantal bedrijven.

Wat er gebeurt als een AI-model leert

Een taalmodel bestaat uit miljarden getallen, de parameters. Tijdens training krijgt het model een stukje tekst, voorspelt het volgende woord, en kijkt hoe ver het ernaast zat. Uit die fout berekent het per parameter een kleine correctie, de gradiënt. Dat herhaalt zich miljarden keren, tot het model goede voorspellingen doet. Hoe dat voorspellen precies werkt, lees je in Hoe werkt een taalmodel?.

Het geheugen is de eerste muur. Naast de parameters moet de GPU ook de gradiënten vasthouden, plus de boekhouding van het leeralgoritme (bij het veelgebruikte Adam twee extra getallen per parameter, plus een nauwkeurige kopie van elk gewicht). Onderzoekers van Microsoft rekenden voor dat dit met de gangbare methode op 16 bytes per parameter uitkomt (Bron: ZeRO-paper, Rajbhandari e.a.). Voor een bescheiden model van 7 miljard parameters is dat 112 GB, nog zonder de tussenresultaten per laag. De grootste A100-kaart heeft 80 GB (Bron: NVIDIA).

Beginner-tipTraining en gebruik zijn twee verschillende dingen. Training is de leerfase die één keer (heel duur) gebeurt. Wat er daarna gebeurt, als jij een vraag stelt, heet inferentie. Dat verschil leggen we uit inWat gebeurt er als je ChatGPT iets vraagt?

Het basisidee: dezelfde leerling, verschillende hoofdstukken

De eenvoudigste manier om het werk te verdelen heet data-parallelisme. Elke GPU krijgt een complete kopie van het model en een eigen portie van de trainingsdata. Allemaal rekenen ze tegelijk hun eigen correcties uit. Daarna volgt de cruciale stap: de GPU’s middelen hun correcties onderling, zodat elke kopie precies dezelfde aanpassing krijgt. Zo blijven alle kopieën identiek, en leert het model in één stap van vier, acht of duizend keer zoveel data.

Dat middelen kost wel communicatie. Binnen één server gaat het over snelle directe verbindingen tussen de chips, tussen servers over een netwerk. Hoe groter het cluster, hoe meer dat netwerk de snelheid bepaalt. Daarom gaat een flink deel van de investeringen in AI-datacenters naar kabels en switches, en bouwen chipmakers complete serverkasten waarin tientallen chips als één systeem samenwerken. Hoe kwetsbaar die planning is, zie je aan Nvidia’s vertraagde Kyber-rack.

Data-parallelisme heeft één harde grens: het model moet op elke GPU passen. Voor modellen van honderden miljarden parameters is dat onmogelijk, en dan stapelen labs meerdere technieken. Meta beschreef voor Llama 3 405B hoe het vier vormen van parallelisme combineerde: het model werd opgeknipt per laag, binnen lagen, over de lengte van de tekst, en de data werd verdeeld met een variant die ook het model zelf over de chips spreidt (Bron: Meta, The Llama 3 Herd of Models).

Wat die schaal in de praktijk betekent

Llama 3 405B is een van de weinige grote modellen waarvan de trainingsopzet openbaar is. Meta trainde het op maximaal 16.384 H100-GPU’s, elk met 80 GB geheugen en een stroomverbruik tot 700 watt, acht per server (Bron: Meta). Reken je dat door, dan trekken alleen de GPU’s al ruim 11 megawatt, nog zonder koeling, processors en netwerk.

Op die schaal gaat er voortdurend iets stuk. In een periode van 54 dagen telde Meta 466 onderbrekingen van de training, waarvan 419 onverwacht. Ongeveer 78% daarvan kwam door (vermoedelijke) hardwareproblemen, zoals defecte GPU’s (Bron: Meta). Het team zag zelfs de dagtemperatuur terug in de rekensnelheid: 1 tot 2% schommeling, omdat warme middagen de chips afremden.

GevorderdenOndanks die storingen haalde Meta meer dan 90% effectieve trainingstijd, het deel van de verstreken tijd dat echt aan trainen opging. Dat lukte door de opstart- en checkpointtijd van de trainingsjob in te korten en tools te bouwen die een probleem snel lokaliseren (Bron: Meta). Op deze schaal is herstellen na een crash dus net zo belangrijk als snel rekenen.

Het meest opvallende detail gaat over het stroomnet. Omdat tienduizenden GPU’s tegelijk wachten of tegelijk weer beginnen, schommelde het verbruik van het datacenter met tientallen megawatts in een oogwenk. Meta noemde dat een blijvende uitdaging voor toekomstige, nog grotere modellen (Bron: Meta). Dat raakt aan een discussie die in Nederland ook speelt: AI botst op het stroomnet.

Voor wie geen eigen cluster heeft, is gedeelde rekenkracht de route. Een Drents kenniscentrum dat een model voor waterplanten-herkenning bouwt, traint dat via het Europese netwerk op een supercomputer in Bulgarije. De aanvraag lukte met hulp van het expertisecentrum van de AI-fabriek in Groningen, waarvan de eigen supercomputer pas begin 2028 volledig draait.

Voor developers: data-parallelisme in PyTorch

De standaard in PyTorch is DistributedDataParallel (DDP). Je start één proces per GPU, verpakt je model in DDP(model, device_ids=[rank]), en zorgt (meestal met een DistributedSampler) dat elk proces een eigen deel van de dataset krijgt. De rest gebeurt tijdens de backward pass: DDP synchroniseert de gradiënten tussen alle processen, zodat elk proces daarna met dezelfde gradiënten dezelfde update doet (Bron: PyTorch-tutorial).

Waarom dat efficiënt is: DDP wacht niet tot alle gradiënten klaar zijn. Het groepeert parameters in buckets (grootte instelbaar met bucket_cap_mb) en start de all-reduce voor een bucket zodra die gereed is, terwijl de backward pass voor de rest van het model nog loopt. Rekenen en communiceren overlappen zo (Bron: PyTorch design notes).

GevorderdenDDP repliceert model, gradiënten en optimizer-state op elke GPU; alleen de activaties worden kleiner doordat de batch is verdeeld. Past het model met optimizer niet op één kaart, dan is FSDP de volgende stap: die shardt parameters, gradiënten en optimizer-state en haalt per laag de benodigde gewichten op met all-gather, en ruilt de all-reduce voor reduce-scatter. De ZeRO-paper beschrijft dezelfde drie niveaus van sharding. Hugging Face zet de opties (DDP, FSDP/ZeRO, tensor- en pipeline-parallelisme) naast elkaar in zijnparallelism-overzicht.

Zelf oefenen kan met kleine middelen. De principes werken al op één machine met twee GPU’s, en met torchrun start je de processen zonder eigen launcher. Wie wil zien wat er onder de motorkap gebeurt, kan de gratis cursus van twee uur volgen die freeCodeCamp op 26 juni 2026 uitbracht: instructeur Kian Kyars behandelt het verschil tussen data- en modelparallelisme, handmatig middelen van batches, een all-reduce-zandbak en DDP-hooks (Bron: freeCodeCamp).

Waarom dit ertoe doet

De techniek zelf is al jaren bekend en publiek beschikbaar. De drempel zit in wat eromheen moet: duizenden chips, een netwerk dat ze snel genoeg verbindt, een stroomaansluiting die pieken van tientallen megawatts aankan, en een team dat storingen elke dag opvangt. Daarom ligt het trainen van de grootste modellen bij een handvol, vooral Amerikaanse en Chinese, bedrijven, en investeert Europa in gedeelde AI-fabrieken om onderzoekers en bedrijven toch rekentijd te geven. Ter vergelijking: de Groningse AI-fabriek kost ongeveer 200 miljoen euro, terwijl Meta voor één Llama 3-run al ruim 2.000 servers met elk acht GPU’s inzette. Hoeveel geld er wereldwijd naar zulke datacenters gaat, rekende PwC voor: 31,6 biljoen dollar tot 2050.

Stand van zaken, bijgewerkt 1 oktober 2026

Alles hierboven over hoe data-parallelisme werkt blijft geldig, welke chip er ook draait. De cijfers en tools hieronder zijn de bederfelijke laag.