LLM की pretraining: डेटा, compute, scaling laws और लागत

Objective में कुछ नहीं बदलता। Model अब भी next token predict करता है, loss अब भी Chapter 4 का cross-entropy है जिसे Chapter 8 के factorisation पर लगाया गया है, optimiser अब भी Chapter 6 का AdamW है। Pretraining कोई नया algorithm नहीं है; यह वही algorithm है जिसे इतने बड़े corpus पर चलाया गया है कि run का budget बनाना पड़ता है। दो बातें इसे संभव बनाती हैं: labels मुफ्त हैं, क्योंकि position $t$ का target $t+1$ पर token है और वह text में पहले से मौजूद है; और Chapter 6 के आखिरी section ने objection हटा दिया था, क्योंकि classical rules से कहीं अधिक parameters वाला model टूटता नहीं, बेहतर होता है। जो निकलता है वह base model है — कुछ ऐसा जो answer देने के बजाय text जारी रखता है।

इनमें से किसी भी चीज़ का budget बनने से पहले उसे count करना पड़ता है, और field इसे एक formula से count करती है:

जहाँ $N$ parameter count है, $D$ training tokens हैं और $C$ total floating-point operations हैं। Kaplan et al. इसे दो steps में derive करते हैं।¹ Forward: प्रति parameter प्रति token 2 FLOPs, क्योंकि matrix multiply में हर parameter प्रति token एक बार use होता है, एक multiply और एक add में। Backward: forward का दोगुना, क्योंकि Chapter 5 का backward pass हर layer पर दो gradients compute करता है — layer के inputs के respect में, ताकि signal आगे यात्रा करता रहे, और उसके weights के respect में — हर एक forward जितने size का matrix multiply है, इसलिए $4N$।

यही पूरी derivation है, और इसे मानने के बजाय जाँचना चाहिए। PyTorch एक real FLOP counter, torch.utils.flop_counter.FlopCounterMode, ship करता है, जो model द्वारा dispatch किए गए हर operation को intercept करता है और actual work को total करता है। इसे चार orders of magnitude पर run करें, सबसे बड़े को meta device पर, जो shapes allocate करता है और memory नहीं:

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 over forward ratio 3.000 है, हर scale पर exactly: कोई approximation नहीं जो संयोग से अच्छी निकली हो, बल्कि ऊपर की arithmetic identity एक ऐसे counter द्वारा round number के रूप में लौटाई गई है जिसे derivation के बारे में कुछ नहीं पता।

Measured total फिर $6ND$ से 3 % और 17 % ऊपर बैठता है, जब $N$ embedding matrices को count करता है — और यह clause मायने रखता है, क्योंकि दो founding papers $N$ को अलग-अलग count करते हैं। Kaplan “all vocabulary and positional embeddings” को exclude करता है क्योंकि ऐसा करने से “significantly cleaner scaling laws” बनते हैं (§1.3); Chinchilla का Appendix F कहता है “we also count embeddings matrices in the total parameter count”.² Wide vocabulary और narrow hidden dimension के लिए दोनों में नौ गुना फर्क है, जैसा पहली row दिखाती है।

Residual gap वह है जिसे $6ND$ जानबूझकर छोड़ देता है: attention scores। Kaplan की Eq. (2.2) forward cost को $2N + 2\,n_{\text{layer}} n_{\text{ctx}} d_{\text{model}}$ लिखती है और second term छोड़ देती है क्योंकि $d_{\text{model}} \gg n_{\text{ctx}}/12$ — 2020 में safe, अब कम safe, और यही वजह है कि $T/d$ बढ़ने पर ratio ऊपर drift करता है — इसी कारण यहाँ दो rows में $T$ 1,024 है और ratio गिरता है, 1.145 से 1.100 तक, जब $d$ 768 से 1,600 हो जाता है। यह वही $O(T^2)$ cost है जिसे Chapter 9 ने introduce किया और Chapter 16 price में बदलता है।

