Een LLM pretrainen: data, compute, scaling laws en kosten

Aan de doelstelling verandert niets. Het model voorspelt nog steeds het volgende token, de loss is nog steeds de cross-entropy uit Hoofdstuk 4 toegepast op de factorisatie van Hoofdstuk 8, de optimiser is nog steeds AdamW uit Hoofdstuk 6. Pretraining is geen nieuw algoritme; het is hetzelfde algoritme uitgevoerd op een corpus dat groot genoeg is om de run te moeten budgetteren. Twee dingen maken dat mogelijk: de labels zijn gratis, omdat het doel voor positie $t$ het token op $t+1$ is en al in de tekst staat; en het laatste deel van Hoofdstuk 6 nam het bezwaar weg, omdat een model met veel meer parameters dan de klassieke regels toestaan niet instort, maar verbetert. Wat eruit komt is een base model — iets dat tekst voortzet in plaats van antwoordt.

Voordat dit allemaal gebudgetteerd kan worden, moet het geteld worden, en het vakgebied telt het met één formule:

waar $N$ het aantal parameters is, $D$ de training tokens en $C$ het totaal aantal floating-point operations. Kaplan et al. leiden dit in twee stappen af.¹ Forward: 2 FLOPs per parameter per token, omdat elke parameter in een matrixvermenigvuldiging één keer per token wordt gebruikt, in één vermenigvuldiging en één optelling. Backward: twee keer de forward, omdat de backward pass uit Hoofdstuk 5 in elke layer twee gradienten berekent — ten opzichte van de inputs van de layer, zodat het signaal blijft doorreizen, en ten opzichte van de weights — elk een matrixvermenigvuldiging ter grootte van de forward, dus $4N$.

Dat is de hele afleiding, en het is de moeite waard om die te controleren in plaats van te geloven. PyTorch levert een echte FLOP-teller mee, torch.utils.flop_counter.FlopCounterMode, die elke bewerking onderschept die een model uitvoert en het werkelijke werk optelt. Draai die over vier ordes van grootte, met de grootste op het meta-device, dat shapes toewijst en geen geheugen:

from torch.utils.flop_counter import FlopCounterMode

counter = FlopCounterMode(display=False)
with counter:                       
    loss = model(x, targets)[1]     
    loss.backward()                 
measured = counter.get_total_flops()
print(measured / (6 * n_params * n_tokens))

De verhouding forward+backward over forward is 3,000, exact, op elke schaal: geen benadering die toevallig goed uitpakt, maar de rekenkundige identiteit hierboven, als rond getal teruggegeven door een teller die niets weet van de afleiding.

Het gemeten totaal ligt vervolgens tussen 3% en 17% boven $6ND$, zodra $N$ de embedding-matrices meetelt — en die clausule doet ertoe, omdat de twee grondleggende papers $N$ anders tellen. Kaplan sluit “all vocabulary and positional embeddings” uit, omdat dat “produces significantly cleaner scaling laws” (§1.3); Chinchilla’s Appendix F zegt “we also count embeddings matrices in the total parameter count”.² Voor een breed vocabulaire en een smalle hidden dimension verschillen de twee met een factor negen, zoals de eerste rij laat zien.

Het resterende gat is wat $6ND$ bewust weglaat: de attention scores. Kaplan’s Eq. (2.2) schrijft de forward-kosten als $2N + 2\,n_{\text{layer}} n_{\text{ctx}} d_{\text{model}}$ en laat de tweede term vallen omdat $d_{\text{model}} \gg n_{\text{ctx}}/12$ — veilig in 2020, minder veilig nu, en de reden dat de verhouding omhoog drijft naarmate $T/d$ groeit — daarom delen twee rijen hier een $T$ van 1.024 en daalt de verhouding, van 1,145 naar 1,100, wanneer $d$ van 768 naar 1.600 gaat. Het is de $O(T^2)$-kost die Hoofdstuk 9 introduceerde en die Hoofdstuk 16 in een prijs verandert.

Compute bepaalt hoe lang een run duurt; geheugen bepaalt of hij kan starten. Train met gewone fp32 AdamW en elke parameter draagt vier getallen: de weight, de gradient, en Adams lopende gemiddelde $m$ en variantie $v$ — de twee gemiddelden die in Hoofdstuk 6 met de hand zijn opgebouwd. Vier getallen van vier bytes elk is 16 bytes per parameter, vóór één enkele activation. Gemeten op een laptop-GPU van 8 GB, met de resident allocation op het punt in de stap waar geen graph meer leeft:

Voorspelling en meting komen binnen 3% overeen. De verrassing zit in de laatste kolom: de activations zijn veel groter dan het model. Hetzelfde model met 5,8 miljoen parameters dat 89 MB persistente state nodig heeft, heeft bij een batch van 128 4.681 MB activations nodig — tweeënvijftig keer het model — en een groot deel daarvan is helemaal niet de transformer. Het zijn de logits, één vector van vocabulairegrootte per token met vier bytes per entry: 512 MB in de laatste rij, 393 MB in de eerste. De vocabulairegrootte werd gekozen in Hoofdstuk 7, en die bepaalt nog steeds wat er op de kaart past.

Welke term domineert hangt af van de vorm van de run, daarom zeggen Micikevicius et al. dat geheugen “is dominated by activations”³ terwijl ZeRO zegt dat een model met 1,5 miljard parameters “at least 24 GB” aan model states alleen nodig heeft.⁴ ZeRO komt via een andere route op dezelfde 16 bytes uit — $2\Psi$ voor fp16 weights, $2\Psi$ voor fp16 gradients, $4\Psi$ elk voor de fp32 master weights en Adams twee moments — wat voor 70 miljard parameters 1,12 terabyte is, de waarde van veertien GPU’s van 80 GB vóór één enkele activation.

Niets daarvan past op frontier-schaal op één device, dus de run wordt op vier manieren tegelijk gesplitst. Data parallelism zet een kopie van het model op elke GPU en middelt de gradienten — de standaard, en degene die ZeRO verbetert door te weigeren redundante kopieën van de optimiser state te bewaren. Tensor parallelism splitst individuele matrices over devices. Pipeline parallelism geeft elk device een aaneengesloten groep layers. Context parallelism splitst de sequence zelf, pas nodig zodra $T$ lang genoeg is dat de attention-term domineert. Tabel 4 van Llama 3 zet alle vier tegelijk neer: tensor 8, context tot 16, pipeline 16, data tot 128, over 16.384 H100-GPU’s.⁵ Dat is alles wat deze cursus erover zal zeggen; distributed training engineering is een eigen semester, en Stanford CS336 is dat semester, colleges 5 tot en met 8, met de code.⁶ Wat de delegatie overleeft is één getal, model FLOPs utilisation — de fractie van de piekrekenkracht van een GPU die een echte run haalt — en dat is wat de nette $6ND$ omzet in wandkloktijd en dus in geld.

In januari 2020 trainden Kaplan et al. een grid van transformers en vonden dat de test loss over meer dan zes ordes van grootte een power law volgt in elk van de drie resources.¹ Hun §1.2 geeft drie gefitte wetten:

met begeleiders $\alpha_D \approx 0.095$ voor data en $\alpha_C^{\min} \approx 0.050$ voor optimaal toegewezen compute. De constanten zijn niet universeel, en de paper zegt dat ook: “the precise numerical values of $N_c$, $C_c^{\min}$ and $D_c$ depend on the vocabulary size and tokenization and hence do not have a fundamental meaning.”

De exponenten zijn piepklein: tien keer zoveel parameters koopt een factor $10^{0.076} \approx 1.19$ van de resterende loss af. Dat klinkt als niets, en dat is het belangrijkste feit hier — de opbrengsten zijn verschrikkelijk en ze stoppen nooit. Een power law met een kleine exponent belooft dat de volgende orde van grootte zal helpen, minder dan de vorige, voor altijd. Compute kopen houdt op een gok te zijn en wordt een aankoop met een gepubliceerde wisselkoers, en dat is precies het argument dat het kapitaal losmaakte.

Toen kwam het voorschrift, en hier zat de paper fout op een manier die de industrie heel veel geld kostte. Kaplan’s Tabel 6 geeft $N_{\text{opt}} \propto C^{0.73}$ en $D_{\text{opt}} \propto C^{0.27}$: tien keer zoveel compute betekent een model dat 5,4 keer groter is en slechts 1,9 keer zoveel tekst krijgt. De abstract is expliciet — “optimally compute-efficient training involves training very large models on a relatively modest amount of data and stopping significantly before convergence.” Het veld deed precies dat: GPT-3 is 175 miljard parameters op 300 miljard tokens,⁷ Gopher 280 miljard op 300 miljard, Megatron-Turing NLG 530 miljard op 270 miljard.² Een halve token tot twee tokens per parameter, over de hele linie.

