Phase 10: LLMs from Scratch

पूर्ण LLM पाइपलाइन का निर्माण

सब कुछ पाठ 01 से 12 तक एक पाइपलाइन का एक चरण है। यह सबक एक मंच है जो उन चरणों को एक एकल अंत-से-अंत रन में बदल देता हैः टोकन, प्री-ट्रेन, स्केल, एसएफटी, संरेखित, मूल्यांकन, क्वांटिज़, सेवा। आप एक लैपटॉप पर एक 70B मॉडल को प्रशिक्षित नहीं करेंगे। आप ऑर्केस्ट्रेशन लेयर, मैनिफिस, एवल गेट और रूलबैक प्लान तैयार करेंगे जो 2026 सीमा टीम द्वारा तय करने के लिए उपयोग किया जाएगा कि क्या शिप किया जाएगा। यह है कपास्टोन.

Type: Build

Languages: Python (stdlib)

Prerequisites: All Phase 10 lessons 01-12

Time: ~120 minutes

सीखने के लक्ष्य

11 पूर्व पाठों (टोकनीज़र, डेटा, प्री-ट्रेनिंग, स्केलिंग, एसएफटी, आरएलएचएफ, डीपीओ, सीएआई, इवल, क्वांटिज़ेशन, इन्फेरेंस) को एक एकल पुनरावर्तन योग्य पाइपलाइन विनिर्देश में मिलाएं
चरणों के बीच कलाकृतियों के अनुबंध को परिभाषित करेंः प्रत्येक चरण क्या खपत करता है, यह क्या बनाता है, और अगला चरण इनपुट की पुष्टि कैसे करता है
एक ऑर्केस्ट्रेटर का निर्माण करें जो प्रयोगों को ट्रैक करता है, कलाकृतियों को हैश करता है, और मूल्यांकन सीमाओं पर निर्णयों को जहाज करता है
रोलबैक योजना का डिजाइन करेंः कौन सी कलाकृतियों को फिर से चलाया जाना सस्ता है, कौन सी महंगी हैं, और एक भ्रष्ट चेकपोस्ट की लागत क्या है

समस्या

पहले के सबक प्रत्येक काम करते हैं। टोकनराइज़र प्रशिक्षित। छोटे जीपीटी पूर्व-प्रशिक्षित। एसएफटी डेटासेट इकट्ठा किया गया। इनाम मॉडल प्रशिक्षित। डीपीओ रन। मापा गया समतुल्य। निर्यात किया गया मात्रा वजन। इन्फरेंस सर्वर फटा हुआ। प्रत्येक एक नोटबुक है। प्रत्येक के अपने स्वयं के सम्मेलन, अपने स्वयं के आउटपुट पथ, अपने स्वयं के बीज हैं।

सीमा पर प्रशिक्षण रन एक नोटबुक नहीं है। Llama 3 405B लगभग 54 दिनों में 30 मिलियन H100 घंटे लग गए। डीपसेक-वी3 ने लगभग 2.8 मिलियन एच800 घंटे का उपयोग किया। उस समय के दौरान, एक भ्रष्ट चेकपॉइंट, एक डेटा दूषित, एक मूल्यांकन प्रतिगमन एक टीम को एक सप्ताह की दीवार घड़ी और एक महीने के GPU बजट की लागत हो सकती है। टीमों का इससे बचने का तरीका पाइपलाइन स्वच्छता के माध्यम से हैः प्रत्येक चरण में एक निर्धारक इनपुट, एक निर्धारक आउटपुट, एक प्रात्यक्षिक, एक हैश और एक गेट होता है।

यह है कीपस्टोन. आप एक लैपटॉप पर पाइपलाइन को अंत से अंत तक नहीं चलाएंगे. आप ऑर्केस्ट्रेटर लिखेंगे जो चरणों को समन्वयित करता है, मैनिफेस्ट जो रन का वर्णन करता है, सत्यापनकर्ता जो जहाज निर्णयों को बंद करता है, और रिप्ले प्लान जो किसी तीसरे पक्ष को एक फ़ाइल से आपके काम को फिर से चलाने की अनुमति देता है। कोड छोटा है; अनुशासन बड़ा है।

