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

स्टेप 15 · रीज़निंग मॉडल्स (Reasoning models)

सबसे नया अध्याय। एक बड़े मॉडल के ज़रिए क्षमता बढ़ाने के बजाय, जवाब देते समय ज़्यादा सोचने के ज़रिए क्षमता बढ़ाएं।

पाठ वीडियो में

60 सेकंड में

स्टेप 15 · रीज़निंग मॉडल्स (Reasoning models)

सबसे नया अध्याय। एक बड़े मॉडल के ज़रिए क्षमता बढ़ाने के बजाय, जवाब देते समय ज़्यादा सोचने के ज़रिए क्षमता बढ़ाएं।

1/6
आसान शब्दों में
कोई मुश्किल सवाल पूछें, तो एक अच्छा छात्र तुरंत पहली बात नहीं बोल देता। वे पहले रफ़ कागज़ पर हिसाब लगाते हैं। रीज़निंग मॉडल्स को रफ़ कागज़ का इस्तेमाल करने — और उसका भरपूर इस्तेमाल करने के लिए ट्रेन किया जाता है।
दो अलग-अलग विचार एक साथ आए, और उन्होंने मिलकर यह बदल दिया कि कठिन समस्याओं पर मॉडल्स क्या कर सकते हैं।
  1. 1

    पहला विचार · सोचना सिर्फ़ और अधिक tokens हैं

    एक मॉडल जो जवाब देने से पहले अपने काम करने का तरीका लिखता है, वह बेहतर प्रदर्शन करता है। Chain-of-thought की शुरुआत एक प्रॉम्प्टिंग ट्रिक के रूप में हुई और यह ट्रेनिंग का लक्ष्य बन गया।
  2. 2

    दूसरा विचार · कुछ जवाब मशीन द्वारा जाँचे जा सकते हैं

    गणित का एक सही जवाब होता है। कोड या तो टेस्ट पास करता है या नहीं। इसका मतलब है कि आप बिना किसी इंसान के एक रीज़निंग प्रयास को स्कोर कर सकते हैं, और ऐसे लाखों प्रयासों को स्कोर कर सकते हैं।
  3. 3

    इन्हें एक साथ लाएं

    प्रति समस्या कई रीज़निंग प्रयासों का सैंपल लें, जो सत्यापन योग्य रूप से काम करे उसे रखें, उस पर ट्रेन करें, और दोहराएं। यह सत्यापन योग्य रिवॉर्ड्स से रीइन्फोर्समेंट लर्निंग (reinforcement learning from verifiable rewards) है।
  4. 4

    हैरानी की बात

    इस तरह से ट्रेन किए गए मॉडल्स ऐसे व्यवहार विकसित करते हैं जो किसी ने लिखे नहीं थे: अपने काम की खुद जाँच करना, गलत दिशा में जाने के बाद पीछे लौटना, दूसरा तरीका आजमाना। ये ऑप्टिमाइज़ेशन से उभरे हैं, किसी प्रदर्शन डेटा से नहीं।
Group-relative policy optimisation, in outlinepython
def grpo_step(model, ref_model, prompts, verify_fn, group=8, beta=0.04):
    losses = []
    for prompt in prompts:
        # 1. sample a group of independent attempts
        completions = [model.generate(prompt, temperature=1.0)
                       for _ in range(group)]

        # 2. score each one objectively -- no reward model needed
        rewards = torch.tensor([verify_fn(prompt, c) for c in completions])

        # 3. advantage = how much better than the group average
        adv = (rewards - rewards.mean()) / (rewards.std() + 1e-6)

        # 4. push probability toward above-average attempts,
        #    with a KL leash back to the reference model
        for c, a in zip(completions, adv):
            logp     = model.logprob(prompt, c)
            ref_logp = ref_model.logprob(prompt, c)
            losses.append(-(a * logp) + beta * (logp - ref_logp))
    return torch.stack(losses).mean()

def verify_fn(prompt, completion):
    """1.0 if the final answer is provably correct, else 0.0."""
    return float(extract_answer(completion) == known_answer(prompt))
यह करें
मुख्य लाइन verify_fn है। जहाँ आप एक ईमानदार चेकर लिख सकते हैं, वहाँ आप असीमित ट्रेनिंग सिग्नल जनरेट कर सकते हैं। जहाँ आप ऐसा नहीं कर सकते, वहाँ यह पूरा तरीका लागू नहीं होता — यही वजह है कि रीज़निंग मॉडल्स गणित, कोड और फ़ॉर्मल लॉजिक में सबसे मजबूत होते हैं, और उन क्षेत्रों में बहुत कम बदलाव लाते हैं जहाँ सही होना राय या निर्णय का मामला है।

टेस्ट-टाइम कंप्यूट: स्केलिंग का एक दूसरा अक्ष (axis)