In maart 2022 trainden Hoffmann et al. meer dan 400 modellen van 70 miljoen tot 16 miljard parameters en kwamen via drie onafhankelijke routes tot de tegenovergestelde conclusie.² Hun Tabel 2 rapporteert de exponent $a$ in $N_{\text{opt}} \propto C^{a}$ als 0,50, 0,49 en 0,46, tegenover Kaplans 0,73. In gewone taal: modelgrootte en training data moeten in gelijke verhouding groeien.

Hun tweede aanpak is degene die de sweep bovenaan dit hoofdstuk reproduceert, op een miljoenste van de schaal: zet een budget vast, train veel groottes exact op dat budget, plot de eind-loss tegen de modelgrootte.

Held-out loss in nats per token, tokens per parameter tussen haakjes, vet voor het beste model per budget; een streepje is een punt dat niet is gedraaid, omdat het budget meer tekst vroeg dan het corpus bevat of de grootte buiten de daar gesweepte reeks viel.

Lees een kolom omlaag: de loss daalt, bereikt een bodem en stijgt weer. Een model kan net zo makkelijk te groot zijn voor zijn budget als te klein — bij $10^{14}$ is de straf voor 665.280 parameters kiezen in plaats van 295.808 gelijk aan 0,08 nats, wat op de hierboven gefitte enveloppe de loss is die een correct gedimensioneerd model met 18% minder compute haalt. De verkeerde vorm kiezen gooit een vijfde van het budget weg. Dat is Chinchilla’s Figure 3 in een middag op één GPU in plaats van met vierhonderd modellen.

Lees nu horizontaal. Bij $10^{13}$ is het beste model het kleinste in de sweep; bij $10^{14}$ is het 295.808 parameters, aan beide kanten ingesloten. Het optimum schuift naar rechts naarmate het budget groeit, en dat is de hele inhoud van de correctie. Fit de derde aanpak van de paper — het oppervlak $L(N,D) = E + A/N^{\alpha} + B/D^{\beta}$ over elke run — en minimaliseer onder de voorwaarde $C = 6ND$:

L(N, D) = 24.7 / N^0.195 + 46.8 / D^0.169       (E fits to ~0; see below)
implied   N_opt ∝ C^0.464
  compare   Chinchilla 0.46-0.50 · Besiroglu 0.513 · Kaplan 0.73

0,46, vanaf een laptop, tegenover Kaplans 0,73. Overeenstemming tot drie cijfers uit een fit met drie budgetten is geluk; overeenstemming tot het eerste cijfer is dat niet. De exponent reist — de constante niet, omdat de token-tot-parameterverhouding bij deze optima 170 tot 540 is, niet 20. Drie redenen, allemaal leerzaam. $E$ fit naar nul omdat de run bij een loss boven 4 nats nergens in de buurt is van de entropievloer die Chinchilla’s fit domineert. Batchgrootte en learning rate stonden vast in plaats van per punt getuned te worden, wat precies de runs benadeelt die de minste stappen krijgen — en dat zijn de grote modellen: bij $10^{13}$ FLOPs krijgt een model met 1,28 miljoen parameters in totaal 159 optimiser-stappen, ver onder de paar duizend die Kaplans $S_{\min}$-term zegt dat elk model nodig heeft. Een scaling law wordt binnen een regime gefit, en deze zit zes ordes van grootte onder Chinchilla’s regime.

Vandaar de abstract van de paper: “current large language models are significantly undertrained”. Chinchilla is de demonstratie — 70 miljard parameters op 1,4 biljoen tokens, dezelfde totale compute als Gophers 280 miljard op 300 miljard, en beter op 51 van 57 MMLU-taken, 67,5% tegen 60%.² Vier keer kleiner, vierënhalf keer meer tekst, hetzelfde geld, beter model.