पैटर्न 100M से 1T पैरामीटर तक अपरिवर्तित है. एक ही चार घटक - manifesto, orchestrator, eval gate, artefact store - Llama 3 चलाएं और अपने शौक GPT भी चलाएं. अंतर प्रत्येक चरण के कॉन्फ़िग के अंदर संख्याओं का आकार है, पाइपलाइन के आकार नहीं.

अवधारणा

बारह चरण

प्रत्येक चरण 10 पाठ एक चरण है. यहाँ पूर्ण निर्भरता ग्राफ है.

graph TD
    S1["01 Tokenizer vocab"] --> S2["02 Trained tokenizer"]
    S2 --> S3["03 Sharded dataset"]
    S3 --> S4["04 Base model checkpoint"]
    S4 --> S5["05 Scaled training recipe"]
    S5 --> S6["06 SFT checkpoint"]
    S6 --> S7["07 Reward model + PPO policy"]
    S6 --> S8["08 DPO policy"]
    S7 --> S9["09 CAI / GRPO refined policy"]
    S8 --> S9
    S9 --> S10["10 Eval report"]
    S9 --> S11["11 Quantized weights"]
    S11 --> S12["12 Inference server"]
    S10 --> GATE["Ship gate"]
    S12 --> GATE

    style S1 fill:#1a1a2e,stroke:#e94560,color:#fff
    style S4 fill:#1a1a2e,stroke:#0f3460,color:#fff
    style S9 fill:#1a1a2e,stroke:#0f3460,color:#fff
    style GATE fill:#1a1a2e,stroke:#51cf66,color:#fff

चरण 07 और 08 समानांतर चल सकते हैं। बाकी सब कुछ एक कठिन निर्भरता है। चरण 02 (टोकनीज़र) में परिवर्तन हर डाउनस्ट्रीम कलाकृतियों को अमान्य करता है। चरण 10 (ईवल) में परिवर्तन केवल जहाज निर्णय को अमान्य करता है।

प्रकट

मैनिफेस्ट एक एकल फ़ाइल है जो इसे फिर से खेलने के लिए पूरी तरह से एक रन का वर्णन करती है। पाइपलाइन का कोई भी उत्पाद उस स्थिति पर निर्भर नहीं होना चाहिए जो मैनिफेस्ट में नहीं है। फ़ील्ड बोरिंग और अनिवार्य हैं।

pipeline_version: 1.2.3
seed: 42
git_commit: a1b2c3d4
stages:
  01_tokenizer:
    recipe: bpe_32k
    input_hash: sha256:...
    output_hash: sha256:...
    wall_clock_sec: 3600
    cost_usd: 12

स्टेज N का आउटपुट हैश स्टेज N+1 का इनपुट हैश है। कोई भी विचलन और पाइपलाइन रुक जाती है। यह है कि आप डेटा भ्रष्टाचार को जल्दी कैसे पकड़ते हैं। यह यह भी है कि एक अलग महाद्वीप पर एक टीम के साथी यह कैसे सत्यापित करते हैं कि उनके रिप्ले ने आपके समान कलाकृतियां उत्पन्न कीं।

अभ्यास में टीमों का उपयोग एक छोटे से YAML योजना प्लस एक स्पष्ट जांचकर्ता है कि पिछले सफल रन के खिलाफ भिन्न है। किसी भी डेल्टा अपेक्षित क्षेत्रों (की लागत, दीवार घड़ी) के बाहर एक लाल झंडा है।

कलाकृतियों का टाइपिंग

प्रत्येक चरण का आउटपुट एक टाइप किया हुआ कलाकृतियाँ हैं, एक निर्देशिका ब्लाब नहीं, एक मक्खन नहीं, लेकिन एक ज्ञात योजना के साथ एक नामित प्रकार।

Stage	Artifact Type	Key Fields
01-02	Tokenizer	vocab.json, merges.txt, config.json, hash
03	Dataset	shards[], row count, token count, dedup stats
04-05	Checkpoint	weights.safetensors, config.json, optimizer state, step count
06	SFT Model	checkpoint + SFT recipe + data mix
07	Reward Model	RM checkpoint + preference data hash
08-09	Policy	checkpoint + reference hash + beta + KL budget consumed
10	Eval Report	benchmark scores + regression diffs + eval data hash
11	Quantized Model	quantized weights + calibration data + accuracy delta vs FP16
12	Server Spec	endpoint + model hash + config + observability hooks

