एक LLM बनाएँएडवांस्डपाठ 446 मिनट का पाठ

स्टेप 8 · स्केलिंग नियम (Scaling laws) और कंप्यूट बजट

पैसे खर्च करने से पहले मॉडल का साइज़ और डेटासेट का साइज़ कैसे तय करें। स्लाइडर को खिसकाएं और खर्च का अंदाज़ा देखें।

✦ ट्यूटर से पूछें🧪 लैब · 15 min📝 पाठ का टेस्ट
पाठ वीडियो में

60 सेकंड में

स्टेप 8 · स्केलिंग नियम (Scaling laws) और कंप्यूट बजट

पैसे खर्च करने से पहले मॉडल का साइज़ और डेटासेट का साइज़ कैसे तय करें। स्लाइडर को खिसकाएं और खर्च का अंदाज़ा देखें।

1/5
आसान शब्दों में
अगर आपके पास एक तय बजट है, तो आप या तो एक बड़ा दिमाग खरीद सकते हैं या ज़्यादा किताबें। इनके बीच एक सही संतुलन होता है, और लोगों ने इसका एक मोटा अंदाज़ा निकाल लिया है।
एक तय कंप्यूट बजट के साथ, आपको इसे parameters और training tokens के बीच बांटना होगा। बहुत कम डेटा पर बहुत बड़ा मॉडल क्षमता की बर्बादी है; बहुत ज़्यादा डेटा पर बहुत छोटा मॉडल आगे बढ़ना बंद कर देता है (plateau हो जाता है)।

तीन ज़रूरी संख्याएं जो आपको चाहिए

मात्राफॉर्मूलानोट
Training computeC ≈ 6 · N · DN parameters, D tokens. Forward pass है 2ND, backward pass है 4ND
Compute-optimal अनुपातD ≈ 20 · Nचिंचिला (Chinchilla) का नतीजा — लगभग 20 tokens प्रति parameter
Inference compute≈ 2 · N प्रति tokenयही वजह है कि सर्विंग (serving) लागत के मामले में छोटे मॉडल बेहतर होते हैं

Interactive · compute budget

7.1B
141.3B
$2.00
Training compute6.0e21
GPU-hours10k
Rough cost$21k
Tokens / parameter20x
Near compute-optimal.Around the Chinchilla ratio of ~20 tokens per parameter — best loss for this training budget. Right if training cost is what you are minimising, which it usually is not.Inference costs about 14.2 GFLOPs per generated token.

अब कोई भी असल में compute-optimal ट्रेनिंग क्यों नहीं करता

चिंचिला इस सवाल का जवाब देता है कि "एक तय training बजट के लिए सबसे अच्छा मॉडल कौन सा है?" अगर आप इस मॉडल को लाखों लोगों तक पहुंचाने जा रहे हैं, तो यह गलत सवाल है, क्योंकि तब पूरा खर्च inference पर ही होता है।
  1. 1

    Compute-optimal

    1.4T tokens पर 70B का मॉडल। ट्रेनिंग बजट के हिसाब से सबसे बेहतरीन loss। हमेशा के लिए सर्व करने में बहुत महंगा।
  2. 2

    Inference-optimised

    15T tokens पर 8B का मॉडल। ट्रेनिंग के प्रति डॉलर पर बदतर loss, "optimal" से बहुत आगे — और चलाने में बेहद सस्ता, इतना छोटा कि एक GPU पर आ जाए, और तेज़।
  3. 3

    इंडस्ट्री ने दूसरा रास्ता चुना

    आज लगभग हर बड़े पैमाने पर इस्तेमाल होने वाला ओपन मॉडल चिंचिला की तुलना में जानबूझकर ज़रूरत से ज़्यादा ट्रेन (over-trained) किया जाता है। ट्रेनिंग की लागत एक बार लगती है; inference की लागत हमेशा चलती रहती है।
यह करें
वास्तव में मॉडल डिप्लॉय करने वाले किसी भी व्यक्ति के लिए एक बुनियादी नियम: वह सबसे छोटा मॉडल चुनें जो आपकी क्वालिटी की कसौटी पर खरा उतरे, फिर उसे compute-optimal बिंदु की तुलना में कहीं ज़्यादा देर तक ट्रेन करें। आपके यूज़र्स लेटेंसी (देरी) का सामना करते हैं और आपकी फाइनेंस टीम inference की लागत झेलती है; दोनों में से किसी को भी आपके training FLOPs से कोई फर्क नहीं पड़ता।

GPU किराए पर लेने से पहले मेमोरी का अंदाज़ा लगाना

Will it fit?python
def memory_gb(n_params, bytes_per_param=2, optimizer="adamw", train=True):
    weights = n_params * bytes_per_param            # bf16 weights
    if not train:
        return weights / 1e9 * 1.2                  # + KV cache and activations
    grads = n_params * bytes_per_param
    # AdamW keeps two fp32 moments, plus an fp32 master copy of the weights
    opt_state = n_params * 12 if optimizer == "adamw" else 0
    total = weights + grads + opt_state
    return total / 1e9 * 1.25                       # + activations, fragmentation

