LLM کی pretraining: data، compute، scaling laws اور لاگت

Objective میں کچھ نہیں بدلتا۔ model اب بھی اگلا token predict کرتا ہے، loss اب بھی باب 4 کی cross-entropy ہے جو Chapter 8 کی factorisation پر apply ہوتی ہے، optimiser اب بھی باب 6 کا AdamW ہے۔ Pretraining کوئی نیا algorithm نہیں؛ یہ وہی algorithm ہے جو اتنے بڑے corpus پر چلایا جاتا ہے کہ run کا budget بنانا پڑتا ہے۔ دو چیزیں اسے ممکن بناتی ہیں: labels free ہیں، کیونکہ position $t$ کے لیے target $t+1$ پر token ہے اور پہلے ہی text میں موجود ہے؛ اور Chapter 6 کے آخری section نے اعتراض ہٹا دیا، کیونکہ classical rules سے کہیں زیادہ parameters والا model ٹوٹتا نہیں، بہتر ہوتا ہے۔ نتیجے میں ایک base model نکلتا ہے — ایسی چیز جو answer دینے کے بجائے text جاری رکھتی ہے۔

اس میں سے کسی چیز کا budget بنانے سے پہلے اسے گننا ضروری ہے، اور field اسے ایک formula سے گنتی ہے:

جہاں $N$ parameter count ہے، $D$ training tokens ہیں اور $C$ کل floating-point operations ہیں۔ Kaplan et al. اسے دو steps میں derive کرتے ہیں۔¹ Forward: 2 FLOPs per parameter per token، کیونکہ matrix multiply میں ہر parameter ہر token کے لیے ایک بار استعمال ہوتا ہے، ایک multiply اور ایک add میں۔ Backward: forward کا دو گنا، کیونکہ باب 5 کا backward pass ہر layer پر دو gradients compute کرتا ہے — layer کے inputs کے حوالے سے، تاکہ signal سفر جاری رکھے، اور اس کے weights کے حوالے سے — دونوں forward کے سائز کے matrix multiply ہیں، اس لیے $4N$۔

یہ پوری derivation ہے، اور اسے ماننے کے بجائے check کرنا چاہیے۔ PyTorch ایک حقیقی FLOP counter، torch.utils.flop_counter.FlopCounterMode، کے ساتھ آتا ہے، جو model کی dispatch کی ہوئی ہر operation intercept کرتا ہے اور actual work جمع کرتا ہے۔ اسے magnitude کے چار orders پر چلائیں، سب سے بڑا 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 پر بالکل: یہ کوئی approximation نہیں جو اتفاقاً اچھی ہو، بلکہ اوپر والی arithmetic identity ہے جو ایک ایسے counter سے round number کی صورت واپس آئی ہے جسے derivation کا کچھ علم نہیں۔

Measured total پھر $6ND$ سے 3 % سے 17 % اوپر بیٹھتا ہے، جب $N$ embedding matrices کو گنتا ہے — اور یہ clause اہم ہے، کیونکہ دو founding papers $N$ کو مختلف طرح گنتے ہیں۔ 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 کے لیے دونوں میں factor nine کا فرق ہے، جیسا پہلی row دکھاتی ہے۔

باقی gap وہ ہے جسے $6ND$ جان بوجھ کر چھوڑتا ہے: attention scores۔ Kaplan کی Eq. (2.2) forward cost کو $2N + 2\,n_{\text{layer}} n_{\text{ctx}} d_{\text{model}}$ لکھتی ہے اور دوسرا 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 فیصلہ کرتی ہے کہ یہ start بھی ہو سکتا ہے یا نہیں۔ Plain fp32 AdamW سے train کریں تو ہر parameter چار numbers اٹھاتا ہے: weight، اس کا gradient، اور Adam کا running mean $m$ اور variance $v$ — وہ دو averages جو Chapter 6 میں ہاتھ سے بنائے گئے۔ چار numbers، ہر ایک چار bytes، یعنی ایک activation سے پہلے 16 bytes per parameter۔ 8 GB laptop GPU پر measured، step کے اس point پر resident allocation لیتے ہوئے جہاں کوئی graph alive نہیں:

Prediction اور measurement 3 % کے اندر agree کرتے ہیں۔ حیرت آخری column ہے: activations model کو dwarf کر دیتے ہیں۔ وہی 5.8-million-parameter model جسے persistent state کے لیے 89 MB چاہیے، 128 کے batch پر activations کے لیے 4,681 MB چاہتا ہے — model سے باون گنا — اور اس کا بڑا حصہ transformer بھی نہیں۔ یہ logits ہیں، ہر token کے لیے vocabulary size کا ایک vector، ہر entry چار bytes: آخری row میں 512 MB، پہلی میں 393 MB۔ Vocabulary size Chapter 7 میں چنی گئی تھی، اور یہ اب بھی فیصلہ کر رہی ہے کہ card پر کیا fit ہوتا ہے۔

کون سا term dominate کرتا ہے، یہ run کی shape پر depend کرتا ہے، اسی لیے 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 سے پہلے fourteen 80 GB GPUs کے برابر۔

Frontier scale پر اس میں سے کچھ بھی ایک device پر fit نہیں ہوتا، اس لیے run ایک ساتھ چار ways میں split ہوتا ہے۔ Data parallelism ہر GPU پر model کی copy رکھتا ہے اور gradients average کرتا ہے — default، اور وہی جسے ZeRO optimiser state کی redundant copies رکھنے سے انکار کر کے improve کرتا ہے۔ Tensor parallelism individual matrices کو devices کے across split کرتا ہے۔ Pipeline parallelism ہر device کو layers کا contiguous group دیتا ہے۔ Context parallelism sequence کو ہی split کرتا ہے، جو صرف تب ضروری ہے جب $T$ اتنا long ہو جائے کہ attention term dominate کرے۔ Llama 3 کی Table 4 چاروں کو ایک ساتھ list کرتی ہے: tensor 8، context up to 16، pipeline 16، data up to 128، 16,384 H100 GPUs کے across۔⁵ یہ course اس بارے میں بس اتنا ہی کہے گا؛ distributed training engineering اپنے آپ میں ایک semester ہے، اور Stanford کا CS336 وہ semester ہے، lectures 5 سے 8، code کے ساتھ۔⁶ Delegation کے بعد جو چیز باقی رہتی ہے وہ ایک number ہے، model FLOPs utilisation — GPU کی peak arithmetic کا وہ fraction جو real run achieve کرتا ہے — یہی tidy $6ND$ کو wall-clock time اور پھر money میں بدلتا ہے۔

جنوری 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 بہت چھوٹے ہیں: دس گنا parameters remaining loss سے factor $10^{0.076} \approx 1.19$ کم کرواتے ہیں۔ یہ کچھ بھی نہیں لگتا، اور یہی یہاں سب سے اہم fact ہے — returns terrible ہیں اور وہ کبھی رکتی نہیں۔ 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 times bigger model جسے صرف 1.9 times اتنا 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 نے بالکل یہی کیا: GPT-3، 300 billion tokens پر 175 billion parameters،⁷ Gopher 300 billion پر 280 billion، Megatron-Turing NLG 270 billion پر 530 billion۔² آدھے token سے دو tokens per parameter، across the board۔

مارچ 2022 میں، Hoffmann et al. نے 70 million سے 16 billion parameters تک 400 سے زیادہ models train کیے اور تین independent routes سے opposite conclusion تک پہنچے۔² ان کی Table 2 $N_{\text{opt}} \propto C^{a}$ میں exponent $a$ کو 0.50، 0.49 اور 0.46 report کرتی ہے، Kaplan کے 0.73 کے مقابل۔ سادہ لفظوں میں: model size اور training data کو equal proportion میں grow کرنا چاہیے۔

ان کا second approach وہی ہے جو اس chapter کے شروع میں sweep نے scale کے millionth حصے پر reproduce کیا: budget fix کریں، اسی budget پر بہت سے sizes 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 demand کرتا تھا یا size اس sweep کے باہر تھا۔

Column کے نیچے پڑھیں: loss گرتا ہے، bottom out ہوتا ہے اور پھر چڑھتا ہے۔ کوئی model اپنے budget کے لیے اتنا ہی آسانی سے بہت بڑا ہو سکتا ہے جتنا بہت چھوٹا — $10^{14}$ پر 295,808 کی جگہ 665,280 parameters چننے کی penalty 0.08 nats ہے، جو اوپر fitted envelope پر وہ loss ہے جو correctly sized model 18 % کم compute کے ساتھ پہنچتا ہے۔ غلط shape چننا budget کا پانچواں حصہ ضائع کر دیتا ہے۔ یہ Chinchilla کی Figure 3 ہے، four hundred models کے بجائے ایک GPU پر ایک afternoon میں۔