Twee kanttekeningen bij die beroemde verhouding. “Twintig tokens per parameter” is geen zin in de paper, die alleen zegt dat “for every doubling of model size the number of training tokens should also be doubled”; de 20 is een gevolgtrekking uit Tabel 3 en uit Chinchilla’s eigen 70 B op 1,4 T. En de precisie is slechter dan gepubliceerd: Besiroglu et al. refitten vanaf een digitalisering van Figure 4, vonden dat de oorspronkelijke parameters “fit the reconstructed data poorly” met intervallen “implausibly tight given the number of data points”, en zetten het eerlijke bereik op “between 4 and 40” tokens per parameter.⁸

Eén detail van Chinchilla’s methode lost een belofte in die Hoofdstuk 1 deed over learning-rate schedules. De cosine schedule moet worden afgestemd op het token-budget. Een model dat 10 miljoen tokens zal zien, moet zijn learning rate naar nul laten vervallen bij 10 miljoen tokens; geef het een schedule voor 100 miljoen, stop het vroeg, en je leest een loss halverwege de daling bij een veel te hoge rate. Chinchilla traint elk model op vier cycle lengths om hier precies voor te controleren; de sweep hierboven zet om dezelfde reden zijn schedule vanuit het budget.

Ze zijn het nuttigste empirische resultaat in het vakgebied en ze worden routinematig oversold. Vier grenzen.

Ze voorspellen loss, geen capability. De linkerkant is cross-entropy op held-out tekst. Niets in deze papers rechtvaardigt een claim over of een model correcte SQL zal schrijven, een schadelijk verzoek zal weigeren of een tool zal gebruiken. Dit is opnieuw de les van Hoofdstuk 5: een voorspelling van de loss is geen voorspelling van het gedrag waarvoor je betaalt.

Ze zijn gefit, niet afgeleid. Geen theorie produceert $\alpha_N = 0.076$. De constanten verschuiven met de tokenizer — daarom is een perplexity-vergelijking tussen twee tokenizers betekenisloos, zoals Hoofdstuk 8 uitlegde — en met de datamix, architectuur en optimiser. Elke gepubliceerde wet is een wet van de setup die haar voortbracht, en daarom fit Meta zijn eigen wet opnieuw vóór Llama 3.⁵

Ze veronderstellen een vers token voor elke stap, wat stilzwijgend een oneindig corpus veronderstelt. Muennighoff et al. maten wat er gebeurt wanneer dat opraakt: tot vier epochs van herhaalde data kosten bijna niets — een model met 8,7 miljard parameters op 44 miljard unieke tokens die vier keer gezien werden eindigde met “only 0.5 % higher validation loss” dan hetzelfde model op 178 miljard unieke tokens — terwijl na ongeveer zestien epochs extra compute niets meer koopt.⁹

En niemand traint nog compute-optimal. Chinchilla minimaliseert de kosten van training; een deployed model betaalt daarna grofweg $2N$ FLOPs per generated token, voor altijd. LLaMA 1 zei het ronduit: “given a target level of performance, the preferred model is not the fastest to train but the fastest at inference”.¹⁰ Sardana et al. formaliseerden dat door in plaats daarvan $6ND_{\text{train}} + 2ND_{\text{inference}}$ te minimaliseren, en vonden dat iedereen die een miljard requests verwacht “smaller and longer than Chinchilla-optimal” moet trainen.¹¹ §9.1 van Llama 3 is het daarmee eens: de kleine modellen trainen “far beyond the point of compute optimal training, effectively trading training compute for inference efficiency”.⁵ De verhouding is niet verouderd; ze beantwoordt een vraag die niet meer de vraag is die wordt gesteld.

Loss daalt soepel. Benchmark-scores doen dat soms niet. Wei et al. verzamelden gevallen waarin een taak over ordes van grootte aan training compute op kansniveau blijft en dan springt — driecijferige rekenkunde die in GPT-3 verschijnt rond $2 \times 10^{22}$ FLOPs, MMLU dat boven gokken uitkomt tussen $3$ en $5 \times 10^{23}$ — en gaven het patroon een naam: “an ability is emergent if it is not present in smaller models but is present in larger models”.¹² Als dat een echte eigenschap is, is extrapoleren vanuit goedkope experimenten onveilig, omdat de capability die je koopt misschien op geen enkele schaal bestaat die je kunt betalen om te testen.

Schaeffer, Miranda en Koyejo betoogden dat het meeste ervan een meetartefact is, en het mechanisme is rekenkunde.¹³ Per-token loss daalt soepel, dus de kans dat één token juist is, $\exp(-\mathcal{L})$, verbetert geleidelijk. Score het model met exact string match over een antwoord van $L$ tokens en je verheft die kans tot de macht $L$ — een soepele curve tot een hoge macht verheven lijkt op een afgrond. Vervang de metric door één die tokens telt in plaats van te eisen dat ze allemaal kloppen, op dezelfde outputs, en “the family’s performance smoothly, continuously and predictably improves with increasing scale”.

Hun audit is het getal om te onthouden — “of the 39 preferred metrics in BIG-Bench, at most 5 display emergence”, waarbij twee discontinue metrics meer dan 92% van de geclaimde gevallen verklaren — en hun waarschuwing ook: “nothing in this paper should be interpreted as claiming that large language models cannot display emergent abilities”. Een sprong in een grafiek is bewijs over de metric totdat anders is aangetoond. Hoofdstuk 29 is waar dat jouw probleem wordt, omdat het kiezen van een hard-cutoff metric een beslissing is die je zult nemen zonder het te merken.

Het corpus is het deel van een pretraining-run waar geen vergelijking aan vastzit, en waar de meeste beslissingen met gevolgen zitten. Het ruwe materiaal is een webcrawl: Common Crawl’s archief van augustus 2026 bevat “2.14 billion web pages or 360 TiB of uncompressed content”, één maand ervan, gratis te downloaden.¹⁴ Bijna niets is bruikbaar zoals het is. De T5-paper zegt dat de crawl “largely comprises gibberish or boiler-plate text like menus, error messages, or duplicate text”, en de C4-pipeline die hij introduceerde is een lijst botte heuristieken — behoud alleen regels die eindigen op zinsafsluitende interpunctie, verwijder pagina’s met minder dan drie zinnen, verwijder elke pagina met een accolade of een woord uit een publieke lijst met obsceniteiten — en verandert twintig terabyte maandelijkse tekst in ongeveer 750 GB.¹⁵

Bot is het woord. Dodge et al. auditten wat die filters verwijderen en vonden dat de obsceniteiten-blocklist 42% van documenten in African-American English en 32% in Hispanic-aligned English verwijdert, tegenover 6,2% van White-aligned English, waardoor een corpus overblijft dat voor 97,8% uit de laatste categorie bestaat.¹⁶ Een regel zonder mening over dialect had er toch één.

Daarna deduplication, en dat is geen huishoudelijk werk: Lee et al. vonden een zin van 61 woorden die 61.036 keer werd herhaald in C4, en lieten zien dat dedupliceren de snelheid waarmee modellen “emit memorized text” tienvoudig verlaagt, van 1,9% van generated tokens naar 0,19%.¹⁷ Meer is echter niet beter — het FineWeb-team dedupliceerde globaal over 96 crawls, kreeg 4 biljoen tokens en geen meetbare winst, dedupliceerde daarna elke crawl afzonderlijk, kreeg 20 biljoen, en evenaarde het beste bestaande corpus.¹⁸

Daarna contamination. Llama 3 mat zijn eigen contamination en publiceerde die: 98% van AGIEval, 95% van BIG-Bench Hard en 85% van HellaSwag overlapte met de trainingsset via 8-grams, en voor MMLU was de overlap zo hoog dat “it is impossible to get a good performance gain estimate”.⁵ §4 van GPT-3 rapporteert een filterbug waardoor benchmarks in de data achterbleven zonder weg terug: “because of cost considerations it was infeasible to retrain the model”.⁷

Provenance is het onopgeloste deel. The Pile bevatte een component van 100,96 GiB genaamd Books3 — 12% van het corpus en, volgens de eigen consent-tabel van de paper, boeken uit een private torrent tracker;¹⁹ die ging in augustus 2023 offline na een auteursrechtklacht. De juridische positie per september 2026 is onzeker, en de drie Amerikaanse uitspraken die als trend worden aangehaald spreken elkaar tegen. Alsup vond training op rechtmatig verkregen boeken “exceedingly transformative”, maar oordeelde dat een library gebouwd uit gepirate kopieën dat niet was, en Anthropic schikte die helft voor $1,5 miljard voor 482.460 werken, ongeveer $3.000 per stuk, goedgekeurd op 20 juli 2026.²⁰ Chhabria wees Meta summary judgment toe terwijl hij schreef dat zijn uitspraak “does not stand for the proposition that Meta’s use of copyrighted materials to train its language models is lawful”, maar alleen dat “these plaintiffs made the wrong arguments”.²¹ Bibas, in een uitspraak tegen Ross Intelligence, merkte op dat “only non-generative AI is before me today”.²² Geen Amerikaans hof van beroep heeft over de vraag geoordeeld.