टाइपिंग सबसे आम विफलता मोड को रोकता हैः चरण 06 इनपुट के रूप में चरण 08 आउटपुट का उपयोग करना, एसएफटी पथ के माध्यम से डीपीओ-प्रशिक्षित मॉडल को शिपिंग करना। टाइप किए गए कलाकृतियों और टाइप किए गए चरण हस्ताक्षर इन त्रुटियों को संकलन समय विफलताओं, पांच दिनों की विफलताओं नहीं बनाते हैं।

ईवल गेट

शिपिंग "प्रशिक्षण समाप्त नहीं है।" शिपिंग "प्रशिक्षण समाप्त है और मूल्यांकन गेट पारित किया गया है।" गेट को रन शुरू होने से पहले परिभाषित किया जाता है।

gates:
  mmlu:      >= baseline + 0.5   # no regression
  humaneval: >= baseline + 1.0
  truthfulqa: >= baseline         # no drop
  safety_refusal_rate: <= 0.05
  kl_from_reference: <= 25.0
  cost_total_usd: <= 50000

प्रत्येक गेट एक संख्यात्मक सीमा है। कोई "अच्छी लगती है" गेट नहीं। कोई व्यक्तिगत हस्ताक्षर नहीं। यदि प्रत्येक गेट गुजरता है, तो कलाकृतियों को शिपपेबल चिह्नित किया जाता है। यदि कोई गेट विफल होता है, तो रन को एक नामित समीक्षक द्वारा स्पष्ट ओवरराइड होने की प्रतीक्षा में रखा जाता है, जो स्वयं मैनिफिस में लॉग इन किया जाता है।

दो गेट सबसे अधिक आपदाओं को पकड़ते हैं। एक रिग्रेशन गेट (नया मॉडल को मूल बेंचमार्क पर पिछले मॉडल के रूप में कम से कम उतना ही अच्छा होना चाहिए) प्रशिक्षण कीड़े को पकड़ता है। एक KL बजट गेट (समझाव वाली नीति अपने संदर्भ से X से अधिक नहीं बह सकती है) संरेखण ओवरकुकिंग को पकड़ता है। प्रत्येक उत्पादन पाइपलाइन में दोनों होते हैं।

संगीतकार

एक छोटा कोड जो मैनिफिस पढ़ता है, चरणों को भेजता है, कलाकृतियों का पता चलता है, और किसी भी अनुबंध उल्लंघन पर रोक देता है। यह एयरफ्लो नहीं है। यह कुबेफ्लो नहीं है। पाइपलाइन स्वच्छता के लिए आप कुछ उबाऊ चाहते हैं जो आपने लिखा है।

संगीतकार का काम संकीर्ण हैः

डायरी से DAG को हल करें।
प्रत्येक चरण के लिए, जांचें कि क्या अपेक्षित आउटपुट पहले से ही सही हैश पर मौजूद है (यदि हां तो छोड़ दें) ।
मंच चलाएं, स्टडआउट / स्टडर को कैप्चर करें, दीवार घड़ी और लागत को मापें।
डाउनस्ट्रीम चरण के अपेक्षित इनपुट हैश के खिलाफ आउटपुट हैश की पुष्टि करें।
विफलता पर, सटीक विफलता चरण के साथ आंशिक घोषणा पत्र लिखें और शून्य से बाहर निकलें।

यह पायथन की 200 पंक्तियों है. यह फ़ाइल की तरह दिखने वाला है.code/main.pyइस सबक में. हुड के नीचे, असली पाइपलाइन का उपयोग करता हैtorchrunया rayसमूहों पर व्यक्तिगत चरणों को निष्पादित करने के लिए, लेकिन ऑर्केस्ट्रेटर स्वयं एक ही बॉक्स पर चलता है।

प्रयोगों का पता लगाना और कलाकृतियों का भंडारण

दो बाहरी प्रणालियों पाइपलाइन को एंकर करते हैं।

Experiment tracker (wandb, neptune, mlflow).लॉग हानि वक्रों, मूल्यांकन माप, प्रणाली टेलीमेट्री प्रति चरण. ट्रैकर है जहां आप जाना है जब आप की जरूरत है तुलना करने के लिए रन ए के खिलाफ रन बी तीन सप्ताह बाद. टीमों लगभग हमेशा इस के लिए एक होस्ट ट्रैकर का उपयोग - अपने खुद के लिखने समय खो देता है कि प्रशिक्षण में जाना चाहिए.

Artifact store (S3, R2, GCS).चेकपॉइंट, डेटासेट, टोकन, मूल्यांकन रिपोर्ट के लिए अपरिवर्तनीय वस्तु भंडारण। कलाकृतियों को हैश द्वारा संबोधित किया जाता है, फ़ाइल नाम द्वारा नहीं। एक फ़ाइल नाम जैसे latest.ptएक पैर बंदूक है;ckpt-7b-step-20000-sha256:abc123.safetensorsएक अनुबंध है।

ऑर्केस्ट्रेटर दोनों को लिखता है. ट्रैकर मानुषों के लिए चार्ट देखने के लिए है. कलाकृतियों की दुकान अगले चरण के लिए इनपुट की तलाश करने के लिए है.

लागत

सीमा पार दौरे पर एक डॉलर का नंबर संलग्न होता है। बजट अनुशासन दो स्थानों पर होता है।

Pre-run estimate.मैनिफस्ट से, अनुमानित FLOPs (पूर्व-प्रशिक्षण के लिएः 6 x पैराम x टोकन), अपेक्षित GPU घंटे (FLOPs / पीक थ्रूपुट / उपयोगिता), और डॉलर लागत को वर्तमान किराए की दर से गणना करें। यदि अनुमान बजट गेट से अधिक है, तो पाइपलाइन शुरू करने से इनकार कर देता है।

In-run tracking.चरण-दर-चरण दीवार घड़ी और लागत मैनिफिस में लॉग इन की जाती है। प्रत्येक चरण के बाद, शेष बजट की जांच की जाती है। यदि एक चरण ओवरराउंड होता है, तो अगले चरण के गेट का मूल्यांकन नए शेष बजट के साथ किया जाता है। जब वीसी कॉल करता है तो आपको पता नहीं चलता कि आपके पास पैसा नहीं है।

लामा 3 की रिपोर्ट की गई लागत थी $61M. DeepSeek-V3 reported $5.6M मुख्य पूर्व प्रशिक्षण रन के लिए। अनुपात ज्यादातर हार्डवेयर दक्षता और विशेषज्ञों के मिश्रण है -- लेकिन विशिष्ट लागत दिखाई देती है क्योंकि दोनों टीमों ने इसे प्रत्येक चरण पर ट्रैक किया, न कि प्रत्येक रन पर।

पुनरुत्पादनशीलता बनाम निर्धारिता

ये एक ही नहीं हैं. पुनर्निमाण का अर्थ है एक ही मैनिफेस्ट प्लस एक ही कोड प्लस एक ही बुनियादी ढांचे के समान डाउनस्ट्रीम मीट्रिक के साथ एक चेकपॉइंट का उत्पादन। निर्धारक का अर्थ है बिट-समान आउटपुट।

आधुनिक LLM प्रशिक्षण पुनः उत्पन्न किया जा सकता है लेकिन निर्धारक नहीं है। वितरित प्रशिक्षण का कम-क्रम, जीपीयू कर्नेल गैर-निर्धारकता (क्यूबीएलएएस, फ्लैश-एटीएन), और मिश्रित परिशुद्धता गोल करना एक साथ मिलकर रनों के बीच 1ई-5 स्तर पर भिन्न फ्लोट उत्पन्न करता है। यह अंतिम माप के लिए ठीक है, जो नहीं चलते हैं। यदि आप बिट-स्तर के अंतर के साथ डिबग करने की कोशिश कर रहे हैं तो यह घातक है। उपचार प्रत्येक चरण के इनपुट हैश, आउटपुट हैश और शीर्षक मेट्रिक्स को लॉग करना है -- यदि वे मेल खाते हैं, तो रन "पुनर्निवृद्धि" होता है भले ही वजन बिट-समान न हों।

graph LR
    M["Manifest v1.2.3"] --> O["Orchestrator"]
    O --> S["Stages 01 → 12"]
    S --> AS["Artifact Store\n(content-addressed)"]
    S --> ET["Experiment Tracker\n(metrics, curves)"]
    AS --> GATE["Eval Gate"]
    ET --> GATE
    GATE -->|pass| SHIP["Ship"]
    GATE -->|fail| ROLL["Rollback plan"]

    style M fill:#1a1a2e,stroke:#0f3460,color:#fff
    style GATE fill:#1a1a2e,stroke:#e94560,color:#fff
    style SHIP fill:#1a1a2e,stroke:#51cf66,color:#fff
    style ROLL fill:#1a1a2e,stroke:#c0392b,color:#fff

रोलबैक योजना

दौड़ शुरू होने से पहले, प्रत्येक चरण की विफलता के बारे में क्या होता है, लिखें। तीन श्रेणियां।

Cheap to re-run(घंटे): टोकन, मूल्यांकन, क्वांटिज़ेशन, निष्कर्ष सर्वर. बस फिर से चलाएं.
Medium(दिन): एसएफटी, डीपीओ, सीएआई. आधार मॉडल बनाए रखें; केवल संरेखण चरणों को फिर से चलाएं।
Expensive(सप्ताहों और लाखों डॉलर): पूर्व-प्रशिक्षण। यहां रोलबैक योजना "पुनः चलाना" नहीं है। यह "अंतिम अच्छे चेकपॉइंट का उपयोग करना और संशोधित डेटा के साथ सस्ते डाउनस्ट्रीम चरणों को फिर से चलाना है।"

क्योंकि चरण निर्भरताएं टाइप और हैश की जाती हैं, ऑर्केस्ट्रेटर स्वचालित रूप से रोलबैक सेट की गणना कर सकता हैः विफल चरण और प्रत्येक वंशज को अमान्य कर सकता है। चरण 06 (SFT) में विफलता 06, 07, 08, 09, 10, 11, 12 को अमान्य करती है। चरण 11 (क्वांटिकेशन) में विफलता केवल 11 और 12 को अमान्य करती है। इसे पहले नामित करना इम्प्रोविज़िंग से बचाता है जबकि टीम सुबह 4 बजे थकी हुई है।

2026 में देखे गए उत्पादन रेसिपी

अधिकांश सीमावर्ती टीमें एक ही कंकाल पर एक साथ आईं।

128k बीपीई बाइट बैकअप के साथ। एक छोटे, संतुलित बहुभाषी स्लाइस पर प्रशिक्षित।
प्री-ट्रेनिंगः 10-20T टोकन, ज्यादातर वेब प्लस कोड प्लस सिंथेटिक। मून या एडमडब्ल्यू अनुकूलक। FSDP2 या डीपस्पीड ZeRO-3. ग्रेडिएंट चेकपोइंटिंग। BF16 वजन, FP32 मास्टर।
SFT: 500k-2M निर्देश जोड़े, मानव और सिंथेटिक मिश्रित, मूल्यांकन सेट के खिलाफ सख्त dedup के साथ।
संरेखणः डीपीओ या सीएआई + जीआरपीओ। आरएलएचएफ केवल तभी जब प्राथमिकता संकेत डीपीओ के लिए बहुत बहुआयामी हो।
ईवल: एमएमएलयू-प्रो, एमएटीएच, ह्यूमनईवल+, जीपीक्यूए, एसवीई-बेंच सत्यापित, लाइवबेंच, प्लस एक निजी रखा सेट सार्वजनिक कभी नहीं देखता है।
क्वांटिज़ेशनः 4-बिट GPTQ या AWQ सेवा के लिए, 8-बिट सुरक्षा मूल्यांकन के लिए जहां सटीकता डेल्टा मायने रखता है।
सेवाः vLLM, TensorRT-LLM, या घर में. निरंतर बैचिंग. अनुमानात्मक डिकोडिंग. KV कैश निष्कासन.

संख्याएं हर छह महीने में बदलती हैं।

इसे बनाओ

पाठ का कोड एक ऑर्केस्ट्रेटर और एक मैनिफेस्ट चेकर है, बारह प्रशिक्षण स्क्रिप्ट नहीं। प्रत्येक चरण को एक प्लेसहोल्डर के साथ सिमुलेट किया जाता है जो सही आकार और हैश के साथ एक आउटपुट आर्टिफैक्ट का उत्पादन करता है। ऑर्केस्ट्रेटर को अंत से अंत तक चलाना वास्तविक चरणों पर GPU पैसे जलाने से पहले पाइपलाइन के प्लाईनिंग काम करता है।