اب across پڑھیں۔ $10^{13}$ پر best model swept میں سب سے چھوٹا ہے؛ $10^{14}$ پر یہ 295,808 parameters ہے، دونوں طرف bracketed۔ Budget بڑھنے پر optimum دائیں move کرتا ہے، یہی correction کا پورا content ہے۔ Paper کا third approach fit کریں — ہر run پر surface $L(N,D) = E + A/N^{\alpha} + B/D^{\beta}$ — اور $C = 6ND$ کے subject to 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 کے مقابل۔ Three-budget fit سے تین digits تک agreement luck ہے؛ پہلے digit تک agreement نہیں۔ Exponent travel کرتا ہے — constant نہیں، کیونکہ ان optima پر token-to-parameter ratio 170 سے 540 ہے، 20 نہیں۔ تین reasons، سب instructive۔ $E$ zero پر fit ہوتا ہے کیونکہ 4 nats سے اوپر loss پر run entropy floor کے قریب کہیں نہیں جو Chinchilla کے fit کو dominate کرتا ہے۔ Batch size اور learning rate کو per point tune کرنے کے بجائے fixed رکھا گیا، جو ان runs کو handicaps کرتا ہے جنہیں fewest steps ملتے ہیں — اور وہ large models ہیں: $10^{13}$ FLOPs پر 1.28-million-parameter model کو total 159 optimiser steps ملتے ہیں، Kaplan کے $S_{\min}$ term کے مطابق کسی بھی model کو درکار چند ہزار سے بہت کم۔ Scaling law ایک regime کے اندر fit ہوتا ہے، اور یہ one Chinchilla سے چھ orders of magnitude نیچے بیٹھتا ہے۔

اسی لیے paper کا abstract: "current large language models are significantly undertrained"۔ Chinchilla demonstration ہے — 1.4 trillion tokens پر 70 billion parameters، Gopher کے 300 billion پر 280 billion جیسا same total compute، مگر 57 میں سے 51 MMLU tasks پر بہتر، 60 % کے مقابل 67.5 %۔² چار گنا چھوٹا، ساڑھے چار گنا زیادہ text، same money، better model۔

اس famous ratio پر دو caveats۔ "Twenty tokens per parameter" paper میں کوئی sentence نہیں؛ paper صرف کہتا ہے کہ "for every doubling of model size the number of training tokens should also be doubled"؛ 20 Table 3 اور Chinchilla کے اپنے 1.4 T پر 70 B سے inference ہے۔ اور اس کی precision published سے worse ہے: 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 باب 1 کے learning-rate schedules کے promise کو پورا کرتی ہے۔ Cosine schedule کو token budget کے ساتھ match کرنا پڑتا ہے۔ جو model 10 million tokens دیکھے گا اسے اپنی learning rate 10 million tokens پر zero تک decay کرنی چاہیے؛ اسے 100 million کے لیے sized schedule دیں، early stop کریں، اور آپ descent کے بیچ کا loss پڑھ رہے ہیں ایسی rate پر جو بہت high ہے۔ Chinchilla ہر model کو four cycle lengths پر train کرتا ہے تاکہ بالکل اس کو control کرے؛ اوپر والا 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 نہیں جس کی آپ payment کر رہے ہیں۔

یہ fitted ہیں، derived نہیں۔ کوئی theory $\alpha_N = 0.076$ produce نہیں کرتی۔ Constants tokenizer کے ساتھ move کرتے ہیں — اسی لیے دو tokenizers کے across perplexity comparison meaningless ہے، جیسا Chapter 8 نے explain کیا — اور data mixture، architecture اور optimiser کے ساتھ بھی۔ ہر published law اس setup کی law ہے جس نے اسے produce کیا، اسی لیے Meta نے Llama 3 سے پہلے اپنی law 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 کے لیے تقریباً $2N$ FLOPs pay کرتا ہے، ہمیشہ۔ 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}}$ کو instead 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 نہیں؛ یہ ایک ایسے question کا جواب دیتا ہے جو اب پوچھا نہیں جا رہا۔