Compute तय करता है कि run कितना लंबा चलेगा; memory तय करती है कि वह शुरू भी हो सकता है या नहीं। Plain fp32 AdamW के साथ train करें और हर parameter चार numbers ढोता है: weight, उसका gradient, और Adam का running mean $m$ और variance $v$ — वे दो averages जिन्हें Chapter 6 में हाथ से बनाया गया था। चार bytes वाले चार numbers यानी 16 bytes per parameter, किसी भी activation से पहले। 8 GB laptop GPU पर measured, step के उस point पर resident allocation लेते हुए जहाँ कोई graph alive नहीं है:

Prediction और measurement 3 % के भीतर agree करते हैं। Surprise आखिरी column है: activations model को dwarf कर देते हैं। वही 5.8-million-parameter model जिसे persistent state के लिए 89 MB चाहिए, batch 128 पर 4,681 MB activations चाहता है — model का बावन गुना — और इसका बड़ा हिस्सा transformer बिल्कुल नहीं है। यह logits हैं, प्रति token vocabulary size का एक vector, प्रति entry चार bytes: आखिरी row में 512 MB, पहली में 393 MB। Vocabulary size Chapter 7 में चुना गया था, और वह अब भी तय कर रहा है कि card पर क्या fit होगा।

कौन-सा term dominate करता है यह run के shape पर निर्भर करता है, इसलिए Micikevicius et al. कहते हैं memory “is dominated by activations”³ जबकि ZeRO कहता है कि 1.5-billion-parameter model को सिर्फ model states के लिए “at least 24 GB” चाहिए।⁴ ZeRO वही 16 bytes दूसरे रास्ते से पहुँचता है — fp16 weights के लिए $2\Psi$, fp16 gradients के लिए $2\Psi$, fp32 master weights और Adam के दो moments में से हर एक के लिए $4\Psi$ — जो 70 billion parameters के लिए 1.12 terabytes है, किसी भी activation से पहले चौदह 80 GB GPUs के बराबर।

Frontier scale पर इनमें से कुछ भी एक device पर fit नहीं होता, इसलिए run को एक साथ चार तरीकों से split किया जाता है। Data parallelism हर GPU पर model की copy रखता है और gradients को average करता है — default, और वही जिसे ZeRO optimiser state की redundant copies रखने से इनकार करके बेहतर बनाता है। Tensor parallelism individual matrices को devices में split करता है। Pipeline parallelism हर device को layers का contiguous group देता है। Context parallelism sequence को ही split करता है, जिसकी जरूरत तभी पड़ती है जब $T$ इतना लंबा हो जाए कि attention term dominate करे। Llama 3 की Table 4 चारों को एक साथ list करती है: tensor 8, context up to 16, pipeline 16, data up to 128, कुल 16,384 H100 GPUs पर।⁵ यह course इसके बारे में बस इतना ही कहेगा; distributed training engineering अपने आप में एक semester है, और Stanford का CS336 वही semester है, lectures 5 से 8, code के साथ।⁶ Delegation के बाद जो बचता है वह एक number है, model FLOPs utilisation — GPU की peak arithmetic का वह fraction जो real run achieve करता है — जो साफ-सुथरे $6ND$ को wall-clock time और इसलिए money में बदलता है।

January 2020 में Kaplan et al. ने transformers की grid train की और पाया कि test loss तीनों resources में से हर एक के साथ छह से अधिक orders of magnitude पर power law follow करता है।¹ उनका §1.2 तीन fitted laws देता है:

साथ में data के लिए $\alpha_D \approx 0.095$ और optimally allocated compute के लिए $\alpha_C^{\min} \approx 0.050$। Constants universal नहीं हैं, और paper खुद ऐसा कहता है: “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.”

Exponents tiny हैं: दस गुना parameters remaining loss से $10^{0.076} \approx 1.19$ factor खरीदते हैं। यह कुछ भी नहीं जैसा लगता है, और यही यहाँ सबसे important fact है — returns खराब हैं और वे कभी रुकते नहीं। Small exponent वाला power law वादा करता है कि अगला order of magnitude मदद करेगा, पिछले से कम, हमेशा। Compute खरीदना gamble रहना बंद कर देता है और published exchange rate वाली purchase बन जाता है, और यही ठीक वह argument था जिसने capital unlock किया।