देखोcode/main.pyपूर्ण कार्यान्वयन के लिए।

Manifestडेटाक्लासः पाइपलाइन संस्करण, बीज, गिट कॉम, चरण, गेट।
Stageडेटाक्लासः नाम, प्रकार, इनपुट (हैश), आउटपुट (हैश), वॉल क्लॉक, लागत।
Orchestrator.run(): DAG हल करता है, चरणों भेजता है, हैश की पुष्टि करता है, अद्यतन प्रकट.
EvalGate.check(): सीमाओं को पढ़ता है, नवीनतम मूल्यांकन रिपोर्ट के साथ तुलना करता है, पास/फेल रिटर्न देता है।
ArtifactStore(मेमोरी में स्टब): डाल/प्राप्त हैश द्वारा, S3 का अनुकरण करता है।
CostTracker: प्रति चरण और संचयी, जब सीमा पार हो जाती है तो रुक जाता है।

पाइपलाइन में main.py12 स्थान धारक चरणों चलाता है, एक मैनिफेस्ट बनाता है, और एक विफल मूल्यांकन गेट का अभ्यास करता है कि एक आयोजित रन कैसा दिखता है। प्रति स्थान धारक को संबंधित पाठ से वास्तविक प्रशिक्षण स्क्रिप्ट के लिए बदल देता है और आपके पास एक वास्तविक सीमा पाइपलाइन का उपयोग करता है।

इसका प्रयोग करें

कैनोनिक वर्कफ़्लो में तीन कमांड होते हैं।

python code/main.py plan    # validate manifest, compute cost estimate, print DAG
python code/main.py run     # execute stages, writing to manifest.out.yaml
python code/main.py gate    # read manifest.out.yaml, apply eval gates, ship-or-hold

दौड़ेंplanअधिकांश पाइपलाइन बग योजना के समय दिखाई देते हैं - गायब गेट सीमाओं, पुराने हैश, बजट ओवरराउंड. चल रहा हैplanमुक्त है. भाग रहा है.runसस्ते पक्ष पर कीड़े पकड़कर पैसे बचाएं।

gateया तो SHIPया HOLD: <reason>. एक आयोजित रन विफलता नहीं है; यह एक निर्णय बिंदु है. एक नामित समीक्षक या तो ओवरराइड करता है (और ओवरराइड लॉग किया जाता है), या वे rollback को मंजूरी देते हैं।

इसे भेजें

यह सबक हमें फल देता हैoutputs/skill-llm-pipeline-reviewer.md. उसे एक प्रस्तावित पाइपलाइन मैनिफेस्ट प्रदान करें और यह सभी अनुबंधों की जांच करता हैः चरण टाइपिंग, हैश चेन, गेट, रोलबैक योजना, लागत अनुमान। यह एक अनुपस्थित मूल्यांकन गेट, एक असीमित KL बजट या एक रन जो मूल्यांकन और प्रशिक्षण डेटा को मिलाता है, के साथ मैनिफेस्ट को मंजूरी देने से इनकार करता है।

व्यायाम

स्टेज 07 और 08 के समानांतर निष्पादन का समर्थन करने के लिए ऑर्केस्ट्रेटर का विस्तार करें। stdlib का उपयोग करें concurrent.futuresमॉड्यूल. पुष्टि करें कि अंतिम प्रकट दोनों चरणों के आउटपुट रिकॉर्ड और कि चरण 09 के इनपुट हैश दोनों का एक निर्धारात्मक संयोजन है।

एक "दूषितता जांच" गेट जोड़ें। eval डेटासेट हैश और प्रशिक्षण डेटासेट के टुकड़े दिए गए, ओवरलैप की गणना करें (सटीक स्ट्रिंग मैच या 13-ग्राम मैच) । गेट विफल रहता है यदि ओवरलैप 0.1% से अधिक है। इसे एक दूषित प्रशिक्षण सेट खिलाएं और पुष्टि करें कि गेट रन को पकड़ता है।

