Pretraining av en LLM: data, compute, scaling laws och kostnad

Ingenting i målet förändras. Modellen förutsäger fortfarande nästa token, förlusten är fortfarande cross-entropy från kapitel 4 applicerad på faktoriseringen i kapitel 8, optimeraren är fortfarande AdamW från kapitel 6. Pretraining är inte en ny algoritm; det är samma algoritm körd på en corpus som är stor nog för att körningen måste budgeteras. Två saker gör det möjligt: etiketterna är gratis, eftersom målet för position $t$ är token vid $t+1$ och redan finns i texten; och det sista avsnittet i kapitel 6 tog bort invändningen, eftersom en modell med långt fler parametrar än de klassiska reglerna tillåter inte faller isär, utan blir bättre. Det som kommer ut är en basmodell — något som fortsätter text snarare än svarar.

Innan något av detta kan budgeteras måste det räknas, och fältet räknar det med en formel:

där $N$ är antalet parametrar, $D$ antalet träningstokens och $C$ det totala antalet flyttalsoperationer. Kaplan et al. härleder den i två steg.¹ Forward: 2 FLOPs per parameter per token, eftersom varje parameter i en matrismultiplikation används en gång per token, i en multiplikation och en addition. Backward: dubbelt så mycket som forward, eftersom backward-passet från kapitel 5 beräknar två gradienter i varje lager — med avseende på lagrets indata, så att signalen fortsätter färdas, och med avseende på dess vikter — var och en en matrismultiplikation i samma storlek som forward, så $4N$.

Det är hela härledningen, och den är värd att kontrollera snarare än att bara tro på. PyTorch levererar en verklig FLOP-räknare, torch.utils.flop_counter.FlopCounterMode, som fångar upp varje operation en modell skickar iväg och summerar det faktiska arbetet. Kör den över fyra storleksordningar, den största på meta-enheten, som allokerar former och inget minne:

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))

Forward+backward över forward-kvoten är 3.000, exakt, i varje skala: inte en approximation som råkar vara bra, utan den aritmetiska identiteten ovan returnerad som ett runt tal av en räknare som inte vet något om härledningen.

Den uppmätta totalen ligger sedan mellan 3 % och 17 % över $6ND$, när $N$ räknar embedding-matriserna — och den klausulen spelar roll, eftersom de två grundläggande artiklarna räknar $N$ olika. Kaplan utesluter ”all vocabulary and positional embeddings” eftersom det ”produces significantly cleaner scaling laws” (§1.3); Chinchillas Appendix F säger ”we also count embeddings matrices in the total parameter count”.² För ett brett vokabulär och en smal hidden dimension skiljer de två sig med en faktor nio, som första raden visar.

Restgapet är vad $6ND$ avsiktligt utelämnar: attention-poängen. Kaplans ekv. (2.2) skriver forward-kostnaden som $2N + 2\,n_{\text{layer}} n_{\text{ctx}} d_{\text{model}}$ och släpper den andra termen eftersom $d_{\text{model}} \gg n_{\text{ctx}}/12$ — säkert 2020, mindre säkert nu, och skälet till att kvoten driver uppåt när $T/d$ växer — vilket är varför två rader här delar ett $T$ på 1 024 och kvoten faller, från 1.145 till 1.100, när $d$ går från 768 till 1 600. Det är $O(T^2)$-kostnaden som kapitel 9 introducerade och kapitel 16 gör om till ett pris.

Compute avgör hur lång tid en körning tar; minnet avgör om den kan starta. Träna med vanlig fp32 AdamW och varje parameter bär fyra tal: vikten, dess gradient, och Adams löpande medelvärde $m$ och varians $v$ — de två medelvärdena som byggdes för hand i kapitel 6. Fyra tal på fyra byte vardera är 16 byte per parameter, före en enda aktivering. Uppmätt på en laptop-GPU med 8 GB, med resident allokering vid punkten i steget där ingen graf är vid liv:

Förutsägelse och mätning stämmer inom 3 %. Överraskningen är den sista kolumnen: aktiveringarna får modellen att se liten ut. Samma modell med 5,8 miljoner parametrar som behöver 89 MB persistent state behöver 4 681 MB aktiveringar vid en batch på 128 — femtiotvå gånger modellen — och mycket av det är inte transformer alls. Det är logits, en vektor av vokabulärstorlek per token med fyra byte per post: 512 MB i sista raden, 393 MB i den första. Vokabulärstorleken valdes i kapitel 7, och den avgör fortfarande vad som får plats på kortet.

Vilken term som dominerar beror på körningens form, vilket är varför Micikevicius et al. säger att minne ”is dominated by activations”³ medan ZeRO säger att en modell med 1,5 miljarder parametrar behöver ”at least 24 GB” enbart för model states.⁴ ZeRO når samma 16 byte via en annan väg — $2\Psi$ för fp16-vikter, $2\Psi$ för fp16-gradienter, $4\Psi$ vardera för fp32-mastervikterna och Adams två moment — vilket för 70 miljarder parametrar är 1,12 terabyte, fjorton 80 GB-GPU:er värt innan en enda aktivering.

Inget av detta får plats på en enda enhet i frontier-skala, så körningen delas på fyra sätt samtidigt. Data parallelism lägger en kopia av modellen på varje GPU och medelvärdesbildar gradienterna — standardläget, och det som ZeRO förbättrar genom att vägra behålla redundanta kopior av optimerarens state. Tensor parallelism delar upp enskilda matriser mellan enheter. Pipeline parallelism ger varje enhet en sammanhängande grupp lager. Context parallelism delar själva sekvensen, nödvändigt först när $T$ är tillräckligt lång för att attention-termen ska dominera. Llama 3:s tabell 4 listar alla fyra samtidigt: tensor 8, context upp till 16, pipeline 16, data upp till 128, över 16 384 H100-GPU:er.⁵ Det är allt den här kursen kommer att säga om det; ingenjörsarbetet bakom distribuerad träning är en egen termin, och Stanfords CS336 är den terminen, föreläsning 5 till 8, med koden.⁶ Det som överlever delegeringen är ett enda tal, model FLOPs utilisation — andelen av en GPU:s topparitmetik som en verklig körning uppnår — vilket är det som förvandlar det prydliga $6ND$ till väggklocketid och därmed till pengar.

I januari 2020 tränade Kaplan et al. ett rutnät av transformers och fann att testförlusten följer en potenslag i var och en av de tre resurserna över mer än sex storleksordningar.¹ Deras §1.2 ger tre anpassade lagar:

med följeslagare $\alpha_D \approx 0.095$ för data och $\alpha_C^{\min} \approx 0.050$ för optimalt allokerad compute. Konstanterna är inte universella, och artikeln säger det: ”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.”

Exponenterna är pyttesmå: tio gånger parametrarna köper en faktor $10^{0.076} \approx 1.19$ från den återstående förlusten. Det låter som ingenting, och det är det viktigaste faktumet här — avkastningen är usel och den tar aldrig slut. En potenslag med en liten exponent lovar att nästa storleksordning kommer att hjälpa, mindre än den förra gjorde, för alltid. Att köpa compute slutar vara en chansning och blir ett inköp med en publicerad växelkurs, vilket är exakt argumentet som låste upp kapitalet.

Sedan kom ordinationen, och det är här artikeln hade fel på ett sätt som kostade industrin väldigt mycket pengar. Kaplans tabell 6 ger $N_{\text{opt}} \propto C^{0.73}$ och $D_{\text{opt}} \propto C^{0.27}$: tio gånger compute betyder en modell som är 5,4 gånger större men bara matas med 1,9 gånger så mycket text. Sammanfattningen är explicit — ”optimally compute-efficient training involves training very large models on a relatively modest amount of data and stopping significantly before convergence.” Fältet gjorde exakt det: GPT-3 är 175 miljarder parametrar på 300 miljarder tokens,⁷ Gopher 280 miljarder på 300 miljarder, Megatron-Turing NLG 530 miljarder på 270 miljarder.² En halv token till två tokens per parameter, rakt igenom.

I mars 2022 tränade Hoffmann et al. över 400 modeller från 70 miljoner till 16 miljarder parametrar och nådde motsatt slutsats via tre oberoende vägar.² Deras tabell 2 rapporterar exponenten $a$ i $N_{\text{opt}} \propto C^{a}$ som 0.50, 0.49 och 0.46, mot Kaplans 0.73. I klartext: modellstorlek och träningsdata bör växa i samma proportion.

Deras andra angreppssätt är det som reproduceras av svepet högst upp i det här kapitlet, i en miljondel av skalan: fixa en budget, träna många storlekar vid exakt den budgeten, plotta slutförlust mot modellstorlek.

Held-out-förlust i nats per token, tokens per parameter inom parentes, fetstil för bästa modellen vid varje budget; ett streck är en punkt som inte kördes, eftersom budgeten krävde mer text än corpuset innehåller eller storleken låg utanför dem som sveptes där.

Läs nedåt i en kolumn: förlusten faller, bottnar och klättrar igen. En modell kan vara för stor för sin budget precis lika lätt som för liten — vid $10^{14}$ är straffet för att välja 665 280 parametrar framför 295 808 0,08 nats, vilket på kuvertet som anpassats ovan är den förlust en korrekt dimensionerad modell når med 18 % mindre compute. Att välja fel form kastar bort en femtedel av budgeten. Det är Chinchillas figur 3 på en eftermiddag på en GPU i stället för med fyrahundra modeller.

Läs nu tvärs över. Vid $10^{13}$ är den bästa modellen den minsta som sveptes; vid $10^{14}$ är den 295 808 parametrar, inramad på båda sidor. Optimum flyttar åt höger när budgeten växer, vilket är hela innehållet i korrigeringen. Anpassa artikelns tredje angreppssätt — ytan $L(N,D) = E + A/N^{\alpha} + B/D^{\beta}$ över varje körning — och minimera under villkoret $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, från en laptop, mot Kaplans 0.73. Överensstämmelse på tre siffror från en trebuddgetsanpassning är tur; överensstämmelse på den första är det inte. Exponenten reser — konstanten gör det inte, eftersom token-till-parameter-kvoten vid dessa optima är 170 till 540, inte 20. Tre skäl, alla lärorika. $E$ anpassas till noll eftersom körningen vid en förlust över 4 nats inte är i närheten av entropigolvet som dominerar Chinchillas anpassning. Batchstorlek och learning rate hölls fasta i stället för att trimmas per punkt, vilket missgynnar de körningar som får minst antal steg — och det är de stora modellerna: vid $10^{13}$ FLOPs får en modell med 1,28 miljoner parametrar totalt 159 optimerarsteg, långt under de några tusen som Kaplans $S_{\min}$-term säger att varje modell behöver. En scaling law anpassas inom en regim, och den här ligger sex storleksordningar under Chinchillas.

Därav artikelns sammanfattning: ”current large language models are significantly undertrained”. Chinchilla är demonstrationen — 70 miljarder parametrar på 1,4 biljoner tokens, samma totala compute som Gophers 280 miljarder på 300 miljarder, och slår den på 51 av 57 MMLU-uppgifter, 67,5 % mot 60 %.² Fyra gånger mindre, fyra och en halv gånger mer text, samma pengar, bättre modell.

Två förbehåll om den berömda kvoten. ”Tjugo tokens per parameter” är inte en mening i artikeln, som bara säger att ”for every doubling of model size the number of training tokens should also be doubled”; 20 är en slutsats från tabell 3 och från Chinchillas egna 70 B på 1,4 T. Och dess precision är sämre än publicerat: Besiroglu et al. anpassade om från en digitalisering av figur 4, fann att de ursprungliga parametrarna ”fit the reconstructed data poorly” med intervall ”implausibly tight given the number of data points”, och satte det ärliga intervallet till ”between 4 and 40” tokens per parameter.⁸

En detalj i Chinchillas metod infriar ett löfte som kapitel 1 gav om learning-rate schedules. Cosine-schemat måste matchas mot token-budgeten. En modell som ska se 10 miljoner tokens måste låta sin learning rate falla till noll vid 10 miljoner tokens; ge den ett schema dimensionerat för 100 miljoner, stoppa den tidigt, och du läser en förlust mitt i nedstigningen vid en alldeles för hög nivå. Chinchilla tränar varje modell med fyra cykellängder för att kontrollera exakt detta; svepet ovan sätter sitt schema från budgeten av samma skäl.

De är det mest användbara empiriska resultatet i fältet och de översäljs rutinmässigt. Fyra begränsningar.

De förutsäger förlust, inte förmåga. Vänsterledet är cross-entropy på held-out-text. Ingenting i dessa artiklar ger stöd för ett påstående om huruvida en modell kommer att skriva korrekt SQL, vägra en skadlig begäran eller använda ett tool. Det här är lärdomen från kapitel 5 igen: en förutsägelse av förlusten är inte en förutsägelse av beteendet du betalar för.

De är anpassade, inte härledda. Ingen teori producerar $\alpha_N = 0.076$. Konstanterna flyttar sig med tokenizer — vilket är varför en perplexity-jämförelse mellan två tokenizers är meningslös, som kapitel 8 förklarade — och med datamixen, arkitekturen och optimeraren. Varje publicerad lag är en lag för den uppställning som producerade den, vilket är varför Meta anpassade sin egen före Llama 3.⁵

De antar en färsk token för varje steg, vilket tyst antar ett oändligt corpus. Muennighoff et al. mätte vad som händer när det tar slut: upp till fyra epoker av upprepade data kostar nästan ingenting — en modell med 8,7 miljarder parametrar på 44 miljarder unika tokens sedda fyra gånger slutade med ”only 0.5 % higher validation loss” än samma modell på 178 miljarder unika — medan ytterligare compute efter omkring sexton epoker inte köper något.⁹

Och ingen tränar compute-optimal längre. Chinchilla minimerar kostnaden för träning; en distribuerad modell betalar sedan ungefär $2N$ FLOPs per genererad token, för alltid. LLaMA 1 sade det rakt ut: ”given a target level of performance, the preferred model is not the fastest to train but the fastest at inference”.¹⁰ Sardana et al. formaliserade det genom att minimera $6ND_{\text{train}} + 2ND_{\text{inference}}$ i stället, och fann att den som väntar sig en miljard förfrågningar bör träna ”smaller and longer than Chinchilla-optimal”.¹¹ Llama 3:s §9.1 håller med: dess små modeller tränas ”far beyond the point of compute optimal training, effectively trading training compute for inference efficiency”.⁵ Kvoten är inte föråldrad; den svarar på en fråga som inte längre är den som ställs.

Förlusten faller jämnt. Benchmark-poäng gör det ibland inte. Wei et al. samlade fall där en uppgift ligger på slumpnivå över storleksordningar av training compute och sedan hoppar — tresiffrig aritmetik som dyker upp i GPT-3 vid ungefär $2 \times 10^{22}$ FLOPs, MMLU som stiger över gissning mellan $3$ och $5 \times 10^{23}$ — och gav mönstret ett namn: ”an ability is emergent if it is not present in smaller models but is present in larger models”.¹² Om det är en verklig egenskap är extrapolering från billiga experiment osäker, eftersom förmågan du köper kanske inte finns i någon skala du har råd att testa.

Schaeffer, Miranda och Koyejo hävdade att det mesta är en mätartefakt, och mekanismen är aritmetisk.¹³ Per-token-förlusten faller jämnt, så sannolikheten att en token är rätt, $\exp(-\mathcal{L})$, förbättras gradvis. Poängsätt modellen med exakt strängmatchning över ett $L$-token-svar och du höjer den sannolikheten till potensen $L$ — en jämn kurva upphöjd till en stor potens ser ut som en klippa. Byt till ett mått som räknar tokens i stället för att kräva alla, på samma utdata, och ”the family's performance smoothly, continuously and predictably improves with increasing scale”.

Deras granskning är talet att minnas — ”of the 39 preferred metrics in BIG-Bench, at most 5 display emergence”, med två diskontinuerliga mått som står för över 92 % av de påstådda fallen — och det är också deras varning: ”nothing in this paper should be interpreted as claiming that large language models cannot display emergent abilities”. Ett hopp i ett diagram är bevis om måttet tills motsatsen visats. Kapitel 29 är där det blir ditt problem, eftersom valet av ett hard-cutoff-mått är ett beslut du kommer att fatta utan att märka det.

Corpuset är den del av en pretraining-körning som inte har någon ekvation kopplad till sig, och där de flesta av de följdrika besluten finns. Råmaterialet är en webbcrawl: Common Crawls arkiv från augusti 2026 innehåller ”2.14 billion web pages or 360 TiB of uncompressed content”, en månad av det, gratis att ladda ned.¹⁴ Nästan inget är användbart som det står. T5-artikeln säger att crawlen ”largely comprises gibberish or boiler-plate text like menus, error messages, or duplicate text”, och C4-pipelinen den introducerade är en lista med trubbiga heuristiker — behåll bara rader som slutar med avslutande skiljetecken, släpp sidor med färre än tre meningar, släpp varje sida som innehåller en klammerparentes eller ett ord från en offentlig lista över obsceniteter — vilket förvandlar tjugo terabyte månadstext till omkring 750 GB.¹⁵

Trubbig är ordet. Dodge et al. granskade vad dessa filter tar bort och fann att obscenitetsblocklistan raderar 42 % av dokument på afroamerikansk engelska och 32 % på hispanic-aligned engelska, mot 6,2 % av white-aligned engelska, vilket lämnar ett corpus där 97,8 % tillhör den sista kategorin.¹⁶ En regel utan åsikt om dialekt hade en.

Sedan deduplication, vilket inte är städning: Lee et al. fann en mening på 61 ord som upprepades 61 036 gånger i C4, och visade att deduplicering minskar takten med vilken modeller ”emit memorized text” tiofaldigt, från 1,9 % av genererade tokens till 0,19 %.¹⁷ Mer är dock inte bättre — FineWebs team deduplicerade globalt över 96 crawls, fick 4 biljoner tokens och ingen mätbar förbättring, deduplicerade sedan varje crawl separat, fick 20 biljoner, och matchade det bästa befintliga corpuset.¹⁸

Sedan contamination. Llama 3 mätte sin egen och publicerade den: 98 % av AGIEval, 95 % av BIG-Bench Hard och 85 % av HellaSwag överlappade träningsmängden med 8-grams, och för MMLU en överlappning så hög att ”it is impossible to get a good performance gain estimate”.⁵ GPT-3:s §4 rapporterar en filtreringsbugg som lämnade benchmarks i datan utan väg tillbaka: ”because of cost considerations it was infeasible to retrain the model”.⁷

Proveniens är den olösta delen. The Pile levererade en komponent på 100,96 GiB kallad Books3 — 12 % av corpuset och, enligt artikelns egen samtyckestabell, böcker från en privat torrenttracker;¹⁹ den togs offline i augusti 2023 efter ett upphovsrättsklagomål. Den rättsliga positionen i september 2026 är olöst, och de tre amerikanska domar som nämns som en trend är oense med varandra. Alsup fann att träning på lagligt förvärvade böcker var ”exceedingly transformative” samtidigt som han höll fast vid att ett bibliotek byggt från piratkopior inte var det, och Anthropic förlikade den halvan för $1,5 miljarder som täckte 482 460 verk, ungefär $3 000 vardera, godkänt 20 juli 2026.²⁰ Chhabria beviljade Meta summary judgment samtidigt som han skrev att hans avgörande ”does not stand for the proposition that Meta's use of copyrighted materials to train its language models is lawful”, bara att ”these plaintiffs made the wrong arguments”.²¹ Bibas, i ett avgörande mot Ross Intelligence, noterade att ”only non-generative AI is before me today”.²² Ingen amerikansk appellationsdomstol har avgjort frågan.

Människor gör de delar som förlusten inte kan. TIME rapporterade i januari 2023 att arbetare som märkte toxisk text åt OpenAI via företaget Sama fick hem ”between around $1.32 and $2 per hour” för att läsa passager som beskrev sexuella övergrepp mot barn, tortyr och självskada, medan OpenAI betalade Sama $12,50 i timmen för arbetet; Sama bestrider både löneintervallet och kvoten.²³ Det är filtreringen runt pretraining snarare än pretraining i sig — men det står på samma faktura, och det är där en människa sitter.

Elektriciteten är verklig och oftast felciterad. Den noggrannaste publicerade siffran är BLOOM:s: 1 082 990 GPU-timmar, 433 MWh och 24,7 ton CO₂-ekvivalenter för körningen, 50,5 när tillverkning och idle-noder räknas;²⁴ Patterson et al. sätter GPT-3 till 1 287 MWh och 552 ton.²⁵ Två varningar. BLOOM:s fördel är det franska kärnkraftsnätet på 57 g CO₂ per kWh snarare än effektivitet — den använde mer energi än OPT-175B. Och fältets mest citerade utsläppssiffra, Strubell et al.:s 626 155 lb för en neural architecture search, visades senare vara 88 gånger för hög, eftersom den antog att sökningen kördes i full modellstorlek när den kördes på en proxy.²⁶ LBNL:s inramning är den försvarbara: amerikanska datacenter använde 192 TWh 2024, 4,7 % av landets el — en siffra kopplad till en industri, inte till någon enskild körning.²⁷

Den röda tråden är vad Bender et al. kallade documentation debt: ”putting ourselves in a situation where the datasets are both undocumented and too large to document post hoc”.²⁸ Varje faktum ovan finns för att någon tittade. För corpora bakom de modeller de flesta använder kan ingen göra det.

Nu aritmetiken alla vill ha, från fyra citerade indata, så att det är uppenbart vad som ska bytas ut när de blir inaktuella.

Läs de två sista kolumnerna tillsammans. För $10 000 får du en modell med 5 miljarder parametrar på en hyrd nod på två veckor. Vid $100 000 000 säger aritmetiken 546 miljarder parametrar — och tolv tusen H100:or ihopkopplade i tre månader, vilket inte är något du hyr med kreditkort. Efter ungefär $100 000 slutar den bindande begränsningen vara pengar och blir klustret.

Innan du litar på en sådan tabell, testa den mot körningar vars verkliga kostnad är publicerad — llm.c reproducerar GPT-2 124M på ”~90 minutes” på en 8×A100-nod ”for about $20”, och GPT-2 1.6B på 24 timmar på en 8×H100-nod för $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

Båda inom ungefär 15 %, vilket är ungefär den noggrannhet den här typen av estimat förtjänar och betydligt bättre än den noggrannhet den brukar citeras med.

Den mest upprepade siffran i det här ämnet är att en GPT-2-klassmodell som kostade omkring $43 000 år 2019 kan reproduceras i dag för några tiotal dollar. Den moderna halvan är väldokumenterad; den historiska halvan är det inte.

I dag. Karpathys 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” här är precist och publicerat — att slå GPT-2:s CORE-poäng på 0,256525 — på en leaderboard vars bästa bidrag den 14 mars 2026 är 1,65 timmar. $48 antar $3 per GPU-timme, under Lambdas listpris $3,99; vid listpris är det närmare $64.

År 2019. Det finns ingen primärkälla: OpenAI publicerade aldrig en varaktighet eller kostnad. Kedjan går via The Register, februari 2019, som rapporterar ”256 Google TPU3 cores” utan pris och utan varaktighet; sedan Synced, juni 2019, som noterar att hårdvaran kostade $256 i timmen på Google Cloud och uttryckligen säger att ”OpenAI didn't specify the training duration”. $43 008 är $256 i timmen gånger antagna 168 timmar som ingen någonsin har källbelagt.

Så den ärliga rubriken är: en modell som matchar GPT-2:s publicerade benchmark-poäng kan tränas i dag för långt under $100 på hyrd hårdvara, mot en kostnad 2019 som aldrig publicerades och vars berömda estimat vilar på en okällad gissning om varaktigheten. Kollapsen är verklig och den moderna halvan kan reproduceras av vem som helst med ett kreditkort; kvoten är aritmetik på ett tal som inte finns. Det är läget för publicerade träningskostnader i allmänhet. GPT-3-artikeln innehåller inget dollarbelopp alls, bara $3.14 \times 10^{23}$ FLOPs i tabell D.1;⁷ Llama 3-artikeln innehåller inget heller.⁵ Varje träningskostnad du har läst är ett estimat från ett FLOP-tal, ett hårdvaruantagande och ett prisantagande — alltid värt att fråga vems.

Det som kommer ut har sett ett fast corpus sammanställt vid ett fast ögonblick, och två egenskaper följer.

Den första är knowledge cutoff. Efter insamlingsdatumet vet modellen ingenting — inte ”är osäker”, ingenting — och den kommer att fabulera flytande i stället för att säga det, eftersom att säga det aldrig var ett beteende den tränades på. Llama 3.1:s model card anger december 2023;³³ varje modell har en, och det är en egenskap hos träningsdatan, inte deployment. Att arbeta runt det är ett retrieval-problem, vilket är kapitel 19.

Den andra är att en basmodell kompletterar snarare än svarar. Ge den ”Vad är Frankrikes huvudstad?” och en plausibel fortsättning är en annan fråga, eftersom den strängen i corpuset oftast förekommer i en lista med övningar.

En textkompletterare är inte en assistant. Den följer inte instruktioner, eftersom ingenting i corpuset sade att en begäran borde lydas i stället för fortsättas. Den har ingen föreställning om ett samtal med två deltagare. Den producerar gärna den mest sannolika fortsättningen på en skadlig prompt, eftersom sannolik var det enda den någonsin optimerades för.

Att göra den till något som svarar kräver ett andra steg som kostar en bråkdel av en procent av det första, och som nästan helt består av att visa den exempel på beteendet du vill ha och sedan jämföra par av dess egna utdata. Det steget är där instruktionföljning, chat templates, vägran och — vilket överraskar folk — förmågan att anropa ett tool alla kommer ifrån. Kapitel 11 är det steget: supervised fine-tuning, RLHF, DPO och GRPO, och frågan om vad ”aligned” betyder och vem som bestämmer.

Också värt att läsa vid sidan av det här kapitlet: Karpathys build-nanogpt och den tillhörande videon, som går igenom en full GPT-2-reproduktion från början till slut i ett tempo det här kapitlet inte kan hålla; och Stanford CS324, Large Language Models, vars föreläsningar om data och miljöpåverkan går djupare än avsnittet ovan i material som den här kursen behandlar en gång och delegerar.