फिर prescription आया, और यहाँ paper इस तरह गलत था जिसने industry को बहुत पैसा खर्च करवाया। Kaplan की Table 6 $N_{\text{opt}} \propto C^{0.73}$ और $D_{\text{opt}} \propto C^{0.27}$ देती है: दस गुना compute का मतलब 5.4 गुना बड़ा model जिसे सिर्फ 1.9 गुना ज्यादा text खिलाया जाए। Abstract explicit है — “optimally compute-efficient training involves training very large models on a relatively modest amount of data and stopping significantly before convergence.” Field ने exactly यही किया: GPT-3 175 billion parameters on 300 billion tokens,⁷ Gopher 280 billion on 300 billion, Megatron-Turing NLG 530 billion on 270 billion।² Across the board, प्रति parameter आधे token से दो tokens।

March 2022 में Hoffmann et al. ने 70 million से 16 billion parameters तक के 400 से अधिक models train किए और तीन independent routes से उल्टा conclusion पाया।² उनकी Table 2 $N_{\text{opt}} \propto C^{a}$ में exponent $a$ को 0.50, 0.49 और 0.46 report करती है, Kaplan के 0.73 के against। Plain terms में: model size और training data समान proportion में बढ़ने चाहिए।

उनका दूसरा approach वही है जिसे इस chapter के ऊपर वाले sweep ने scale के millionth हिस्से पर reproduce किया: budget fix करें, कई sizes को exactly उसी budget पर train करें, final loss को model size के against plot करें।

Held-out loss nats per token में, brackets में tokens per parameter, हर budget पर best model bold; dash ऐसा point है जिसे run नहीं किया गया, क्योंकि budget ने corpus से अधिक text माँगा या size वहाँ sweep किए गए sizes से बाहर था।

Column में नीचे पढ़ें: loss गिरता है, bottom out होता है और फिर चढ़ता है। एक model अपने budget के लिए उतना ही आसानी से बहुत बड़ा हो सकता है जितना बहुत छोटा — $10^{14}$ पर 295,808 की जगह 665,280 parameters चुनने की penalty 0.08 nats है, जो ऊपर fitted envelope पर वह loss है जिसे सही size का model 18 % कम compute से reach करता है। Wrong shape चुनना budget का पाँचवाँ हिस्सा फेंक देता है। यह Chinchilla की Figure 3 है, चार सौ models के बजाय एक GPU पर एक afternoon में।

अब across पढ़ें। $10^{13}$ पर best model swept में सबसे छोटा है; $10^{14}$ पर यह 295,808 parameters है, दोनों sides से bracketed। Budget बढ़ने पर optimum दाईं ओर move करता है, और correction की पूरी बात यही है। Paper का third approach fit करें — हर run पर surface $L(N,D) = E + A/N^{\alpha} + B/D^{\beta}$ — और $C = 6ND$ के subject में minimise करें:

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, laptop से, Kaplan के 0.73 के against। Three-budget fit से तीन digits तक agreement luck है; first digit तक agreement नहीं। Exponent यात्रा करता है — constant नहीं, क्योंकि इन optima पर token-to-parameter ratio 170 से 540 है, 20 नहीं। तीन वजहें, सभी instructive। $E$ zero fit होता है क्योंकि 4 nats से ऊपर loss पर run उस entropy floor के पास कहीं नहीं है जो Chinchilla के fit को dominate करता है। Batch size और learning rate को per point tune करने के बजाय fixed रखा गया, जो उन runs को handicap करता है जिन्हें सबसे कम steps मिलते हैं — और वे large models हैं: $10^{13}$ FLOPs पर 1.28-million-parameter model को कुल 159 optimiser steps मिलते हैं, उन few thousand से बहुत नीचे जिन्हें Kaplan का $S_{\min}$ term किसी भी model के लिए जरूरी बताता है। Scaling law एक regime के अंदर fit होता है, और यह Chinchilla से छह orders of magnitude नीचे बैठता है।

इसीलिए paper का abstract: “current large language models are significantly undertrained”. Chinchilla demonstration है — 70 billion parameters on 1.4 trillion tokens, Gopher के 280 billion on 300 billion जितना same total compute, 57 में से 51 MMLU tasks पर उसे beat करता हुआ, 60 % के against 67.5 %।² चार गुना छोटा, साढ़े चार गुना ज्यादा text, वही पैसा, बेहतर model।