पहले सिद्धांतों से लागत अनुमानक लागू करें। चरण 04 (पूर्व प्रशिक्षण) के लिए, FLOPs का अनुमान 6 x पैराम x टोकन के रूप में करें, H100 पर 40% MFU (मॉडल FLOPs उपयोग) को 989 TFLOPs BF16 पर, $ 2.50 / GPU-घंटे पर मान लें। 2T टोकन पर प्रशिक्षित 7B मॉडल के लिए अनुमान की रिपोर्ट करें। प्रकाशित Llama 2 संख्याओं की तुलना करें।

एक आंशिक रोलबैक बनाएं। चरण 09 (CAI) में एक विफलता का अनुकरण करें, फिर चरण 09 से 12 तक फिर से चलाएं, जबकि 01-08 को कैश छोड़ दें। ऑर्केस्ट्रेटर को हैश द्वारा कैश किए गए कलाकृतियों का पता लगाना चाहिए और उन्हें छोड़ना चाहिए। दीवार घड़ी को सहेजे गए बनाम पूर्ण पुनः रन का मापें।

देखने योग्यता जोड़ें. प्रत्येक चरण के लिए खुला टेलीमेट्री स्पैन जारी करें, जिसमें पैरामीटर, देखे गए टोकन, हानि और लागत के लिए विशेषताएं हैं। स्पैन को स्थानीय कलेक्टर में पाइप करें। मुद्दा डैशबोर्ड नहीं है; मुद्दा यह है कि प्रत्येक चरण का स्वास्थ्य एक एकल निशान आईडी से पता लगाया जा सकता है।

प्रमुख शर्तें

Term	What people say	What it actually means
Manifest	"The recipe file"	YAML or JSON describing pipeline version, seed, per-stage config, and gate thresholds — sufficient to replay a run
Content-addressed	"By hash not name"	Artifacts stored by SHA-256 of their contents, so you can never confuse version A with version B
Eval gate	"The ship criteria"	Numeric thresholds on benchmark metrics and safety scores that must pass before an artifact is marked shippable
KL budget	"How far alignment drifted"	A cap on cumulative KL(policy
MFU	"How much of the GPU you used"	Model FLOPs Utilization — achieved FLOPs divided by theoretical peak. 40% is typical at 70B scale, 55% at 7B
Rollback plan	"What we do when it breaks"	Pre-written set of actions per stage on failure: re-run, fall back, retrain with revised inputs
Orchestrator	"The conductor"	The process that reads the manifest, dispatches stages, verifies hashes, halts on any contract violation
Artifact store	"Versioned S3 for weights"	Immutable content-addressed object store — single source of truth for checkpoints, datasets, eval reports
Reproducible	"Same metrics on replay"	Different bit-level weights but equivalent downstream metrics — the realistic target for distributed LLM training
Cost gate	"You cannot exceed X"	Pre-run cost estimate plus in-run tracker — the pipeline refuses to start if the estimate exceeds budget

आगे पढ़ना

Dubey et al., 2024 -- "The Llama 3 Herd of Models"-- सीमा पाइपलाइन का सबसे विस्तृत सार्वजनिक विवरण जिसमें डेटा, प्रशिक्षण, संरेखण, मूल्यांकन शामिल है
DeepSeek-AI, 2024 -- "DeepSeek-V3 Technical Report"-- दक्षता-पहले पाइपलाइन लगभग 1/10 Llama 3 वर्ग प्रशिक्षण की लागत
Kaplan et al., 2020 -- "Scaling Laws for Neural Language Models"-- मूल कम्प्यूटिंग-डेटा-पेरम्स स्केलिंग रिश्ता
Hoffmann et al., 2022 -- "Training Compute-Optimal Large Language Models (Chinchilla)"-- काप्लान को सुधार जो आधुनिक डेटा बजट को पुनः मापता है
PyTorch FSDP2 documentation-- PyTorch 2.4+ में FSDP1 की जगह वितरित प्रशिक्षण आदिम
Weights & Biases LLM Reports-- ओपन सोर्स LLM रन के लिए वास्तविक मैनिफेस्ट और प्रयोग ट्रैकर आउटपुट, plagiarizable टेम्पलेट के रूप में उपयोगी

This free lesson is part of the AI Engineering from Scratch curriculum. Read the full explanation, run the lesson code, and verify the result in the interactive reader or from the repository source.

Browse the complete course catalog or open this lesson on GitHub.