स्टेप 15 · रीज़निंग मॉडल्स (Reasoning models)
सबसे नया अध्याय। एक बड़े मॉडल के ज़रिए क्षमता बढ़ाने के बजाय, जवाब देते समय ज़्यादा सोचने के ज़रिए क्षमता बढ़ाएं।
60 सेकंड में
स्टेप 15 · रीज़निंग मॉडल्स (Reasoning models)
सबसे नया अध्याय। एक बड़े मॉडल के ज़रिए क्षमता बढ़ाने के बजाय, जवाब देते समय ज़्यादा सोचने के ज़रिए क्षमता बढ़ाएं।
- 1
पहला विचार · सोचना सिर्फ़ और अधिक tokens हैं
एक मॉडल जो जवाब देने से पहले अपने काम करने का तरीका लिखता है, वह बेहतर प्रदर्शन करता है। Chain-of-thought की शुरुआत एक प्रॉम्प्टिंग ट्रिक के रूप में हुई और यह ट्रेनिंग का लक्ष्य बन गया। - 2
दूसरा विचार · कुछ जवाब मशीन द्वारा जाँचे जा सकते हैं
गणित का एक सही जवाब होता है। कोड या तो टेस्ट पास करता है या नहीं। इसका मतलब है कि आप बिना किसी इंसान के एक रीज़निंग प्रयास को स्कोर कर सकते हैं, और ऐसे लाखों प्रयासों को स्कोर कर सकते हैं। - 3
इन्हें एक साथ लाएं
प्रति समस्या कई रीज़निंग प्रयासों का सैंपल लें, जो सत्यापन योग्य रूप से काम करे उसे रखें, उस पर ट्रेन करें, और दोहराएं। यह सत्यापन योग्य रिवॉर्ड्स से रीइन्फोर्समेंट लर्निंग (reinforcement learning from verifiable rewards) है। - 4
हैरानी की बात
इस तरह से ट्रेन किए गए मॉडल्स ऐसे व्यवहार विकसित करते हैं जो किसी ने लिखे नहीं थे: अपने काम की खुद जाँच करना, गलत दिशा में जाने के बाद पीछे लौटना, दूसरा तरीका आजमाना। ये ऑप्टिमाइज़ेशन से उभरे हैं, किसी प्रदर्शन डेटा से नहीं।
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)
| तरीका | यह कैसे काम करता है | लागत (Cost) |
|---|---|---|
| लंबी chain of thought | बस ज़्यादा tokens के लिए सोचें | सोचने की लंबाई के हिसाब से लीनियर (Linear) |
| सेल्फ़-कंसिस्टेंसी (Self-consistency) | N जवाबों का सैंपल लें, बहुमत को चुनें | लागत N गुना |
| वेरिफ़ायर के साथ Best-of-N | N का सैंपल लें, एक चेकर विजेता चुनता है | N गुना, साथ में वैरिफ़िकेशन |
| कदमों पर सर्च (Search over steps) | अधूरे समाधानों के ट्री (tree) को एक्सप्लोर करें | काफ़ी ज़्यादा, और कठिन समस्याओं पर बहुत बेहतर |
और देखें और पढ़ें
लैब
आपके द्वारा लिखे गए वेरिफ़ायर के साथ ट्रेन किया गया एक रीज़निंग मॉडल।
समस्या
def verify(problem, completion):
return float(extract_final_answer(completion) == problem["answer"])
adv = (rewards - rewards.mean()) / (rewards.std() + 1e-6)आपका काम तब पूरा होगा जब
कठिन सवाल
उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।
Q1सटीकता बढ़ी और जवाब तीन गुना लंबे हो गए। दो व्याख्याएं — आप कैसे बताएंगे कि कौन सी सही है?दिखाएं
अक्सर पूछे जाने वाले सवाल
क्या यह सिर्फ़ chain-of-thought प्रॉम्प्टिंग है?
शुरुआत वहीं से हुई थी। अंतर यह है कि यह व्यवहार अब प्रॉम्प्ट में अनुरोध करने के बजाय एक वास्तविक ऑप्टिमाइज़ेशन सिग्नल के साथ ट्रेन किया गया है, जो इसे कहीं अधिक विश्वसनीय बनाता है और ऐसी रणनीतियाँ विकसित करने देता है जो किसी ने दिखाई नहीं थीं।
क्या मैं खुद एक रीज़निंग मॉडल को ट्रेन कर सकता हूँ?
छोटे पैमाने पर, हाँ, और यह एक बेहतरीन प्रोजेक्ट है। एक ओपन बेस मॉडल, जाँचे जा सकने वाले जवाबों वाला एक गणित डेटासेट, और एक ओपन RL लाइब्रेरी से GRPO इम्प्लीमेंटेशन लें। आपको LoRA के साथ एक सिंगल GPU पर मापने योग्य सुधार दिखेगा।
क्या यह गणित और कोड के अलावा भी मदद करता है?
सामान्य रीज़निंग में कुछ हद तक सुधार देखा गया है। लेकिन ट्रेनिंग सिग्नल सत्यापन योग्य डोमेन से आता है, इसलिए लाभ वहीं सबसे मजबूत हैं। जहाँ भी सही होने पर मतभेद हो, वहाँ ऑप्टिमाइज़ करने के लिए कोई रिवॉर्ड नहीं है।
क्या मुझे हमेशा रीज़निंग मॉडल का ही इस्तेमाल करना चाहिए?
नहीं। सारांश बनाने, डेटा निकालने (extraction), फ़ॉर्मेटिंग और चैट के लिए, एक मानक मॉडल तेज़ और बहुत सस्ता होता है, और अक्सर उतना ही अच्छा होता है। कठिन समस्याओं को रीज़निंग मॉडल पर भेजें और बाकी सब कुछ किसी छोटे मॉडल पर।
पाठ का टेस्ट
5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।