उस famous ratio पर दो caveats। “Twenty tokens per parameter” paper में sentence नहीं है, जो केवल इतना कहता है कि “for every doubling of model size the number of training tokens should also be doubled”; 20 Table 3 और Chinchilla के अपने 70 B on 1.4 T से inference है। और इसकी precision published से खराब है: Besiroglu et al. ने Figure 4 की digitisation से refit किया, पाया कि original parameters “fit the reconstructed data poorly” और intervals “implausibly tight given the number of data points” थे, और honest range को “between 4 and 40” tokens per parameter रखा।⁸

Chinchilla की method की एक detail Chapter 1 के learning-rate schedules वाले वादे को पूरा करती है। Cosine schedule को token budget से match करना पड़ता है। जो model 10 million tokens देखेगा उसे अपना learning rate 10 million tokens पर zero तक decay करना चाहिए; उसे 100 million के लिए sized schedule दें, जल्दी रोक दें, और आप descent के बीच का loss पढ़ रहे हैं, ऐसे rate पर जो बहुत ज्यादा है। Chinchilla exactly इसे control करने के लिए हर model को चार cycle lengths पर train करता है; ऊपर का sweep उसी कारण अपना schedule budget से set करता है।

वे field का सबसे useful empirical result हैं और routinely oversold हैं। चार limits।

वे loss predict करते हैं, capability नहीं। Left-hand side held-out text पर cross-entropy है। इन papers में कुछ भी यह claim करने की license नहीं देता कि model correct SQL लिखेगा, harmful request refuse करेगा या tool use करेगा। यह Chapter 5 का lesson फिर है: loss की prediction उस behaviour की prediction नहीं है जिसके लिए आप pay कर रहे हैं।

वे fitted हैं, derived नहीं। कोई theory $\alpha_N = 0.076$ produce नहीं करती। Constants tokenizer के साथ move करते हैं — इसी कारण दो tokenizers के बीच perplexity comparison meaningless है, जैसा Chapter 8 ने समझाया — और data mixture, architecture और optimiser के साथ भी। हर published law उस setup का law है जिसने उसे produce किया, इसलिए Meta ने Llama 3 से पहले अपना खुद का refit किया।⁵

वे हर step के लिए fresh token assume करते हैं, जो चुपचाप infinite corpus assume करता है। Muennighoff et al. ने measure किया कि जब यह खत्म हो जाता है तो क्या होता है: repeated data के चार epochs तक लगभग कुछ cost नहीं होता — 44 billion unique tokens पर 8.7-billion-parameter model, जिन्हें चार बार देखा गया, 178 billion unique tokens वाले same model से “only 0.5 % higher validation loss” पर finish हुआ — जबकि करीब sixteen epochs के बाद additional compute कुछ नहीं खरीदता।⁹

और अब कोई compute-optimal train नहीं करता। Chinchilla training की cost minimise करता है; deployed model फिर generated token प्रति roughly $2N$ FLOPs देता है, हमेशा। LLaMA 1 ने साफ कहा: “given a target level of performance, the preferred model is not the fastest to train but the fastest at inference”.¹⁰ Sardana et al. ने इसके बजाय $6ND_{\text{train}} + 2ND_{\text{inference}}$ minimise करके formalise किया, और पाया कि billion requests expect करने वाले किसी भी व्यक्ति को “smaller and longer than Chinchilla-optimal” train करना चाहिए।¹¹ Llama 3 का §9.1 agree करता है: उसके small models “far beyond the point of compute optimal training, effectively trading training compute for inference efficiency” train होते हैं।⁵ Ratio obsolete नहीं है; वह ऐसे सवाल का जवाब देता है जो अब पूछा नहीं जा रहा।

Loss smoothly गिरता है। Benchmark scores कभी-कभी नहीं। Wei et al. ने ऐसे cases collect किए जहाँ कोई task training compute के orders of magnitude तक chance पर बैठा रहता है और फिर jump करता है — GPT-3 में लगभग $2 \times 10^{22}$ FLOPs पर three-digit arithmetic दिखना, MMLU का $3$ और $5 \times 10^{23}$ के बीच guessing से ऊपर उठना — और pattern को नाम दिया: “an ability is emergent if it is not present in smaller models but is present in larger models”.¹² अगर यह real property है, तो cheap experiments से extrapolate करना unsafe है, क्योंकि आप जो capability खरीद रहे हैं वह शायद ऐसे किसी scale पर exist ही न करे जिसे test करना आप afford कर सकें।