ऐतिहासिक रूप से आप ट्रेनिंग कंप्यूट के ज़रिए क्षमता बढ़ाते थे। रीज़निंग मॉडल्स आपको इसे इन्फ़्रेंस (inference) कंप्यूट के ज़रिए बढ़ाने देते हैं: ज़्यादा देर तक सोचें, कई प्रयासों का सैंपल लें, उन्हें जांचें, और सबसे अच्छा चुनें।
तरीकायह कैसे काम करता हैलागत (Cost)
लंबी chain of thoughtबस ज़्यादा tokens के लिए सोचेंसोचने की लंबाई के हिसाब से लीनियर (Linear)
सेल्फ़-कंसिस्टेंसी (Self-consistency)N जवाबों का सैंपल लें, बहुमत को चुनेंलागत N गुना
वेरिफ़ायर के साथ Best-of-NN का सैंपल लें, एक चेकर विजेता चुनता हैN गुना, साथ में वैरिफ़िकेशन
कदमों पर सर्च (Search over steps)अधूरे समाधानों के ट्री (tree) को एक्सप्लोर करेंकाफ़ी ज़्यादा, और कठिन समस्याओं पर बहुत बेहतर
सावधान रहें
दो ईमानदार सीमाएं। लागत: एक रीज़निंग जवाब सीधे जवाब की तुलना में दस से सौ गुना अधिक tokens की खपत कर सकता है, और यूज़र्स को लेटेंसी (देरी) महसूस होती है। निष्ठा (Faithfulness): इस बात की कोई गारंटी नहीं है कि जो रीज़निंग दिख रही है, वही जवाब का वास्तविक कारण है — एक मॉडल एक सुव्यवस्थित chain of thought पेश कर सकता है और किसी दूसरे रास्ते से अपने निष्कर्ष तक पहुँच सकता है। इस ट्रेस (trace) को ऑडिट लॉग न समझें।
ख़तरा
ट्रैक B के लिए यह व्यावहारिक रूप से मायने रखता है। एक रीज़निंग एजेंट जो तीस हज़ार tokens तक सोचता है, उसके पास किसी इंजेक्टेड निर्देश के प्रभावित करने के लिए तीस हज़ार tokens का दायरा होता है, और प्रभावित होते हुए भी उसका रीज़निंग ट्रेस पूरी तरह से उचित लग सकता है। ट्रेस को लॉग करें, लेकिन सुरक्षा नियंत्रण के रूप में कभी भी इस पर भरोसा न करें।

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

Deep dive into LLMs like ChatGPTAndrej Karpathy · covers RL and reasoning · video

लैब

आपके द्वारा लिखे गए वेरिफ़ायर के साथ ट्रेन किया गया एक रीज़निंग मॉडल।

~30 min

समस्या

एक बेस मॉडल और जाँचे जा सकने वाले जवाबों वाला एक गणित डेटासेट लें। GRPO लागू करें: प्रति समस्या एक ग्रुप का सैंपल लें, सटीक-जवाब चेकर के साथ स्कोर करें, और औसत से बेहतर प्रयासों की ओर बढ़ावा दें। पहले और बाद की सटीकता मापें।
शुरुआती कोडpython
def verify(problem, completion):
    return float(extract_final_answer(completion) == problem["answer"])
adv = (rewards - rewards.mean()) / (rewards.std() + 1e-6)
Google Colab खोलें ↗इस कोड के लिए आपके अपने सेटअप की ज़रूरत है (एक मॉडल, एक GPU या अतिरिक्त पैकेज)। इसे Google Colab में चलाएं: File → Upload notebook।

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

कठिन सवाल

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

Q1सटीकता बढ़ी और जवाब तीन गुना लंबे हो गए। दो व्याख्याएं — आप कैसे बताएंगे कि कौन सी सही है?दिखाएं
या तो मॉडल ने चरणों में सोचना सीख लिया है, जो वास्तव में मदद करता है, या उसने सीखा कि लंबे आउटपुट का संबंध रिवॉर्ड से है — यानी लेंथ हैकिंग। इन्फ़्रेंस के समय आउटपुट की लंबाई सीमित करके और फिर से मापकर अंतर समझें: यदि सटीकता बनी रहती है, तो लंबाई संयोगवश थी; यदि यह गिर जाती है, तो लंबाई ही रणनीति थी। साथ ही बीस लंबे जवाबों को खुद पढ़ें और जांचें कि क्या बीच का हिस्सा कोई काम करता है या सिर्फ़ जगह भरता है।

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

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

क्या यह सिर्फ़ chain-of-thought प्रॉम्प्टिंग है?

शुरुआत वहीं से हुई थी। अंतर यह है कि यह व्यवहार अब प्रॉम्प्ट में अनुरोध करने के बजाय एक वास्तविक ऑप्टिमाइज़ेशन सिग्नल के साथ ट्रेन किया गया है, जो इसे कहीं अधिक विश्वसनीय बनाता है और ऐसी रणनीतियाँ विकसित करने देता है जो किसी ने दिखाई नहीं थीं।

क्या मैं खुद एक रीज़निंग मॉडल को ट्रेन कर सकता हूँ?

छोटे पैमाने पर, हाँ, और यह एक बेहतरीन प्रोजेक्ट है। एक ओपन बेस मॉडल, जाँचे जा सकने वाले जवाबों वाला एक गणित डेटासेट, और एक ओपन RL लाइब्रेरी से GRPO इम्प्लीमेंटेशन लें। आपको LoRA के साथ एक सिंगल GPU पर मापने योग्य सुधार दिखेगा।

क्या यह गणित और कोड के अलावा भी मदद करता है?

सामान्य रीज़निंग में कुछ हद तक सुधार देखा गया है। लेकिन ट्रेनिंग सिग्नल सत्यापन योग्य डोमेन से आता है, इसलिए लाभ वहीं सबसे मजबूत हैं। जहाँ भी सही होने पर मतभेद हो, वहाँ ऑप्टिमाइज़ करने के लिए कोई रिवॉर्ड नहीं है।

क्या मुझे हमेशा रीज़निंग मॉडल का ही इस्तेमाल करना चाहिए?

नहीं। सारांश बनाने, डेटा निकालने (extraction), फ़ॉर्मेटिंग और चैट के लिए, एक मानक मॉडल तेज़ और बहुत सस्ता होता है, और अक्सर उतना ही अच्छा होता है। कठिन समस्याओं को रीज़निंग मॉडल पर भेजें और बाकी सब कुछ किसी छोटे मॉडल पर।

पाठ का टेस्ट

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

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