Loss smoothly گرتا ہے۔ Benchmark scores کبھی کبھی نہیں۔ Wei et al. نے ایسے cases collect کیے جہاں task training compute کے orders of magnitude تک chance پر بیٹھا رہتا ہے اور پھر jump کرتا ہے — GPT-3 میں تقریباً $2 \times 10^{22}$ FLOPs پر تین-digit arithmetic ظاہر ہونا، MMLU کا $3$ اور $5 \times 10^{23}$ کے درمیان guessing سے اوپر جانا — اور pattern کو name دیا: "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 پر موجود ہی نہ ہو جسے آپ afford کر کے test کر سکیں۔

Schaeffer, Miranda and Koyejo نے argue کیا کہ اس کا بڑا حصہ measurement کا artefact ہے، اور mechanism arithmetic ہے۔¹³ Per-token loss smoothly گرتا ہے، اس لیے ایک token کے right ہونے کی probability، $\exp(-\mathcal{L})$، gradually improve ہوتی ہے۔ Model کو $L$-token answer پر exact string match سے score کریں تو آپ اس probability کو power $L$ تک raise کرتے ہیں — ایک smooth curve کو large power تک raise کریں تو وہ cliff جیسی لگتی ہے۔ Same outputs پر metric بدل کر ایسا metric لگائیں جو تمام tokens demand کرنے کے بجائے 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"، جبکہ دو discontinuous metrics claimed cases کے 92 % سے زیادہ کی ذمہ دار ہیں — اور ان کی caution بھی: "nothing in this paper should be interpreted as claiming that large language models cannot display emergent abilities"۔ Chart میں jump metric کے بارے میں evidence ہے جب تک دوسری صورت ثابت نہ ہو۔ Chapter 29 وہ جگہ ہے جہاں یہ آپ کا مسئلہ بنتا ہے، کیونکہ hard-cutoff metric چننا ایک ایسا decision ہے جو آپ محسوس کیے بغیر کریں گے۔

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" ہیں، اس کا ایک month، download کرنے کے لیے free۔¹⁴ تقریباً کچھ بھی اپنی original حالت میں 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 obscenity list کے word والی ہر page drop کریں — monthly text کے twenty terabytes کو تقریباً 750 GB میں بدلتے ہوئے۔¹⁵

Blunt صحیح لفظ ہے۔ Dodge et al. نے audit کیا کہ یہ filters کیا remove کرتے ہیں اور پایا کہ obscenity blocklist African-American English میں 42 % documents اور Hispanic-aligned English میں 32 % delete کرتی ہے، White-aligned English کے 6.2 % کے مقابل، جس سے corpus 97.8 % آخری category کا رہ جاتا ہے۔¹⁶ Dialect کے بارے میں no 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 always better نہیں — FineWeb کی team نے 96 crawls کے across globally deduplicate کیا، 4 trillion tokens ملے اور کوئی measurable gain نہیں، پھر ہر crawl کو separately deduplicate کیا، 20 trillion ملے، اور best existing corpus کو match کیا۔¹⁸

پھر contamination۔ Llama 3 نے اپنی contamination measure کر کے publish کی: AGIEval کا 98 %، BIG-Bench Hard کا 95 % اور HellaSwag کا 85 % training set سے 8-grams کے ذریعے overlapping، اور 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 part ہے۔ The Pile نے Books3 نام کا 100.96 GiB component ship کیا — corpus کا 12 % اور، paper کی اپنی consent table کے مطابق، private torrent tracker کی books؛¹⁹ اسے August 2023 میں copyright complaint کے بعد 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 کے لیے، تقریباً $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 نے اس question پر ruling نہیں دی۔

لوگ وہ parts کرتے ہیں جو 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 بیان کرنے والے passages پڑھتے ہوئے، جبکہ OpenAI نے اس work کے لیے Sama کو $12.50 an hour pay کیا؛ Sama pay range اور quota دونوں dispute کرتا ہے۔²³ یہ pretraining کے گرد filtering ہے، pretraining خود نہیں — مگر same invoice پر ہے، اور وہیں ایک انسان بیٹھتا ہے۔

Electricity real ہے اور عموماً غلط quote ہوتی ہے۔ سب سے 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 پر run ہوئی جبکہ وہ 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 اس لیے موجود ہے کہ کسی نے دیکھا۔ ان corpora کے لیے جن کے پیچھے most people use models ہیں، کوئی نہیں دیکھ سکتا۔

اب وہ arithmetic جو ہر کوئی چاہتا ہے، چار cited inputs سے، تاکہ جب وہ stale ہوں تو واضح ہو کہ کس کو replace کرنا ہے۔