Schaeffer, Miranda और Koyejo ने argue किया कि इसका अधिकांश measurement का artefact है, और mechanism arithmetic है।¹³ Per-token loss smoothly गिरता है, इसलिए एक token के सही होने की probability, $\exp(-\mathcal{L})$, धीरे-धीरे improve करती है। Model को exact string match से score करें, $L$-token answer पर, और आप उस probability को $L$ power तक raise कर देते हैं — large power पर उठी smooth curve cliff जैसी दिखती है। उसी outputs पर ऐसा metric लगाएँ जो सभी tokens मांगने के बजाय tokens count करता हो, और “the family's performance smoothly, continuously and predictably improves with increasing scale”.

उनका audit याद रखने वाला number है — “of the 39 preferred metrics in BIG-Bench, at most 5 display emergence”, और claimed cases के 92 % से अधिक के लिए दो discontinuous metrics जिम्मेदार हैं — और उनकी caution भी: “nothing in this paper should be interpreted as claiming that large language models cannot display emergent abilities”. Chart में jump metric के बारे में evidence है, जब तक कुछ और साबित न हो। Chapter 29 वह जगह है जहाँ यह आपकी problem बनता है, क्योंकि hard-cutoff metric चुनना ऐसा decision है जिसे आप notice किए बिना करेंगे।

Corpus pretraining run का वह हिस्सा है जिसके साथ कोई equation attached नहीं है, और जहाँ अधिकतर consequential decisions रहते हैं। Raw material web crawl है: Common Crawl के August 2026 archive में “2.14 billion web pages or 360 TiB of uncompressed content” है, इसका एक महीना, download के लिए free।¹⁴ जैसा है वैसा लगभग कुछ भी usable नहीं है। T5 paper कहता है कि crawl “largely comprises gibberish or boiler-plate text like menus, error messages, or duplicate text” है, और उसने जो C4 pipeline introduce की वह blunt heuristics की list है — केवल terminal punctuation पर खत्म होने वाली lines रखें, तीन से कम sentences वाले pages drop करें, curly brace या public obscenities list के किसी word वाला कोई भी page drop करें — monthly text के बीस terabytes को लगभग 750 GB में बदलते हुए।¹⁵

Blunt सही word है। Dodge et al. ने audit किया कि वे filters क्या हटाते हैं और पाया कि obscenity blocklist African-American English में 42 % documents और Hispanic-aligned English में 32 % documents delete करती है, White-aligned English के 6.2 % के against, जिससे corpus का 97.8 % आखिरी category रह जाता है।¹⁶ Dialect के बारे में कोई opinion न रखने वाले rule की एक opinion निकली।

फिर deduplication, जो housekeeping नहीं है: Lee et al. ने C4 में 61-word sentence को 61,036 बार repeated पाया, और दिखाया कि deduplicating models के “emit memorized text” करने की rate को दस गुना काट देता है, generated tokens के 1.9 % से 0.19 % तक।¹⁷ हालांकि more बेहतर नहीं है — FineWeb की team ने 96 crawls में globally deduplicate किया, 4 trillion tokens मिले और कोई measurable gain नहीं, फिर हर crawl को अलग deduplicate किया, 20 trillion मिले, और best existing corpus match किया।¹⁸

फिर contamination। Llama 3 ने अपना measure किया और publish किया: AGIEval का 98 %, BIG-Bench Hard का 95 % और HellaSwag का 85 % training set से 8-grams द्वारा overlap करता है, और MMLU के लिए overlap इतना high कि “it is impossible to get a good performance gain estimate”.⁵ GPT-3 के §4 में filtering bug report है जिसने benchmarks को data में छोड़ दिया और वापसी का कोई रास्ता नहीं था: “because of cost considerations it was infeasible to retrain the model”.⁷

Provenance unresolved हिस्सा है। The Pile ने Books3 नाम का 100.96 GiB component ship किया — corpus का 12 % और, paper की अपनी consent table के अनुसार, private torrent tracker से books;¹⁹ copyright complaint के बाद August 2023 में उसे offline कर दिया गया। September 2026 तक legal position unsettled है, और trend के रूप में cite किए गए तीन US rulings एक-दूसरे से disagree करते हैं। Alsup ने lawfully acquired books पर training को “exceedingly transformative” पाया जबकि pirated copies से बनी library को नहीं, और Anthropic ने उस half को $1.5 billion में settle किया, 482,460 works cover करते हुए, roughly $3,000 each, 20 July 2026 को approved।²⁰ Chhabria ने Meta को summary judgment दिया जबकि लिखा कि उनका ruling “does not stand for the proposition that Meta's use of copyrighted materials to train its language models is lawful”, केवल इतना कि “these plaintiffs made the wrong arguments”.²¹ Bibas ने Ross Intelligence के खिलाफ ruling देते हुए note किया कि “only non-generative AI is before me today”.²² किसी US appellate court ने इस सवाल पर ruling नहीं दी है।

लोग वे हिस्से करते हैं जो loss नहीं कर सकता। TIME ने January 2023 में report किया कि OpenAI के लिए Sama firm के through toxic text label करने वाले workers “between around $1.32 and $2 per hour” घर ले जाते थे, child sexual abuse, torture और self-harm describe करने वाले passages पढ़ते हुए, जबकि OpenAI ने Sama को इस काम के लिए $12.50 an hour pay किया; Sama pay range और quota दोनों पर dispute करता है।²³ यह pretraining के आसपास की filtering है, खुद pretraining नहीं — लेकिन यह same invoice पर है, और यही वह जगह है जहाँ एक person बैठता है।

Electricity real है और अक्सर misquoted होती है। सबसे careful published figure BLOOM का है: run के लिए 1,082,990 GPU-hours, 433 MWh और 24.7 tonnes CO₂ equivalent, manufacturing और idle nodes count करने पर 50.5;²⁴ Patterson et al. GPT-3 को 1,287 MWh और 552 tonnes पर रखते हैं।²⁵ दो cautions। BLOOM का advantage efficiency नहीं बल्कि 57 g CO₂ per kWh वाला French nuclear grid है — उसने OPT-175B से ज्यादा energy use की। और field की सबसे-quoted emissions figure, Strubell et al. की neural architecture search के लिए 626,155 lb, बाद में 88 times too high निकली, क्योंकि उसने assume किया था कि search full model size पर चली जबकि वह proxy पर चली थी।²⁶ LBNL का framing defensible है: US data centres ने 2024 में 192 TWh use किया, national electricity का 4.7 % — एक number जो industry से attached है, किसी एक run से नहीं।²⁷

Through-line वह है जिसे Bender et al. ने documentation debt कहा: “putting ourselves in a situation where the datasets are both undocumented and too large to document post hoc”.²⁸ ऊपर का हर fact इसलिए exist करता है क्योंकि किसी ने देखा। जिन models को ज्यादातर लोग use करते हैं उनके पीछे के corpora के लिए, कोई नहीं देख सकता।

अब वह arithmetic जो हर कोई चाहता है, चार cited inputs से, ताकि जब वे stale हों तो obvious रहे कि किसे replace करना है।

आखिरी दो columns साथ पढ़ें। $10,000 पर आपको एक rented node पर पखवाड़े में 5-billion-parameter model मिलता है। $100,000,000 पर arithmetic 546 billion parameters कहता है — और तीन months के लिए wired together बारह हजार H100s, जो ऐसा कुछ नहीं है जिसे credit card से rent किया जाए। लगभग $100,000 के बाद binding constraint money रहना बंद कर देता है और cluster बन जाता है।

ऐसी table पर भरोसा करने से पहले, उसे उन runs से test करें जिनकी real cost published है — llm.c GPT-2 124M को 8×A100 node पर “~90 minutes” में “about $20” में reproduce करता है, और GPT-2 1.6B को 8×H100 node पर 24 hours में $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

दोनों लगभग 15 % के भीतर, जो इस तरह के estimate को मिलनी चाहिए accuracy के करीब है और उस accuracy से काफी बेहतर है जिसके साथ इसे आमतौर पर quote किया जाता है।

