Chain of Thought, RLVR और Test-Time Compute: माप के साथ

लुभावना यह कहना है कि दूसरे version ने "इसके बारे में सोचा"। इससे बचिए, क्योंकि mechanism जानने के लिए इससे सरल और ज़्यादा उपयोगी है।

एक transformer हर generate किए गए token पर computation की एक fixed मात्रा करता है। एक forward pass: वही layers, वही matrices, operations की वही संख्या, चाहे प्रश्न 2+2 क्या है हो या इस theorem को prove करो। model के भीतर "इस पर ज़्यादा मेहनत करो" के लिए कोई dial नहीं है।

इसलिए जब किसी model से तुरंत उत्तर माँगा जाता है, तो उसके पास उपलब्ध पूरा computation एक forward pass होता है। हर intermediate quantity को उसी single pass की activations में fit होना पड़ता है, और जो कुछ वह वहाँ compute नहीं कर सकता, वह compute नहीं कर सकता।

token emit करने से यह बदलता है, और यह दो अलग-अलग तरीकों से बदलता है जिन्हें अलग रखना ज़रूरी है:

• ज़्यादा computation. हर generated token एक और पूरा forward pass है। working के सौ पैंतालीस token, सीधे जवाब देने की arithmetic के सौ पैंतालीस गुना हैं।
• Externalised memory. token context में लिख दिए जाते हैं, इसलिए अगला pass उन्हें पढ़ सकता है। 5 × 13 = 65 input में एक fact बन जाता है, कोई ऐसी value नहीं जिसे model को activation में पकड़कर आगे ले जाना हो। model अपने ही output को scratchpad की तरह इस्तेमाल कर रहा है।

दूसरा point वही है जिसे लोग अक्सर चूक जाते हैं, और यही समझाता है कि मदद के लिए working को लिखना क्यों पड़ता है। किसी model से अगर कहा जाए कि "चुपचाप इसके बारे में सोचो और फिर जवाब दो", तो उसके पास उस thought को रखने की जगह नहीं होती।

इसमें किसी रहस्यवाद की ज़रूरत नहीं है, और यह एक ठोस prediction देता है: chain of thought उन समस्याओं पर सबसे ज़्यादा मदद करनी चाहिए जिनकी structure serial है — जहाँ step two को step one के result की ज़रूरत होती है — और उन समस्याओं पर सबसे कम जिनमें बस एक lookup है। literature में ठीक यही मिलता है, और इसी वजह से "think step by step" France की राजधानी क्या है पर कुछ नहीं करता।

यह technique 2022 में दो हिस्सों में आई। Wei et al. ने दिखाया कि prompt में worked examples शामिल करना — ऐसे demonstrations जहाँ answer से पहले reasoning आती है — arithmetic और commonsense benchmarks पर बड़े gains देता है।¹ फिर Kojima et al. ने कुछ ज़्यादा अजीब दिखाया: examples की ज़रूरत नहीं है। zero-shot prompt में "Let's think step by step" जोड़ना उसी gain का बड़ा हिस्सा capture कर लेता है।²

दूसरा result बताता है कि असल में क्या हो रहा है। अगर कोई magic phrase behaviour को unlock करता है, तो behaviour model में पहले से था — pretraining worked solutions से भरी है, और phrase distribution के उस क्षेत्र की ओर pointer है। Chain of thought ने model को कुछ सिखाया नहीं। उसने model में पहले से मौजूद चीज़ को select किया।

यह framing technique के अंततः अप्रचलित होने की भी भविष्यवाणी करती है, जिस पर हम अध्याय के अंत में लौटेंगे।

अगला obvious कदम: अगर reasoning की एक chain गलत हो सकती है, तो कई sample करें और majority answer लें। यही self-consistency है।³ यह strictly बड़ा खर्च है — एक के बजाय $n$ full generations — और intuition यह है कि गलत answers बिखरते हैं जबकि सही answers सहमत होते हैं।

उन्हीं समस्याओं में से 16 पर मापा गया, temperature 0.8 पर sampling, $n$ chains पर majority vote:

सोलह समस्याएँ छोटा denominator हैं, और अध्याय 4 का rule इस table पर भी उतना ही लागू होता है जितना किसी और पर। 16 में से 13 यानी 81 % है, 95 % Wilson interval [57, 93] के साथ; 16 में से 16 यानी 100 % है, [81, 100] के साथ। ये overlap करते हैं। curve का shape पढ़िए, वही finding है; उस exact rung को मत पढ़िए जहाँ यह flat होता है, क्योंकि सोलह समस्याएँ उसे locate नहीं कर सकतीं।

उस table में दो बातें हैं, और दूसरी वह नहीं है जिसकी मुझे उम्मीद थी।

curve $n = 3$ पर flat हो जाता है। तीसरे sample तक accuracy अपने ceiling पर है और बचे हुए दो samples कुछ नहीं खरीदते, जबकि हर एक की लागत 172 token है, दोनों मिलाकर 345। literature में report की गई हर self-consistency curve का shape यही है, और यह "more samples is more better" framing से कहीं पहले आ जाता है।

और greedy decoding पहले से 100 % पर था। अध्याय की शुरुआत पर लौटकर देखिए: one chain, no sampling, 145 token, 24/24. temperature 0.8 पर sampling ने accuracy को घटाकर 81 % कर दिया, और self-consistency को वहाँ वापस चढ़ने के लिए तीन generations चाहिए थीं जहाँ एक single greedy pass पहले से था — 3.6 गुना token पर, या छह गुना अगर आप यह जाने बिना sweep को पाँच तक चलाएँ कि curve कहाँ flat होता है।

यह self-consistency के ख़िलाफ़ argument नहीं है। यह सटीक statement है कि वह करती क्या है: temperature errors inject करके diversity खरीदता है, और voting वही errors हटाती है जो उसने अभी inject किए। जिन समस्याओं पर greedy decoding fail होती है — जहाँ single most likely chain गलत जगह ले जाती है और कोई less likely chain सही होती है — वहाँ यह trade payoff करता है, और इसी वजह से technique मौजूद है। जिन समस्याओं पर greedy पहले से सफल है, वहाँ यह budget को छह गुना खर्च करके break even करने का तरीका है।

दूसरा case कोई publish नहीं करता, इसलिए अपनी task पर technique अपनाने से पहले इसे measure करना क़ीमती है। ये एक small model के लिए आसान two-step problems हैं; यही वह regime है जहाँ answer इस तरह आता है।

अब तक सब कुछ prompt time पर ऐसे model पर हो रहा है जिसे इसके लिए specifically train नहीं किया गया था। reasoning models की current generation बनाने वाला shift इसे training में ले जाना था — और वह key जिसने इसे possible बनाया, सुनने में जितनी broad लगती है उससे narrow है।

अध्याय 11 की post-training को human preferences चाहिए थीं, क्योंकि "क्या यह अच्छा answer था?" का कोई programmatic answer नहीं है। लेकिन कुछ questions के लिए होता है। mathematical answer या तो correct value के बराबर होता है या नहीं। Code या तो tests pass करता है या नहीं। Proof या तो check होती है या नहीं।

इन domains के लिए आप reward model को verifier से replace कर सकते हैं, और downstream सब कुछ एक साथ बेहतर हो जाता है: कोई annotators नहीं, कोई Bradley–Terry fitting नहीं, अध्याय 11 में मापे गए तरह का कोई reward hacking नहीं — क्योंकि आप unit test की चापलूसी नहीं कर सकते। यह reinforcement learning from verifiable rewards है, और यही वह setting है जिसके लिए GRPO बनाया गया था: same problem के लिए solution attempts का group sample करें, हर एक को check करें, और group के mean score को baseline की तरह use करें। कोई critic नहीं, कोई annotator नहीं, कोई reward model नहीं। बस एक program जो कहता है सही या गलत।

field को reframe करने वाला result 2025 की शुरुआत में DeepSeek से आया।⁶ उन्होंने एक base model लिया और verifiable rewards के साथ reinforcement learning directly apply किया, पहले कोई supervised fine-tuning stage लगाए बिना — वही stage जिसे अध्याय 11 हर चीज़ की foundation की तरह प्रस्तुत करता है। reasoning की long chains फिर भी emerge हुईं। ऐसे behaviours भी जिनके लिए किसी ने train नहीं किया था: model ने अपने steps को re-check करना शुरू किया और, paper के सबसे ज़्यादा quoted passage में, mid-solution किसी approach पर spontaneously reconsider किया।

ईमानदार reading यह नहीं है कि reasoning magic है। बात यह है कि जब reward केवल right होने को मिलता है, और hard problem पर right होने के लिए उसे work through करना पड़ता है, तो optimiser वही find करता है — जिसमें work through करने के वे हिस्से भी शामिल हैं जो humans भी करते हैं, क्योंकि वे problem की requirement हैं, किसी की teaching नहीं।

इन सबका practical consequence यह है कि reasoning model वे tokens produce करता है जो आपने माँगे थे और वे tokens भी जो आपने नहीं माँगे, और आप दोनों के लिए pay करते हैं।

Providers इसे अलग-अलग handle करते हैं, और फर्क मायने रखता है:

• Most APIs reasoning tokens को output token count के inside count करती हैं। आपके bill और आपकी max_tokens limit, दोनों में वह thinking शामिल है जिसे आप कभी देखते नहीं।
• Google's Gemini thinking tokens को standard output count के बाहर एक separate field के रूप में report करता है।

यह एक ही चीज़ को count करने के दो तरीकों के बीच real incompatibility है, और providers के across cost compute करने या budget enforce करने वाले किसी भी code को इसे normalise करना होगा। अध्याय 16 में यह money बनता है, और अध्याय 23 में वह budget जिसे आप enforce कर सकते हैं।

दूसरा consequence latency वाला है, जो लोगों को पहली बार चौंकाता है। reasoning model के पहले visible token तक का time उसकी सारी thinking शामिल करता है, इसलिए कोई request जो आठ seconds तक कुछ stream नहीं करती और फिर एक second में answer देती है, hung connection नहीं है — model काम कर रहा है। कोई भी interface जो आठ seconds तक बिना explanation spinner दिखाता है, उसमें design problem है, networking problem नहीं।

एक closing warning, क्योंकि यही इस अध्याय की material को गलत apply करने का सबसे common तरीका है।

पहले half की हर चीज़ ऐसी technique है जो उस model से reasoning produce करवाती है जिसे reason करने के लिए train नहीं किया गया था। RLVR से trained models यह पहले से करते हैं: वे answer देने से पहले अपनी working, अपनी length पर, emit करते हैं। ऐसे model से think step by step कहना best case में redundant और worst case में harmful है — यह उस longer chain की जगह short, prompt-shaped chain produce कर सकता है जो model अपने आप generate करता, और कुछ providers exactly यही document करते हैं।

Application code में बने elaborate reasoning scaffolds पर भी यही लागू होता है। ऐसा prompt जो model को decision tree से walk कराता है जिसे वह internally पहले से navigate करता है, आपके tokens खर्च करके उस behaviour को constrain कर रहा है जिसे training में डाला गया था। यह उस theme की पहली appearance है जो course के बाकी हिस्से में चलती है: जो techniques 2022 में essential थीं, वे 2025 तक superstition बन गईं, और आज आपके model के लिए कौन सी कौन है, यह जानने का एकमात्र तरीका दोनों को measure करना है।

अध्याय 15 में वही measurement opinion के बजाय discipline बनता है।

Reasoning की एक असहज property है: यह इकलौती capability है जिसकी cost question की difficulty के साथ scale होती है। नौ सौ tokens तक सोचने वाला model नौ सौ forward passes करता है, उन सभी के लिए memory में बढ़ता हुआ cache रखता है, और duration भर GPU hold करता है।

इससे reasoning model serve करने की economics, chat model serve करने की तुलना में sharp रूप से worse हो जाती है, और implementation details का एक set viable product और unviable product के बीच फर्क बन जाता है: past keys और values का cache कैसे store और reuse होता है, कितनी requests एक forward pass share कर सकती हैं, और weights को वास्तव में कितनी precision चाहिए।

अध्याय 13 आख़िरी अध्याय है जहाँ model किसी port के पीछे service होने के बजाय आपकी memory में object है, और यह उस object को इतना cheap बनाने के बारे में है कि उसे serve किया जा सके। यह इस chapter का एक promise भी cash करता है: speculative decoding, जो एक small model से guess करवाकर और large model से check करवाकर roughly one token की कीमत पर कई tokens produce करता है — एक trick जो तभी समझ में आती है जब आप देख चुके हों कि forward pass का कितना हिस्सा arithmetic करने के बजाय memory का इंतज़ार करने में खर्च होता है।

इस अध्याय में सभी measurements Qwen/Qwen2.5-0.5B-Instruct से आए हैं, 24 generated two-step word problems पर, जहाँ sampling stated है उसे छोड़कर greedy decoding, और used token caps पर zero truncated generations के साथ। वे reproducible हैं, और वे easy problems पर small model हैं: self-consistency result को mechanism की demonstration की तरह पढ़िए, benchmark की तरह नहीं। CS229 lecture notes का अध्याय 18 और Hugging Face LLM Course का अध्याय 12, दोनों इस material को larger models और proper benchmarks के साथ cover करते हैं।