Mensen doen de delen die de loss niet kan. TIME meldde in januari 2023 dat werknemers die toxische tekst labelden voor OpenAI via het bedrijf Sama “between around $1.32 and $2 per hour” mee naar huis namen voor het lezen van passages over seksueel misbruik van kinderen, marteling en zelfbeschadiging, terwijl OpenAI Sama $12,50 per uur voor het werk betaalde; Sama betwist zowel de loonrange als het quotum.²³ Dat is de filtering rond pretraining en niet pretraining zelf — maar het staat op dezelfde factuur, en daar zit een mens.

De elektriciteit is echt en wordt meestal verkeerd geciteerd. Het zorgvuldigste gepubliceerde cijfer is dat van BLOOM: 1.082.990 GPU-uren, 433 MWh en 24,7 ton CO₂-equivalent voor de run, 50,5 inclusief productie en idle nodes;²⁴ Patterson et al. zetten GPT-3 op 1.287 MWh en 552 ton.²⁵ Twee waarschuwingen. BLOOMs voordeel is het Franse kernenergienet van 57 g CO₂ per kWh in plaats van efficiëntie — het gebruikte meer energie dan OPT-175B. En het meest geciteerde emissiecijfer van het veld, Strubell et al.’s 626.155 lb voor een neural architecture search, bleek later 88 keer te hoog, omdat was aangenomen dat de search op volledige modelgrootte draaide terwijl hij op een proxy draaide.²⁶ LBNL’s framing is de verdedigbare: Amerikaanse datacenters gebruikten in 2024 192 TWh, 4,7% van de nationale elektriciteit — een getal dat aan een industrie hangt, niet aan één run.²⁷

De rode draad is wat Bender et al. documentation debt noemden: “putting ourselves in a situation where the datasets are both undocumented and too large to document post hoc”.²⁸ Elk feit hierboven bestaat omdat iemand keek. Voor de corpora achter de modellen die de meeste mensen gebruiken, kan niemand dat.

Nu de rekenkunde die iedereen wil, uit vier geciteerde inputs, zodat wanneer ze verouderen duidelijk is welke vervangen moet worden.

Lees de laatste twee kolommen samen. Voor $10.000 krijg je in twee weken een model met 5 miljard parameters op één gehuurde node. Bij $100.000.000 zegt de rekenkunde 546 miljard parameters — en twaalfduizend H100’s die drie maanden lang aan elkaar zijn gekoppeld, wat je niet met een creditcard huurt. Na ongeveer $100.000 houdt de bindende beperking op geld te zijn en wordt het de cluster.

Voordat je zo’n tabel vertrouwt, test je hem tegen runs waarvan de echte kosten gepubliceerd zijn — llm.c reproduceert GPT-2 124M in “~90 minutes” op een 8×A100-node “for about $20”, en GPT-2 1.6B in 24 uur op een 8×H100-node voor $672.³¹

$672, against what $672 actually bought (llm.c GPT-2 1.6B, one 8xH100 node, 24 h)
  this table predicts:      168 H100-hours   N = 1.41 B params   D = 28.3 B tokens
  what was actually run:    192 H100-hours   N = 1.558 B params  D = 33.6 B tokens

Llama 3 405B, against Meta's own published GPU-hours
  from the paper's 3.8e25 FLOPs at 40 % MFU:   26.67 M H100-hours
  published in Meta's Llama 3.1 model card:    30.84 M H100-hours    ratio 0.86

Beide binnen ongeveer 15%, wat grofweg de nauwkeurigheid is die dit soort schatting verdient en aanzienlijk beter dan de nauwkeurigheid waarmee ze meestal wordt geciteerd.

Het vaakst herhaalde cijfer in dit onderwerp is dat een GPT-2-klasse model dat in 2019 ongeveer $43.000 kostte vandaag voor een paar tientjes kan worden gereproduceerd. De moderne helft is goed gedocumenteerd; de historische helft niet.