इस subject में सबसे repeated figure यह है कि 2019 में करीब $43,000 cost करने वाला GPT-2-class model आज कुछ दर्जन dollars में reproduce किया जा सकता है। Modern half अच्छी तरह documented है; historical half नहीं।

आज। Karpathy के 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” precise और published है — GPT-2 के CORE score 0.256525 को beat करना — ऐसे leaderboard पर जिसकी 14 March 2026 तक best entry 1.65 hours है। $48 $3 per GPU-hour assume करता है, Lambda की list $3.99 से नीचे; list पर यह $64 के करीब है।

2019 में। कोई primary source नहीं है: OpenAI ने कभी duration या cost publish नहीं की। Chain The Register, February 2019 से चलती है, जिसमें “256 Google TPU3 cores” report है, price और duration नहीं; फिर Synced, June 2019, note करता है कि Google Cloud पर hardware cost $256 an hour थी और explicitly कहता है कि “OpenAI didn't specify the training duration”. $43,008 यानी $256 an hour times assumed 168 hours, जिसका source कभी किसी ने नहीं दिया।

इसलिए honest headline है: GPT-2 के published benchmark score को match करने वाला model आज rented hardware पर $100 से काफी कम में train किया जा सकता है, ऐसे 2019 cost के against जो कभी publish नहीं हुई और जिसका famous estimate duration के बारे में unsourced guess पर टिका है। Collapse real है और modern half credit card वाले किसी भी व्यक्ति द्वारा reproducible है; ratio ऐसे number पर arithmetic है जो exist नहीं करता। Published training costs की generally यही state है। GPT-3 paper में कोई dollar amount नहीं है, केवल Table D.1 में $3.14 \times 10^{23}$ FLOPs;⁷ Llama 3 paper में भी कोई नहीं।⁵ आपने जो भी training cost पढ़ी है वह FLOP count, hardware assumption और price assumption से estimate है — हमेशा पूछने लायक कि किसका।

जो निकलता है उसने fixed moment पर assemble किया गया fixed corpus देखा है, और इससे दो properties follow करती हैं।

पहली है knowledge cutoff। Collection date के बाद model कुछ नहीं जानता — “uncertain” नहीं, कुछ नहीं — और वह ऐसा कहने के बजाय fluently confabulate करेगा, क्योंकि ऐसा कहना कोई behaviour नहीं था जिस पर उसे train किया गया था। Llama 3.1 का model card December 2023 देता है;³³ हर model का एक होता है, और यह training data की property है, deployment की नहीं। इसके around काम करना retrieval problem है, जो Chapter 19 है।

दूसरी यह है कि base model answers के बजाय complete करता है। उसे “What is the capital of France?” दें और plausible continuation एक और question है, क्योंकि corpus में वह string अक्सर exercises की list में आती है।

Text completer assistant नहीं है। यह instructions follow नहीं करता, क्योंकि corpus में कुछ भी नहीं बताता कि request को obey किया जाना चाहिए, continue नहीं। इसे दो participants वाली conversation की कोई notion नहीं है। यह harmful prompt का सबसे probable continuation खुशी से produce करेगा, क्योंकि probable ही वह अकेली चीज़ थी जिसके लिए इसे optimise किया गया था।

इसे answer देने वाली चीज़ में बदलने में दूसरी stage लगती है, जिसकी cost पहली की fraction of a per cent है, और जो लगभग पूरी तरह इसे आपके चाहें behaviour के examples दिखाने और फिर इसके अपने outputs के pairs compare करने से बनी है। वही stage है जहाँ से instruction following, chat templates, refusals और — यह लोगों को surprise करता है — tool call करने की ability आती है। Chapter 11 वही stage है: supervised fine-tuning, RLHF, DPO और GRPO, और यह सवाल कि “aligned” का मतलब क्या है और decide कौन करता है।

इस chapter के साथ पढ़ने लायक और भी: Karpathy का build-nanogpt और उसका accompanying video, जो full GPT-2 reproduction को end to end ऐसे pace पर walk कराते हैं जो यह chapter नहीं कर सकता; और Stanford CS324, Large Language Models, जिसकी data और environmental impact वाली lectures ऊपर के section से ज्यादा deep जाती हैं, उस material में जिसे यह course एक बार treat करके delegate करता है।