آخری دو columns کو ساتھ پڑھیں۔ $10,000 پر آپ کو ایک rented node پر fortnight میں 5-billion-parameter model ملتا ہے۔ $100,000,000 پر arithmetic 546 billion parameters کہتی ہے — اور تین ماہ کے لیے twelve thousand H100s wired together، جو ایسی چیز نہیں جسے credit card سے rent کیا جائے۔ تقریباً $100,000 کے بعد binding constraint money نہیں رہتا بلکہ cluster بن جاتا ہے۔

ایسی table پر trust کرنے سے پہلے اسے ان runs کے خلاف test کریں جن کی real cost published ہے — llm.c GPT-2 124M کو 8×A100 node پر "~90 minutes" میں "for 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

دونوں about 15 % کے اندر ہیں، جو تقریباً اتنی accuracy ہے جتنی اس kind کے estimate deserve کرتے ہیں، اور اس accuracy سے کافی بہتر ہے جس کے ساتھ اسے عموماً quote کیا جاتا ہے۔

اس subject میں سب سے repeated figure یہ ہے کہ 2019 میں تقریباً $43,000 cost کرنے والا GPT-2-class model آج چند tens of dollars میں reproduce ہو سکتا ہے۔ Modern half اچھی طرح documented ہے؛ historical half نہیں۔

Today. 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 پر جس کی best entry 14 March 2026 تک 1.65 hours ہے۔ $48، $3 per GPU-hour assume کرتا ہے، Lambda کی list $3.99 سے کم؛ list پر یہ $64 کے قریب ہے۔

In 2019. کوئی primary source نہیں: OpenAI نے duration یا cost کبھی publish نہیں کی۔ Chain The Register، February 2019 سے چلتی ہے، جس نے "256 Google TPU3 cores" report کیا، price یا duration کے بغیر؛ پھر Synced، June 2019، جس نے note کیا کہ hardware Google Cloud پر $256 an hour cost کرتا تھا اور explicitly کہا کہ "OpenAI didn't specify the training duration"۔ $43,008، $256 an hour کو assumed 168 hours سے multiply کرنا ہے جس کا source کبھی نہیں ملا۔

تو honest headline یہ ہے: GPT-2 کے published benchmark score کو match کرنے والا model آج rented hardware پر $100 سے کہیں کم میں train ہو سکتا ہے، ایک 2019 cost کے مقابل جو کبھی publish نہیں ہوئی اور جس کا famous estimate duration کے بارے میں ایک unsourced guess پر ٹکا ہے۔ Collapse real ہے اور modern half credit card رکھنے والے ہر شخص کے لیے reproducible ہے؛ ratio ایسے number پر arithmetic ہے جو exist نہیں کرتا۔ Published training costs کی 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 پر assembled 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 work کرنا retrieval problem ہے، جو Chapter 19 ہے۔

دوسری یہ کہ base model answer دینے کے بجائے complete کرتا ہے۔ اسے "What is the capital of France?" دیں تو ایک plausible continuation ایک اور question ہے، کیونکہ corpus میں یہ string اکثر exercises کی list میں آتی ہے۔

Text completer assistant نہیں۔ یہ instructions follow نہیں کرتا، کیونکہ corpus میں کچھ بھی اسے نہیں بتاتا تھا کہ request کو obey کرنا چاہیے، continue نہیں۔ اسے two participants والی conversation کا کوئی notion نہیں۔ یہ harmful prompt کی most probable continuation خوشی سے produce کرے گا، کیونکہ probable ہی وہ واحد چیز ہے جس کے لیے اسے optimise کیا گیا۔

اسے answer دینے والی چیز میں بدلنا ایک second stage لیتا ہے جس کی cost first کے ایک per cent کے fraction جتنی ہوتی ہے، اور جو تقریباً مکمل طور پر اسے مطلوب behaviour کی examples دکھانے اور پھر اس کے اپنے outputs کے pairs compare کرنے پر مشتمل ہے۔ یہی stage ہے جہاں سے instruction following، chat templates، refusals اور — یہ لوگوں کو حیران کرتا ہے — tool call کرنے کی ability آتی ہے۔ Chapter 11 وہ stage ہے: supervised fine-tuning، RLHF، DPO اور GRPO، اور یہ question کہ "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 سے زیادہ depth میں جاتے ہیں، اس material میں جسے یہ course ایک بار treat کر کے delegate کرتا ہے۔