Vandaag. Karpathy’s nanochat README: “you can train your own GPT-2 capability LLM ... for only $48 (~2 hours of 8XH100 GPU node) ... On a spot instance, the total cost can be closer to ~$15.”³² “GPT-2 capability” is hier precies en gepubliceerd — beter dan GPT-2’s CORE-score van 0,256525 — op een leaderboard waarvan de beste entry per 14 maart 2026 1,65 uur is. De $48 veronderstelt $3 per GPU-uur, onder Lambda’s lijstprijs van $3,99; op lijstprijs is het dichter bij $64.

In 2019. Er is geen primaire bron: OpenAI publiceerde nooit een duur of kosten. De keten loopt via The Register, februari 2019, dat “256 Google TPU3 cores” rapporteerde zonder prijs en zonder duur; daarna Synced, juni 2019, dat opmerkte dat de hardware $256 per uur kostte op Google Cloud en expliciet stelde dat “OpenAI didn’t specify the training duration”. $43.008 is $256 per uur maal een aangenomen 168 uur waarvoor niemand ooit een bron heeft gegeven.

De eerlijke headline is dus: een model dat GPT-2’s gepubliceerde benchmarkscore evenaart, kan vandaag voor ruim onder de $100 op gehuurde hardware worden getraind, tegenover een kostenpost uit 2019 die nooit is gepubliceerd en waarvan de beroemde schatting rust op een ongefundeerde gok over de duur. De ineenstorting is echt en de moderne helft is reproduceerbaar door iedereen met een creditcard; de ratio is rekenkunde op een getal dat niet bestaat. Dat is de staat van gepubliceerde trainingskosten in het algemeen. De GPT-3-paper bevat helemaal geen dollarbedrag, alleen $3.14 \times 10^{23}$ FLOPs in Tabel D.1;⁷ de Llama 3-paper bevat er ook geen.⁵ Elke trainingskost die je hebt gelezen is een schatting uit een FLOP-count, een hardware-aanname en een prijsaanname — altijd de moeite waard om te vragen van wie.

Wat eruit komt heeft een vast corpus gezien dat op een vast moment is samengesteld, en daaruit volgen twee eigenschappen.

De eerste is de knowledge cutoff. Na de verzamelingsdatum weet het model niets — niet “is onzeker”, maar niets — en het zal vloeiend confabuleren in plaats van dat te zeggen, omdat dat nooit een gedrag was waarop het getraind werd. Llama 3.1’s model card geeft december 2023;³³ elk model heeft er een, en het is een eigenschap van de training data, niet van de deployment. Eromheen werken is een retrieval-probleem, en dat is Hoofdstuk 19.

De tweede is dat een base model aanvult in plaats van antwoordt. Geef het “What is the capital of France?” en een plausibel vervolg is nog een vraag, omdat die string in het corpus het vaakst in een lijst met oefeningen voorkomt.

Een tekstaanvuller is geen assistant. Hij volgt geen instructies, omdat niets in het corpus hem vertelde dat een verzoek moest worden opgevolgd in plaats van voortgezet. Hij heeft geen begrip van een gesprek met twee deelnemers. Hij produceert zonder moeite de waarschijnlijkste voortzetting van een schadelijke prompt, omdat waarschijnlijk het enige is waarvoor hij ooit geoptimaliseerd werd.

Er iets van maken dat antwoordt, vraagt een tweede fase die een fractie van een procent van de eerste kost, en bijna volledig bestaat uit het tonen van voorbeelden van het gedrag dat je wilt en daarna paren van zijn eigen outputs vergelijken. Uit die fase komen instruction following, chat templates, refusals en — dit verrast mensen — het vermogen om een tool aan te roepen. Hoofdstuk 11 is die fase: supervised fine-tuning, RLHF, DPO en GRPO, en de vraag wat “aligned” betekent en wie dat bepaalt.

Ook de moeite waard om naast dit hoofdstuk te lezen: Karpathy’s build-nanogpt en de bijbehorende video, die een volledige GPT-2-reproductie end-to-end doorlopen in een tempo dat dit hoofdstuk niet kan; en Stanford CS324, Large Language Models, waarvan de colleges over data en environmental impact dieper ingaan op materiaal dat deze cursus één keer behandelt en daarna delegeert.