Search-R1 एक LLM को reinforcement learning से train करता है। Training के बाद LLM खुद तय करता है कि कब search करनी है, क्या search करनी है, और कब रुकना है। इस training को हर सवाल का सिर्फ़ सही जवाब चाहिए, search के steps नहीं।
Lesson 6 का सवाल फिर लीजिए: Who is older, Jed Hoyer or John William Henry II? Lecture के trace में model ने 3 searches कीं, और सही जवाब दिया। लेकिन training data में इस सवाल के साथ सिर्फ़ जवाब लिखा है: John William Henry II। पहली query क्या हो, कितनी searches हों, और कब रुकें, ये कहीं नहीं लिखा।
इस lesson की सीढ़ी
सीढ़ी में 5 पड़ाव हैं। हर पड़ाव के नीचे लिखा है कि उसके बाद आप क्या कर पाएँगे।
पहले से क्या चाहिए: Lesson 1 (probability, next-token prediction), Lesson 4 (loss, gradient), Lesson 5 (Exact Match), Lesson 6 (multi-hop) और Lesson 16 (agent, action)। जो पड़ाव आपको पहले से आता है, उसे छोड़कर अगले पर जाइए। जिस शब्द के नीचे बिंदुओं वाली line और ▾ हो, उस पर click करने से उसका मतलब खुलता है।
1सिर्फ़ आख़िरी जवाब से सीखना: rollout, reward और policy
Reinforcement learning (RL) में model एक सवाल पर कई कोशिशें करता है, और हर कोशिश के आख़िर में उसे एक number मिलता है। फिर training उन कोशिशों के tokens की probability बढ़ाती है, जिनका number अच्छा रहा। Lesson 4 की इससे अलग थी। वहाँ data में सही output लिखा होता था, और training उसी output की बढ़ाती थी। Search के फ़ैसलों का कोई एक सही output नहीं है, क्योंकि Hoyer वाले सवाल पर 2 searches भी काफ़ी हो सकती हैं, और 3 भी।
लेकिन आख़िरी जवाब हर बार check हो सकता है, और RL इसी पर टिका है। RL के तीन शब्द आगे हर जगह आएँगे:
Rollout
एक सवाल पर शुरू से आख़िरी जवाब तक की एक पूरी कोशिश: सोचना, searches, लौटे passages और जवाब। इसे trajectory भी कहते हैं।
Reward
Rollout के आख़िर में मिला number। Search-R1 में जवाब सही जवाब से हूबहू मिले, तो 1, नहीं तो 0। ये lesson 5 वाला है। paper से
Policy
जो हर कदम पर फ़ैसला लेता है। यहाँ LLM ही policy है, क्योंकि अगला token, यानी सोचना, search करना या जवाब देना, वही चुनता है।
एक सवाल पर अलग-अलग rollouts तभी बनते हैं, जब model हर बार एक ही रास्ता न ले। इसलिए model हर token चुनता है। जैसे पहले <think> के बाद model <search> को 0.6 probability दे, और सीधे <answer> को 0.4। तब 100 rollouts में करीब 60 search से शुरू होंगे, और करीब 40 सीधे जवाब देंगे। probabilities मेरी बनाई
अब Hoyer वाले सवाल पर 4 rollouts देखिए। ये चार rollouts मेरा example हैं
Rollout
क्या किया
आख़िरी जवाब
Reward
o1
दोनों की जन्म-तारीख search की
John William Henry II
1
o2
बिना search, अंदाज़ा
Jed Hoyer
0
o3
एक search, फिर अंदाज़ा
Jed Hoyer
0
o4
दोनों की जन्म-तारीख search की
John William Henry II
1
Training o1 और o4 के tokens की probability बढ़ाती है, और इन tokens में दोनों तारीखें search करने वाले फ़ैसले भी हैं। o2 और o3 के tokens की probability घटती है, जिनमें बिना search अंदाज़ा लगाना भी है। ये बढ़ाना और घटाना ठीक-ठीक कैसे होता है, ये पड़ाव 3 में आता है। हज़ारों सवालों के बाद model ऐसे सवालों पर दोनों तारीखें ढूँढना सीखता है। किसी ने search steps का label नहीं लिखा, सिर्फ़ आख़िरी जवाब check हुआ।
पहले सोचिए
मान लीजिए model हर बार सबसे ऊँची probability वाला token लेता है। तब 4 rollouts कितने अलग होंगे, और training को उनसे क्या मिलेगा?
जवाब देखिए
चारों एक जैसे होंगे, क्योंकि हर कदम पर वही token जीतेगा, जैसे पहले कदम पर 0.6 वाला <search>। तब चारों को एक ही reward मिलेगा, और तुलना के लिए कुछ नहीं बचेगा। RL को अलग-अलग कोशिशें चाहिए, और वो random चुनने से आती हैं।
2Search भी text है: चार tags और lecture का trace
Search-R1 में model search को भी text की तरह लिखता है, और system उस text को पहचानकर असली search engine चलाता है।Search-R1 इसके लिए 4 tags रखता है। Tag text के दोनों ओर लगा एक निशान है, जैसे <search> और </search>।
Tag
कौन लिखता है
अंदर क्या है
<think>
Model
सोचना: अब तक क्या पता है, और क्या कम है
<search>
Model
Query
<information>
System
Search engine के top results। Model इन्हें नहीं लिखता।
<answer>
Model
आख़िरी जवाब। Reward इसी पर लगता है।
Model जैसे ही </search> लिखता है, system query निकालकर search engine से top 3 passages लाता है। 3 paper से System इन्हें <information> tags में रखकर text के आगे जोड़ता है, और model वहीं से आगे लिखता है। ये तब तक चलता है, जब तक model <answer> न लिख दे। Model को हर सवाल के साथ एक छोटी instruction मिलती है, जो ये चारों tags समझाती है। वो पड़ाव 4 की slide पर नीचे छपी है।
इस तरह के तीनों फ़ैसले tokens बन गए। <search> लिखना ढूँढने का फ़ैसला है, उसके अंदर की query दूसरा फ़ैसला, और <answer> लिखना रुकने का फ़ैसला। Search engine यहाँ है, और <information> उसका ।
नीचे lecture का trace है। ये Search-R1 से train हुए model का एक rollout है, थोड़ा छोटा करके।
पहले अंदाज़ा लगाइए: Model 3 बार search करता है, और जवाब सही है। क्या उसके <think> में लिखी हर तारीख किसी <information> से आई?
<think> I need to determine if Jed Hoyer or John William Henry II is older. I'll search for their ages. </think>
<search> Jed Hoyer or John William Henry II </search>
<information> Doc 1 (Title: "Jed Hoyer") … Wesleyan University … Red Sox at 28 … married Merrill Muckerman in June 2010 … </information>
<think> I found out that Jed Hoyer is a person. Now I need to find his age … </think>
<search> John William Henry II </search>
<information> Doc 1 (Title: "John W. Henry") … John William Henry II was born on September 13, 1949 in Quincy, Illinois … </information>
<think> I found out that John William Henry II was born on September 13, 1949. Now I need to find Jed Hoyer's birth year to compare. </think>
<search> Jed Hoyer birth year </search>
<information> Doc 1 (Title: "Jed Hoyer") … Wesleyan University … Red Sox at 28 … married Merrill Muckerman in June 2010 … </information>
<think> I found out that Jed Hoyer was born on December 7, 1973. Now I can compare his birth year to John William Henry II's birth year. </think>
<answer> John William Henry II </answer>
Stanford की slide: यही trace, पूरा। Ground Truth सही जवाब है। Image पर click करने से वो पूरे size में खुलती है।
सही जवाब, लेकिन एक तारीख बिना सबूत
जवाब सही है, इसलिए इस rollout का reward 1 है। अब तीसरी search देखिए। उसका नतीजा वही document है, जो पहली search में आया था, और उसमें Jed Hoyer की जन्म-तारीख नहीं है। फिर भी अगले <think> में model लिखता है: I found out that Jed Hoyer was born on December 7, 1973.
Retrieved text में ये तारीख नहीं है, तो model ने उसे अपनी से लिखा, यानी अपने parameters में बसी जानकारी से। तारीख शायद सही भी हो। दिक्कत ये है कि trace उसे I found out लिखकर search का नतीजा बताता है। Reward सिर्फ़ आख़िरी जवाब देखता है, इसलिए ऐसा बिना सबूत वाला कदम भी 1 पाता है, और training उसे भी मज़बूत करती है।
पहले सोचिए
<information> के अंदर का text search engine ने लिखा, model ने नहीं। o4 का reward 1 है। Training में उस text के tokens की probability भी बढ़नी चाहिए या नहीं?
जवाब देखिए
नहीं। वो text model का फ़ैसला नहीं है। उसकी probability बढ़ाने से model सीखेगा कि search के नतीजे खुद लिख दे, यानी उन्हें गढ़ दे। इसलिए paper इन tokens को training के हिसाब से बाहर रखता है। paper से
3GRPO: हर reward को उसी सवाल के group से मिलाना
GRPO हर rollout के reward की तुलना उसी सवाल के rollouts के औसत से करता है। Training इसी फ़र्क के हिसाब से probability बदलती है। ये तुलना क्यों चाहिए, ये सबसे सीधा तरीका आज़माकर दिखता है। सीधा तरीका ये है कि हर rollout को उसके reward जितना धक्का मिले। धक्के का मतलब है कि training उस rollout के tokens की probability कितनी बढ़ाती है। मेरा example
सवाल
4 rollouts के rewards
Reward जितना धक्का
आसान
1, 1, 1, 1
चारों को 1, कुल 4
मुश्किल
0, 0, 0, 1
सिर्फ़ o4 को 1, कुल 1
आसान सवाल पर model पहले से हर बार सही है, फिर भी उसे कुल 4 का धक्का मिला। मुश्किल सवाल पर अकेला सही rollout ही असली सबक है, और उसे सिर्फ़ 1 मिला। तीन गलत rollouts की probability घटी भी नहीं, क्योंकि 0 का धक्का कुछ नहीं बदलता।
इसलिए GRPO हर reward से उसी सवाल का औसत घटाता है। एक सवाल के सारे rollouts को group कहते हैं, और उनकी गिनती को G, यहाँ 4। मुश्किल सवाल पर औसत (0 + 0 + 0 + 1) ÷ 4 = 0.25 है। तो o4 का फ़र्क 1 − 0.25 = +0.75 है, और बाकी तीन का 0 − 0.25 = −0.25। आसान सवाल पर औसत 1 है, इसलिए चारों का फ़र्क 0 है, और कुछ नहीं बदलता।
फ़र्क का size हर सवाल पर अलग होता है, इसलिए GRPO उसे group के फैलाव से भाग देता है। फैलाव का नाप standard deviation है, और ये 4 steps में निकलता है:
हर reward का औसत से फ़र्क लीजिए: +0.75, −0.25, −0.25, −0.25। इनका जोड़ हमेशा 0 होता है, इसलिए इनका सीधा औसत फैलाव नहीं नाप सकता।
हर फ़र्क का square लीजिए, यानी उसे खुद से गुणा कीजिए: 0.5625, 0.0625, 0.0625, 0.0625। Square से minus हट जाता है, इसलिए ऊपर और नीचे वाले फ़र्क आपस में नहीं कटते।
Squares का औसत लीजिए: (0.5625 + 0.0625 + 0.0625 + 0.0625) ÷ 4 = 0.75 ÷ 4 = 0.1875।
अब हर फ़र्क को 0.433 से भाग दीजिए। o4 का advantage 0.75 ÷ 0.433 = +1.73 है, और बाकी तीन का −0.25 ÷ 0.433 = −0.58। Advantage बताता है कि rollout उम्मीद से कितना बेहतर या बुरा रहा। Positive advantage पर training उस rollout के tokens की probability बढ़ाती है, और negative पर घटाती है।
यही हिसाब symbols में ऐसे लिखते हैं:
Ai = (ri − mean(r1, …, rG)) ÷ std(r1, …, rG)
यहाँ ri rollout i का reward है, जैसे o4 के लिए 1। mean group का औसत है (0.25), std standard deviation (0.433), और Ai advantage (+1.73)। GRPO का पूरा नाम group relative policy optimization है। सारे rewards बराबर हों, तो std 0 है, और हर advantage 0 मान लेते हैं, क्योंकि उस सवाल से सीखने को कुछ नहीं।
Rewards
औसत
Std
Advantages
0, 0, 0, 1
0.25
0.433
−0.58, −0.58, −0.58, +1.73
1, 1, 1, 0
0.75
0.433
+0.58, +0.58, +0.58, −1.73
1, 1, 1, 1
1
0
0, 0, 0, 0
1, 0, 0, 1
?
?
?
आख़िरी row आप निकालिए
ये पड़ाव 1 वाला group है। औसत, standard deviation और चारों advantages निकालिए। फिर नीचे के widget में o1 पर click करके check कीजिए।
जवाब देखिए
औसत 0.5 है। फ़र्क +0.5, −0.5, −0.5, +0.5 हैं, और चारों के squares 0.25। उनका औसत 0.25 है, और square root 0.5।
Advantages: +0.5 ÷ 0.5 = +1, फिर −1, −1, +1। सही rollouts को जितना धक्का ऊपर मिलता है, गलत rollouts को उतना ही नीचे।
GRPO advantage खुद निकालिए
हर rollout पर click करके उसका reward 0 या 1 कीजिए। शुरू में मुश्किल सवाल वाला group है: 0, 0, 0, 1।
Rollout
Reward
Advantage
Training
4PPO का value model, और KL penalty
PPO भी advantage से train करता है, और उसकी उम्मीद एक अलग model देता है, जिसे value model कहते हैं। Value model अब तक का text पढ़कर अंदाज़ा लगाता है कि आख़िर में कितना reward मिलेगा। PPO GRPO से पहले का आम तरीका है, और Search-R1 का paper दोनों आज़माता है।
मान लीजिए Hoyer वाले मुश्किल सवाल पर value model 0.25 का अंदाज़ा देता है। o4 का reward 1 है, तो उसका advantage 1 − 0.25 = +0.75 है। GRPO ने यही 0.25 चार rollouts के औसत से निकाला था। मेरे numbers फ़र्क खर्च में है। Value model खुद एक LLM है, और उसे भी train करना पड़ता है। GRPO को ये model नहीं चाहिए, लेकिन उसे हर सवाल पर G rollouts चाहिए, और हर rollout में कई searches।
दोनों तरीकों में एक बचाव और है। Training model को reward की तरफ़ धकेलती है, और model अपनी पुरानी आदतों से बहुत दूर जा सकता है। इसलिए training शुरू होने से पहले वाले model की एक जमी हुई copy रखते हैं, जिसे reference LLM कहते हैं। Training हर token पर देखती है कि नया model reference से कितनी अलग probabilities देता है, और इस दूरी पर KL penalty लगाती है।
जैसे किसी जगह reference model <search> को 0.2 probability देता था, और नया model 0.9 देने लगा। ये 0.9 ÷ 0.2 = 4.5 गुना है, इसलिए penalty बड़ी है। Model इतना तभी बदलेगा, जब reward का फ़ायदा इस penalty से ज़्यादा हो। numbers मेरे
Stanford की slide: ऊपर PPO, बीच में GRPO, और नीचे वो instruction, जो model को हर सवाल के साथ मिलती है। GRPO में G rollouts o1 से oG के rewards r1 से rG हैं, और Group Computation उनसे advantages A1 से AG बनाता है। Reward Model कोई trained model नहीं, बस Exact Match वाला नियम है। paper से पीले box trained models हैं, और हरे जमे हुए models।
पहले सोचिए
GRPO वाले diagram में Value LLM का box नहीं है। क्यों?
जवाब देखिए
GRPO को उम्मीद के लिए अलग model नहीं चाहिए। वो उम्मीद उसी सवाल के G rollouts के औसत से लेता है, जैसे पड़ाव 3 में 0.25। ये काम Group Computation वाला box करता है।
5Search-R1, एक बार ढूँढने वाली RAG से कितना आगे है
Multi-hop सवालों पर Search-R1 एक बार ढूँढने वाली RAG से साफ़ आगे है। Paper ने ये Qwen2.5-7B नाम के LLM पर नापा, जिसमें करीब 7 billion parameters हैं। Score Exact Match है, यानी 0 से 1 के बीच का हिस्सा। जैसे 0.433 का मतलब है कि 1,000 में से 433 जवाब हूबहू सही निकले।
Direct inference में model बिना search जवाब देता है, और RAG सवाल पर एक बार search करता है। Search-R1-base सिर्फ़ वाले model से शुरू हुआ। Search-R1-instruct ऐसे model से शुरू हुआ, जो instructions मानने के लिए हो चुका था। ये numbers PPO से train हुए Search-R1 के हैं, क्योंकि paper का default PPO है। paper से
Method
HotpotQA
2wiki
Musique
Direct inferenceबिना search
0.183
0.250
0.031
RAGएक बार search
0.299
0.235
0.058
Search-R1-base
0.433
0.382
0.196
Search-R1-instruct
0.370
0.414
0.146
HotpotQA पर RAG 0.299 पर है, और Search-R1-base 0.433 पर, यानी 1,000 सवालों में 134 और सही जवाब। Musique पर 0.058 से 0.196, यानी तीन गुने से ज़्यादा। 2wiki पर एक बार ढूँढना नुकसान करता है: RAG 0.235 पर है, बिना search वाले 0.250 से भी नीचे। जहाँ एक search काफ़ी नहीं, फ़ायदा वहीं सबसे बड़ा है।
Training के दौरान model क्या सीखता है, ये slide के दो graphs दिखाते हैं। Training के साथ train reward बढ़ता है, और हर rollout में valid searches की गिनती भी। Valid search वो है, जिसके tags ठीक थे और जिस पर system ने सच में search चलाई। ये मतलब मेरी समझ है, paper के algorithm से यानी model ने ज़्यादा search करना सीखा, और ये नियम किसी ने उसे नहीं लिखा।
Stanford की slide: बाईं ओर नतीजों की पूरी table, और दाईं ओर training के दो graphs। Image पर click करने से वो पूरे size में खुलती है।
लेकिन सबसे अच्छे numbers पर भी multi-hop के आधे से ज़्यादा सवाल गलत हैं: HotpotQA पर 1,000 में से 567। और बिना सबूत वाला कदम भी reward पाता है, क्योंकि reward बीच के steps नहीं देखता। ऐसी गलतियाँ कहाँ-कहाँ आती हैं, ये lesson 18 गिनाता है।
गहरे version में और क्या है
गहरे version में ये पूरा lesson है, और उसके बाद 6 पड़ाव और, जो Stanford की slides के level तक ले जाते हैं:
पड़ाव 6: paper का लक्ष्य, यानी औसत reward − β × KL। Expected value, और KL divergence दो options वाले example पर।
पड़ाव 7: probability ratio और clipping, positive और negative advantage पर numbers से।
पड़ाव 8: retrieved tokens का mask, slide के trace पर गिनकर, और mask हटाने वाला experiment।
पड़ाव 9: PPO का value model और GAE, paper वाला 5 rollouts का GRPO group, और PPO बनाम GRPO के नतीजे।
पड़ाव 10: paper का पूरा setup, और slide की table की हर row।
पड़ाव 11: Stanford की तीनों Search-R1 slides, जिन्हें आप खुद पढ़ते हैं।
Search के steps पर labels नहीं चाहिए। Policy, यानी LLM, एक सवाल पर कई rollouts बनाती है, और सिर्फ़ आख़िरी जवाब का reward उसे सिखाता है।
GRPO हर reward से group का औसत घटाकर standard deviation से भाग देता है, और यही advantage है। PPO उम्मीद value model से लेता है।
Search-R1 multi-hop सवालों पर RAG से बहुत आगे है। लेकिन reward बीच के steps नहीं देखता, इसलिए बिना सबूत वाला step भी इनाम पा सकता है।
इस lesson के नए शब्द
Reinforcement learning (RL)
कोशिशें करके, हर कोशिश के reward से सीखना। जैसे 4 rollouts में 2 का reward 1 है, तो उन दोनों के tokens की probability बढ़ती है।
Policy
जो हर कदम पर फ़ैसला लेता है। यहाँ LLM, जो हर बार अगला token चुनता है: सोचना, <search> या <answer>।
Rollout (trajectory)
एक सवाल पर शुरू से आख़िरी जवाब तक की एक पूरी कोशिश। जैसे Hoyer वाले सवाल पर o1: दोनों तारीखें search कीं, फिर जवाब दिया।
Reward
Rollout के आख़िर में मिला number। जैसे जवाब हूबहू सही हो तो 1, नहीं तो 0।
Search-R1
LLM को RL से search के फ़ैसले सिखाने वाला तरीका, think, search, information और answer tags के साथ। Reward सिर्फ़ आख़िरी जवाब पर लगता है।
Advantage
Rollout उम्मीद से कितना बेहतर या बुरा रहा। जैसे rewards 0, 0, 0, 1 में o4 का +1.73, और बाकी तीन का −0.58।
PPO और value model
RL का आम तरीका, जो आगे के reward का अंदाज़ा लगाने वाला अलग model (value model) train करता है। जैसे अंदाज़ा 0.25 और reward 1 हो, तो advantage +0.75।
GRPO
Group के rewards के औसत और standard deviation से advantage। Value model नहीं चाहिए। जैसे 0, 0, 0, 1 पर औसत 0.25 और standard deviation 0.433।
Standard deviation
Numbers के फैलाव का नाप: औसत से फ़र्कों के squares का औसत, फिर square root। जैसे 0, 0, 0, 1 पर औसत 0.25, squares 0.5625, 0.0625, 0.0625, 0.0625, उनका औसत 0.1875, और square root 0.433।
Reference LLM और KL penalty
Training से पहले वाले model की जमी हुई copy, और नए model को उससे दूर जाने से रोकने वाली penalty। जैसे <search> की probability 0.2 से 0.9 हो जाए, तो penalty बड़ी है।