print(memory_gb(7e9))              # ~ 100 GB  -> will NOT fit on one 80GB card
print(memory_gb(7e9, train=False)) # ~ 17 GB   -> inference fits easily
print(memory_gb(1.5e9))            # ~ 22 GB   -> trainable on one 24GB card
सावधान रहें
इन दोनों संख्याओं के बीच का अंतर ही वह चीज़ है जिसे शुरुआती लोग नज़रअंदाज़ कर देते हैं। पूरी ट्रेनिंग के लिए inference की तुलना में लगभग 6–8 गुना मेमोरी की ज़रूरत होती है, जो लगभग पूरी तरह से optimiser state की वजह से होती है। यह बिल्कुल वही अंतर है जिसे पाटने के लिए LoRA बना है — मॉड्यूल 52।

इमर्जेंस (Emergence), और यह कि सिर्फ ग्राफ ही पूरी कहानी क्यों नहीं है

Loss आसानी से और लगातार गिरता है। लेकिन कुछ खास क्षमताएं कभी-कभी ऐसे नहीं सुधरतीं — अंकगणित (arithmetic), कई चरणों में सोचना (multi-step reasoning) और निर्देशों का पालन करना कुछ खास पैमानों पर अचानक उभरे हैं। इसमें से कितना असली है और कितना हां-या-ना (all-or-nothing) वाले पैमानों का नतीजा है, इस पर बहस जारी है।
इसका व्यावहारिक नतीजा: एक छोटा मॉडल स्टाइल, फॉर्मेट और सीमित विषयों में बेहतरीन हो सकता है, जबकि कुछ क्षमताएं एक तय पैमाने से नीचे मिल ही नहीं सकतीं, चाहे आप उसे कितनी भी देर तक ट्रेन क्यों न करें।

और देखें और पढ़ें

Scaling laws and ChinchillaYouTube searchTraining Compute-Optimal LLMsthe Chinchilla paper · reading

लैब

एक असली विकल्प के सामने अपने कंप्यूट बजट को सही साबित करना।

~15 min

समस्या

एक तय क्वालिटी के लिए, तीन योजनाओं की लागत निकालें: compute-optimal, inference-optimised, और किसी मौजूदा API का इस्तेमाल करना। इसमें ट्रेनिंग, आपके इस्तेमाल के आधार पर एक साल का inference, और इंजीनियरिंग का समय शामिल करें। एक को चुनें और उसका मेमो (memo) लिखें।

आपका काम तब पूरा होगा जब

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1आपकी inference-optimised योजना 300B tokens पर 3B मॉडल को ट्रेन करती है — यानी 100 tokens प्रति parameter, जो कि चिंचिला से बहुत आगे है। लागत के हिसाब से इसे सही साबित करें।दिखाएं
चिंचिला एक तय training बजट के लिए loss को कम से कम करता है, जो कि सिर्फ एक बार का खर्च है। आप पूरे मालिकाना हक की कुल लागत (total cost of ownership) को कम कर रहे हैं, जहां inference का भुगतान हमेशा प्रति रिक्वेस्ट किया जाता है। एक 3B मॉडल 12B मॉडल की तुलना में लगभग एक चौथाई लागत पर काम करता है और सस्ते हार्डवेयर पर फिट हो जाता है, इसलिए हर महीने कुछ सौ मिलियन tokens पर अतिरिक्त training compute की भरपाई कुछ ही हफ्तों में हो जाती है। Compute-optimal बिंदु उस सवाल का सही जवाब है जो आप पूछ ही नहीं रहे हैं।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

क्या 6ND फॉर्मूले में attention की लागत शामिल है?

यह quadratic attention वाले हिस्से को नज़रअंदाज़ करता है, जो कि तब तक एक अच्छा अनुमान है जब तक sequence की लंबाई मॉडल की चौड़ाई की तुलना में कम है। बहुत लंबे context पर यह असली लागत को काफी कम आंकता है।

क्या स्केलिंग नियम अब भी काम कर रहे हैं?

Loss बनाम compute के लिए, मोटे तौर पर हां, उन सीमाओं के भीतर जो प्रकाशित की गई हैं। बदलाव यह आया है कि अब मुख्य रुकावटें ग्राफ के बजाय डेटा की उपलब्धता, बिजली और inference के खर्च पर आ गई हैं।

क्या मैं ट्रेनिंग से पहले अपने अंतिम loss का अंदाज़ा लगा सकता हूँ?

काफी हद तक हां, अपने डेटा मिश्रण पर छोटे-छोटे प्रयोगों की एक सीरीज़ बनाकर स्केलिंग नियम को फिट करके, और फिर आगे का अंदाज़ा (extrapolate) लगाकर। लैब्स एक बड़े रन पर काम शुरू करने से पहले बिल्कुल यही करती हैं, और यह किसी भी स्तर पर एक अच्छी आदत है।

एक ट्रेनिंग रन की असल लागत क्या होती है?

2026 की क्लाउड कीमतों पर एक मोटा अंदाज़ा: 100M का मॉडल, कुछ दसियों डॉलर। 1B का मॉडल, कुछ सौ से लेकर कुछ हज़ार डॉलर तक। ठीक से ट्रेन किया गया 7B का मॉडल, लाखों डॉलर। और सबसे आधुनिक (frontier) स्तर का मॉडल, करोड़ों डॉलर।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें