Agentic RAG में ढूँढना pipeline का तय step नहीं रहता। एक LLM हर कदम पर तय करता है कि ढूँढना है या नहीं, क्या ढूँढना है, और जो मिला वो काफ़ी अच्छा है या नहीं। ऐसे LLM को agent कहते हैं, और ये lesson ये फ़ैसले लेने के दो तरीके दिखाता है: Self-RAG और CRAG।
इसकी ज़रूरत lesson 11 में दिखी थी। सवाल which office hour is least crowded पर BM25 ने पुराने forum post को 2.749 दिया, और queue log को 2.473। K = 1 पर prompt में सिर्फ़ forum post जाता है, और LLM लिखता है midweek afternoons [P4], जहाँ [P4] उसी post का ID है। ये lesson 1 वाला गलत जवाब है, बस अब citation के साथ। उल्टी गलती भी होती है: 17 × 3 कितना है? पर भी pipeline 60,000 passages में ढूँढती है।
इस lesson की सीढ़ी
सीढ़ी में 9 पड़ाव हैं। पहले 5 आसान version जैसे ही हैं, और 6 से 9 आपको Stanford की slides के level तक ले जाते हैं। हर पड़ाव के नीचे लिखा है कि उसके बाद आप क्या कर पाएँगे।
पहले से क्या चाहिए: Lesson 1 (next-token prediction, vocabulary), Lesson 6 (pipeline, query rewriting, ITER-RETGEN) और Lesson 14 (reranker)। पड़ाव 6 से आगे Lesson 4 (probability, softmax, ln, loss) और Lesson 13 (points) भी काम आते हैं। जो पड़ाव आपको पहले से आता है, उसे छोड़कर अगले पर जाइए। जिस शब्द के नीचे बिंदुओं वाली line और ▾ हो, उस पर click करने से उसका मतलब खुलता है।
1Agent: action, observation और loop
Agent एक LLM है, जो loop में काम करता है। वो अगला काम चुनता है, वो काम होता है, और फिर वो नतीजा पढ़कर अगला काम चुनता है। Agent का चुना काम action कहलाता है, जैसे search करना या जवाब लिखना। Action को असल में एक program करता है, जैसे search engine, और उसे tool कहते हैं। Tool जो नतीजा लौटाता है, और agent जिसे अगले कदम से पहले पढ़ता है, उसे observation कहते हैं।
Loop की ज़रूरत lesson 6 में दिखी थी। वहाँ दो बार ढूँढता था, और ये गिनती इंसान ने पहले से लिख दी थी। लेकिन Jed Hoyer वाले सवाल पर model ने तीन searches कीं, और 17 × 3 को एक भी नहीं चाहिए। कोई तय गिनती दोनों पर सही नहीं बैठती, इसलिए गिनती वही तय करे, जो हर search का नतीजा पढ़ रहा है।
अब एक छोटा loop देखिए। User छोटे रूप में पूछता है OH timings? Retriever lesson 6 वाला word overlap है, जो गिनता है कि query के कितने शब्द passage में भी हैं। ये loop मेरा example है
कदम
Agent का action
Observation
1
Search: OH timings
हर passage का score 0
2
Search: CS 329Z office hours schedule
Office hours page पर 2, queue log पर 1
3
जवाब: Tuesday 4pm, Room 104, or Thursday 9am, Zoom [P2]
Loop ख़त्म
पहली query के शब्द oh और timings किसी passage में नहीं हैं। दूसरी query के office और hours, दोनों office hours page में हैं, इसलिए उसका score 2 है। Queue log में office है, लेकिन hours की जगह hour लिखा है, इसलिए उसका score 1 है। जवाब का [P2] office hours page का ID है।
दूसरा कदम पहले कदम के observation से निकला: कुछ नहीं मिला, इसलिए agent ने query दोबारा लिखी। ये lesson 6 वाली है। Lesson 6 की Advanced RAG pipeline हर query को rewrite करती है, और इसमें हर query पर एक extra LLM call लगती है। Agent के हर कदम पर भी एक LLM call लगती है, लेकिन rewrite वाला कदम यहाँ तभी आया, जब search खाली लौटी।
पहले सोचिए
मान लीजिए user ने पहली बार में ही office hour timings लिखा। Observation में किसका score कितना होगा, और क्या agent को query दोबारा लिखनी पड़ेगी?
जवाब देखिए
Queue log में office और hour, दोनों हैं, इसलिए उसका score 2 है। Office hours page में सिर्फ़ office है, इसलिए 1। Search खाली नहीं लौटी, तो query बदलने की वजह नहीं। लेकिन queue log में समय है, जगह नहीं, इसलिए agent को अब ये तय करना है कि जो मिला वो काफ़ी है या नहीं। ये अगले पड़ाव का तीसरा फ़ैसला है।
2तीन फ़ैसले, और pipeline कहाँ चूकती है
ढूँढने वाले agent के सामने हर कदम पर तीन फ़ैसले आते हैं। पहला, ढूँढें या सीधे जवाब दें। दूसरा, कौन सी query भेजें। तीसरा, जो मिला वो काफ़ी अच्छा है या नहीं। पड़ाव 1 के loop में तीनों दिखे: agent ने ढूँढना चुना, फिर नई query लिखी, और फिर नतीजे को काफ़ी मानकर जवाब लिखा।
Pipeline ये फ़ैसले नहीं लेती, वो हर सवाल पर वही steps चलाती है। नीचे हर फ़ैसले के लिए एक सवाल है, जिस पर pipeline चूकती है:
फ़ैसला
सवाल
Pipeline क्या करती है
Agent क्या कर सकता है
1. ढूँढें?
17 × 3 कितना है?
60,000 passages में ढूँढती हैऔर करीब 2,500 tokens prompt में डालती है
0 searches, सीधा जवाब: 51
2. कौन सी query?
OH timings?
वही query भेजती है, 0 passages पाती है
Search खाली आई, तो query बदलता है
3. काफ़ी अच्छा?
Least crowded, K = 1
अकेला forum post भेजती है
Post 2024 की राय है, तो दोबारा ढूँढता है
RAG में ढूँढना जब agent का action बन जाए, और ये तीनों फ़ैसले हर कदम पर हों, तो उसे agentic RAG कहते हैं। Stanford की slide यही कहती है:
Stanford की slide: loop के अंदर retrieval। ऊपर लिखा है कि अब तक की कोई चीज़ तय नहीं करती कि ढूँढना है या नहीं, क्या पूछना है, और कब रुकना है। नीचे वही तीन फ़ैसले हैं। Image पर click करने से वो पूरे size में खुलती है।
ऊपर का when to stop और नीचे का तीसरा फ़ैसला एक ही बात है। नतीजा काफ़ी अच्छा है, तो agent रुककर जवाब लिखता है, और नहीं है, तो फिर से ढूँढता है।
अब सवाल ये है कि ये फ़ैसले कौन ले। ये lesson दो जवाब देता है। Self-RAG में जवाब लिखने वाला model खुद फ़ैसले लेता है, और CRAG में एक अलग, छोटा model नतीजा परखता है।
3Self-RAG: फ़ैसले tokens में
सबसे सीधा तरीका ये है कि वही LLM फ़ैसले ले, जो जवाब लिख रहा है, क्योंकि वो सवाल और passages, दोनों पढ़ रहा है। दिक्कत ये है कि LLM सिर्फ़ लिखता है, और अलग से कोई फ़ैसला नहीं सुनाता।
Self-RAG इसका हल ये निकालता है कि फ़ैसले भी tokens बन जाएँ। वो model की में कुछ खास tokens जोड़ता है, जिन्हें reflection tokens कहते हैं। Model की खास training होती है, और फिर वो इन्हें बाकी text की तरह लिखता है। Self-RAG Asai और साथियों का 2024 का तरीका है, और इसके मुख्य tokens ये हैं:
Token
मतलब
फ़ैसला
Retrieve
अभी ढूँढना है
फ़ैसला 1
Relevant / Irrelevant
मिला हुआ passage सवाल के काम का है या नहीं
फ़ैसला 3
Supported / Partially
Model का लिखा हिस्सा passage से पूरा साबित होता है, या आधा
फ़ैसला 3 की दूसरी जाँच
Paper में कुछ और tokens भी हैं, जैसे No support। एक चौथी किस्म पूरे जवाब को 1 से 5 तक का score देती है, और वो गहरे version में है।
अब हमारा सवाल लीजिए: Which office hour this week is least crowded? मान लीजिए model ने Retrieve लिखा, और retriever queue log, पुराना forum post और Homework 1 की announcement लाया। Model हर passage के साथ अलग से अगला हिस्सा लिखता है, और हर हिस्से के साथ reflection tokens भी। ये example और tokens मेरे हैं
Passage
Reflection tokens
Model का लिखा हिस्सा
Queue log
Relevant, Supported
Thursday 9am, about 3 waiting.
पुराना forum post
Relevant, Partially
Wednesday afternoon is quietest.
Homework 1 की announcement
?
Homework 1 will be released on Oct 5.
Forum post वाला हिस्सा Partially है, क्योंकि post में midweek लिखा है, Wednesday नहीं, और साथ में usually भी। यानी Wednesday वाली बात passage में आधी ही है। Queue log वाली बात queue log में पूरी लिखी है, इसलिए वो हिस्सा Supported है।
तीसरी row आप निकालिए
Homework वाले हिस्से पर कौन सा token लगेगा? तीनों हिस्सों का क्रम क्या होगा, और जवाब में कौन सा हिस्सा जुड़ेगा?
जवाब देखिए
Irrelevant। Homework की तारीख सच है, और announcement से साबित भी होती है, लेकिन सवाल office hours की भीड़ का है। क्रम है: queue log, फिर forum post, फिर Homework। Queue log वाला हिस्सा Relevant और Supported है, इसलिए जवाब में वही जुड़ता है: Thursday 9am।
तो Self-RAG हर हिस्से को दो बातों पर परखता है: बात सवाल के काम की है या नहीं, और passage से साबित है या नहीं। Stanford की slide पर paper का अपना example है, और अब आप उसे पढ़ सकते हैं:
Stanford की slide: Self-RAG के तीन steps। हरे box अच्छे tokens हैं, नारंगी box Partially है, और लाल box Irrelevant।
Step 1 में model पहला sentence लिखता है, फिर Retrieve, और तीन passages आते हैं। Step 2 में वो हर passage के साथ एक हिस्सा लिखता है, और step 3 में tokens से क्रम बनता है: 1 > 3 > 2। Texas वाली बात सच है, लेकिन उसका passage Irrelevant है, इसलिए वो सबसे नीचे है। फिर model दोबारा Retrieve लिखता है, और यही दोहराता है।
Self-RAG की कीमत भी है। Generator की खास training चाहिए, इसलिए API से लिया यहाँ नहीं चलता। हर passage के साथ अलग हिस्सा लिखना पड़ता है, यानी lesson 5 के की तरह K बार generation। और Supported सिर्फ़ इतना कहता है कि बात passage में है। वो ये नहीं कहता कि passage अब भी सच है।
4CRAG: अलग evaluator और दो thresholds
ज़्यादातर systems frozen LLM पर बनते हैं, इसलिए फ़ैसला 3 generator के बाहर कोई और ले। पहला idea lesson 14 का है। लेकिन reranker सिर्फ़ क्रम बदलता है। मान लीजिए retriever सिर्फ़ Homework 1 की announcement और project page लाया, जो भीड़ वाले सवाल के लिए बेकार हैं। Reranker तब भी एक को ऊपर रखेगा, और वो prompt में जाएगा। मेरा example
CRAG में एक हल्का model हर document को एक confidence देता है: ये document इस सवाल के लिए कितना सही है। इस model को retrieval evaluator कहते हैं। CRAG का पूरा नाम Corrective RAG है, और ये Yan और साथियों का 2024 का तरीका है। Confidence का अपना मतलब है, इसलिए उस पर एक पहले से तय limit रख सकते हैं, जिसे threshold कहते हैं।
CRAG दो thresholds रखता है, ऊपर वाला और नीचे वाला। यहाँ confidence 0 से 1 के बीच है, और thresholds 0.6 और 0.2 हैं। ये scale और numbers मेरे रखे हैं Paper के अपने numbers गहरे version में हैं। पहले वो case लीजिए, जिसमें retriever एक ही document लाया, यानी K = 1:
अकेला document
Confidence
फ़ैसला
Queue log
0.85
Correct0.6 से ऊपर
पुराना forum post
0.4
Ambiguous0.2 और 0.6 के बीच
Homework 1 की announcement
0.05
Incorrect0.2 से नीचे
कई documents हों, तो एक भी document 0.6 से ऊपर होने पर फ़ैसला Correct है, और Incorrect के लिए सारे 0.2 से नीचे होने चाहिए। Reranker वाले example में Homework 0.05 पर है और project page 0.1 पर, इसलिए फ़ैसला Incorrect है। project page का 0.1 मेरा हर फ़ैसले पर CRAG अलग action चलाता है:
फ़ैसला
Action
Generator को क्या मिलता है
Correct
Knowledge refinement: documents को strips में तोड़िए, बेकार strips हटाइए, बाकी जोड़िए
सवाल + साफ़ किए documents
Incorrect
Documents छोड़िए, query दोबारा लिखिए, web search कीजिए
सवाल + web का नतीजा
Ambiguous
दोनों
सवाल + साफ़ किए documents + web का नतीजा
CRAG का फ़ैसला, K = 1 पर
Retriever एक document लाया है। Evaluator का confidence बदलिए, और देखिए कि CRAG क्या करता है। Thresholds 0.6 और 0.2 हैं। thresholds और तीनों confidence मेरे रखे हैं
Correct वाले रास्ते पर भी document पूरा नहीं जाता। CRAG उसे छोटे टुकड़ों में तोड़ता है, जिन्हें strips कहते हैं। फिर वो हर strip को evaluator से परखता है, और बेकार strips हटाकर बाकी को क्रम से जोड़ता है। इसे knowledge refinement कहते हैं। सवाल When is the milestone due? पर syllabus के तीन sentences तीन strips बनते हैं: मेरा example
Syllabus की strip
रखें?
The project milestone is due Week 6, Thursday 11:59pm.
हाँ, यही जवाब है
Late days may not be applied to the milestone.
हाँ, milestone की deadline से जुड़ी है
The final report is due Week 10.
नहीं, ये final report की बात है
Generator को 3 में से 2 strips मिलती हैं। Week 10 वाली line prompt में नहीं जाती, इसलिए generator उसे milestone की तारीख नहीं समझ सकता।
Incorrect वाले रास्ते पर CRAG अपने documents छोड़ देता है। एक LLM सवाल को search engine के लायक keywords में दोबारा लिखता है, और CRAG web पर ढूँढता है। Slide पर सवाल Who was the screenwriter for Death of a Batman? है, और नई query के तीन टुकड़े हैं: Death of a Batman, screenwriter और Wikipedia।
Stanford की slide: CRAG। Correct पर Knowledge Refinement चलता है, Incorrect पर Knowledge Searching, और Ambiguous पर दोनों। सबसे नीचे की line दिखाती है कि हर फ़ैसले पर generator को क्या मिलता है।
ध्यान दीजिए: Web से आया हर text भरोसे लायक नहीं होता। उसमें गलत बातें हो सकती हैं, या agent को भटकाने वाली instructions भी, जो lesson 18 में आती हैं। इसीलिए slide पर web search के बाद भी एक Select step है।
पहले सोचिए
K = 1 पर अकेला forum post आया, और evaluator ने उसे 0.4 दिया। CRAG क्या करेगा, और generator को क्या मिलेगा?
जवाब देखिए
0.4, 0.2 और 0.6 के बीच है, इसलिए फ़ैसला Ambiguous है। CRAG forum post को refine करके रखेगा, और query दोबारा लिखकर web search भी करेगा। Generator को सवाल, forum post का साफ़ हिस्सा और web का नतीजा, तीनों मिलेंगे।
5Self-RAG और CRAG साथ-साथ, और उनकी हद
अब शुरू के दोनों सवालों पर लौटिए। 17 × 3 पर ठीक से train हुआ Self-RAG Retrieve नहीं लिखता, और सीधे 51 लिखता है। Paper के example में भी essay वाले prompt पर model नहीं ढूँढता। paper से CRAG यहाँ भी ढूँढेगा, क्योंकि वो हर सवाल पर ढूँढता है, और सिर्फ़ नतीजा परखता है।
K = 1 पर अकेला forum post आए, तो Self-RAG का Wednesday वाला हिस्सा Partially है, और model दोबारा Retrieve लिख सकता है। CRAG का evaluator forum post को 0.4 देता है, इसलिए वो web पर भी ढूँढता है। दोनों में से कोई अब forum post को बिना परखे आगे नहीं भेजता।
Self-RAG
CRAG
फ़ैसला कौन लेता है
Generator खुद, reflection tokens से
अलग evaluator, दो thresholds से
Generator बदलना पड़ता है?
हाँ, खास training
नहीं, कोई भी LLM
फ़ैसला 1: ढूँढें?
Retrieve token से
हमेशा ढूँढता है
फ़ैसला 2: कौन सी query?
अलग से query नहीं लिखताpaper से
Web के लिए query दोबारा लिखता है
फ़ैसला 3: काफ़ी अच्छा?
Relevant और Supported tokens से
Evaluator के confidence से
दोनों की हद भी है। CRAG के thresholds इंसान रखता है, और evaluator भी गलती कर सकता है। Self-RAG के reflection tokens भी model ही लिखता है, इसलिए वो भी गलत हो सकते हैं। और दोनों में से किसी ने ये फ़ैसले खुद कोशिश करके नहीं सीखे।
Lesson 17 में model ये फ़ैसले कोशिश करके और नतीजा देखकर सीखता है: कब ढूँढना है, कौन सी query लिखनी है, और कब रुकना है। Loop में एक गलत फ़ैसला अगले कदमों पर असर डालता है, और ये बात lesson 18 में आती है।
यहाँ से Stanford वाला level
ऊपर के 5 पड़ाव आसान version जैसे ही हैं। आगे के 4 पड़ाव आपको Stanford की slides के level तक ले जाते हैं। पहले Self-RAG के tokens का गणित आता है, फिर उसकी training और नतीजे, और फिर CRAG का असली evaluator और उसके नतीजे। आख़िर में आप slides खुद पढ़ते हैं। हर गणित वहीं समझाया है, जहाँ वो पहली बार आता है।
6Self-RAG का गणित: token की probability से हिस्से का score
पड़ाव 3 में तीन तरह के tokens थे, और हिस्सों का क्रम मैंने tokens देखकर बताया था। Paper में चार तरह के tokens हैं, और क्रम एक number से निकलता है। हर किस्म के अपने कुछ values हैं: paper से
किस्म
Values
क्या परखती है
Retrieve
yes, no, continue
अभी ढूँढना है, नहीं ढूँढना, या पिछला passage ही आगे इस्तेमाल करना है
IsRel
relevant, irrelevant
Passage सवाल के काम का है या नहीं
IsSup
fully supported, partially supported, no support
लिखा हिस्सा passage से कितना साबित होता है
IsUse
5, 4, 3, 2, 1
जवाब सवाल के लिए कितना काम का है
आख़िरी तीन किस्मों को paper critique tokens कहता है, क्योंकि वो लिखे हुए को परखती हैं। हर किस्म में एक value सबसे अच्छी है, जो table में bold है। पड़ाव 3 का Supported यहाँ fully supported है, और Partially यहाँ partially supported।
Token की probability से हिस्सा
Model हर कदम पर पूरी vocabulary के हर token को एक देता है, और ये सब मिलकर 1 होती हैं। Self-RAG एक किस्म के tokens को अलग निकालता है, और उनकी probabilities को आपस में बाँटता है। मान लीजिए queue log वाले हिस्से के बाद relevant की probability 0.54 है, irrelevant की 0.06, और बाकी सारे tokens की मिलाकर 0.40। मेरे numbers
IsRel के दोनों tokens जोड़िए: 0.54 + 0.06 = 0.60।
Relevant को इस जोड़ से भाग दीजिए: 0.54 ÷ 0.60 = 0.9।
ये 0.9 relevant का हिस्सा है, सिर्फ़ IsRel वाले tokens के बीच। बाकी 0.40 इस हिसाब में नहीं आता, इसलिए हिस्सा हमेशा 0 और 1 के बीच रहता है। Paper इसे ऐसे लिखता है:
यहाँ p(relevant) relevant token की probability है, यानी 0.54, और नीचे दोनों का जोड़ 0.60 है। Lesson 4 के में भी हिस्सा ऐसे ही निकला था: एक number को group के जोड़ से भाग दीजिए।
ढूँढने का फ़ैसला: threshold δ
फ़ैसला 1 के लिए भी यही हिस्सा काम आता है। Self-RAG तब ढूँढता है, जब yes और no के बीच yes का हिस्सा एक threshold से ऊपर हो। इस threshold को paper δ लिखता है, जिसे delta पढ़ते हैं:
ढूँढिए, अगर p(yes) ÷ ( p(yes) + p(no) ) > δ
दो सवालों पर देखिए, जहाँ p(yes) और p(no) Retrieve वाले tokens की probabilities हैं: मेरे numbers
सवाल
p(yes), p(no)
yes का हिस्सा
17 × 3 कितना है?
0.03, 0.87
0.03 ÷ 0.90 = 0.033
Least crowded वाला सवाल
0.56, 0.24
0.56 ÷ 0.80 = 0.70
अब δ बदलकर देखिए कि कौन सा सवाल ढूँढता है:
δ
17 × 3 (0.033)
Least crowded (0.70)
0
ढूँढता है
ढूँढता है
0.2
नहीं ढूँढता
ढूँढता है
0.5
नहीं ढूँढता
ढूँढता है
0.8
नहीं ढूँढता
नहीं ढूँढता
यानी δ जितना बड़ा, model उतना कम ढूँढता है। Paper ज़्यादातर tasks पर δ = 0.2 रखता है, ताकि model अक्सर ढूँढे। ALCE नाम के task पर, जहाँ हर दावे के साथ citation चाहिए, paper δ = 0 रखता है। paper से
हर हिस्से का score: वज़न वाला जोड़
अब तीनों critique किस्मों के हिस्से एक number में जुड़ते हैं। पहले हर किस्म का हिस्सा, paper के नियम से: paper से
IsRel: relevant का हिस्सा, जैसे ऊपर निकाला।
IsSup: fully का हिस्सा, और उसमें partially के हिस्से का आधा। यानी partially supported को आधा वज़न मिलता है।
IsUse: पाँचों values को वज़न मिलते हैं। 5 को 1, 4 को 0.5, 3 को 0, 2 को −0.5, और 1 को −1। फिर हर value का हिस्सा उसके वज़न से गुणा होता है, और सब जुड़ते हैं।
IsUse वाला जोड़ एक तरह का औसत है। मान लीजिए 5 का हिस्सा 0.6 है, 4 का 0.3 और 3 का 0.1। तब sIsUse = 1 × 0.6 + 0.5 × 0.3 + 0 × 0.1 = 0.75। सारा हिस्सा 5 पर होता, तो ये 1 होता, और सारा 1 पर होता, तो −1। इसलिए sIsUse −1 और 1 के बीच रहता है।
हमारे तीनों हिस्सों पर model ने ये हिस्से दिए। हर group के हिस्से मिलकर 1 हैं: मेरे numbers
हिस्सा किस passage से
relevant
fully, partially, no
5, 4, 3, 2, 1
Queue log
0.9
0.8, 0.15, 0.05
0.6, 0.3, 0.1, 0, 0
पुराना forum post
0.7
0.2, 0.7, 0.1
0.2, 0.5, 0.3, 0, 0
Homework 1 की announcement
0.05
0.6, 0.3, 0.1
0, 0, 0.1, 0.3, 0.6
Queue log वाले हिस्से का score चार steps में निकलता है:
Step 4 में तीनों हिस्से वज़न के साथ जुड़े। Paper के default वज़न IsRel और IsSup के लिए 1.0 हैं, और IsUse के लिए 0.5। paper से Formula यही चार steps है:
S = wIsRel sIsRel + wIsSup sIsSup + wIsUse sIsUse
यहाँ हर w एक वज़न है (1.0, 1.0 और 0.5), और हर s उस किस्म का हिस्सा (0.9, 0.875 और 0.75)। यही हिसाब तीनों हिस्सों पर:
हिस्सा
sIsRel, sIsSup, sIsUse
S
Queue log
0.9, 0.875, 0.75
2.15
पुराना forum post
0.7, 0.55, 0.45
1.475
Homework 1 की announcement
0.05, 0.75, −0.75
0.425
क्रम वही निकला, जो पड़ाव 3 में था: queue log, फिर forum post, फिर Homework। Homework का sIsSup 0.75 है, यानी उसकी बात announcement से अच्छी तरह साबित है। लेकिन sIsRel 0.05 और sIsUse −0.75 उसे सबसे नीचे ले जाते हैं।
पहले सोचिए
मान लीजिए सिर्फ़ IsSup गिना जाए, यानी wIsRel = 0 और wIsUse = 0, और wIsSup = 1। तीनों हिस्सों का क्रम क्या होगा?
जवाब देखिए
तब S सिर्फ़ sIsSup है: queue log 0.875, Homework 0.75 और forum post 0.55। Homework forum post से ऊपर आ जाता है, क्योंकि उसकी बात अपने passage से साबित है, भले सवाल से उसका कोई लेना-देना नहीं। इसीलिए IsRel ज़रूरी है: Supported सिर्फ़ ये बताता है कि बात passage में है।
Paper का पूरा score इस S में हिस्से की अपनी probability भी जोड़ता है:
f(yt, d) = p(yt | x, d, y<t) + S
यहाँ x सवाल है, d passage, yt t-वाँ हिस्सा, और y<t उससे पहले लिखे सारे हिस्से। Paper हर हिस्से को एक sentence मानता है। p(yt | x, d, y<t) इस sentence की probability है, जब सवाल, passage और पिछले हिस्से दिए हों। paper से
वज़न बदलने से model का बर्ताव बदलता है, और इसके लिए दोबारा training नहीं चाहिए। मान लीजिए wIsSup = 2 है। तब scores 3.025, 2.025 और 1.175 होते हैं, यानी क्रम वही रहता है, लेकिन साबित होने का असर बढ़ता है। Paper में ASQA task पर IsSup का वज़न बढ़ाने से citation precision बढ़ा, यानी ज़्यादा citations अपने दावे को सच में साबित करते थे। साथ में MAUVE नाम का fluency score घटा। paper से, graph का रुझान
Beam search: दो अधूरे जवाब साथ
Paper हर कदम पर सिर्फ़ एक सबसे अच्छा हिस्सा चुनकर आगे नहीं बढ़ता। वो सबसे ऊँचे score वाले B अधूरे जवाब रखता है, और हर एक को अगले कदम तक बढ़ाता है। इसे beam search कहते हैं, और B को beam की चौड़ाई। Paper में B = 2 है। paper से
हमारे तीन हिस्सों पर B = 2 लगाइए। Queue log (2.15) और forum post (1.475) वाले दोनों अधूरे जवाब अगले कदम तक जाते हैं, और Homework (0.425) वाला वहीं छूट जाता है। आख़िर में पूरे जवाबों में से सबसे अच्छा लौटता है। B = 1 होता, तो ये lesson 1 के जैसा होता, बस token की जगह पूरा sentence।
7Self-RAG की training, और paper के नतीजे
Model reflection tokens तभी लिख सकता है, जब training data में ये tokens सही जगह लगे हों। हर sentence पर हाथ से tokens लगाना महँगा है, इसलिए paper ये काम एक दूसरे model से करवाता है। जो model किसी और के लिखे को grade देता है, उसे critic कहते हैं। Self-RAG की training तीन कदमों में होती है: paper से
GPT-4 को हर किस्म के लिए एक instruction और कुछ examples दिए, और उससे tokens लिखवाए। हर किस्म के लिए 4 हज़ार से 20 हज़ार examples बने, जैसे IsRel के 19,317, IsSup के 11,181 और IsUse के 3,831।
इन examples पर Llama 2 7B से critic train हुआ, ताकि आगे GPT-4 की जगह critic tokens लिखे।
Critic ने 145,619 training examples में reflection tokens और retrieved passages जोड़े। फिर generator, Llama 2 7B या 13B, इन्हीं examples पर train हुआ।
Critic सिर्फ़ training data बनाने के लिए है। Generator train होने के बाद tokens खुद लिखता है, इसलिए जवाब देते वक्त critic की ज़रूरत नहीं होती।
Generator की training lesson 4 वाला ही है: हर अगले token की probability का −ln, जिसमें reflection tokens भी शामिल हैं। जैसे किसी सही token की probability 0.5 से 0.9 हो जाए, तो उसका −ln 0.693 से 0.105 पर आता है। Passage वाले text पर loss नहीं लगता, क्योंकि उसे model ने नहीं लिखा, retriever ने दिया। Paper यही बात ऐसे लिखता है:
maxM 𝔼 [ log pM(y, r | x) ]
यहाँ M generator है, x सवाल, y जवाब, और r उसके reflection tokens। 𝔼 का मतलब है सारे training examples पर औसत। log को सबसे बड़ा करना और −log, यानी loss, को सबसे छोटा करना एक ही बात है।
Critic कितना भरोसे लायक है, ये paper ने GPT-4 के tokens से मिलाकर नापा: paper से
किस्म
Critic और GPT-4 का मेल (%)
Retrieve
93.8
IsSup
93.5
IsRel
80.2
IsUse
73.5
IsUse सबसे कमज़ोर है, क्योंकि critic अक्सर 5 और 4 में उलझता है, और इन दोनों पर इंसान भी असहमत होते हैं। इंसानी annotators ने PopQA के 50 जवाब भी जाँचे। Model के IsRel tokens 95.0% बार उनकी राय से मिले, और IsSup tokens 90.0% बार।
जवाब देते वक्त paper ने Contriever नाम के dense retriever से top 5 passages लिए। वज़न 1.0, 1.0 और 0.5 थे, δ = 0.2, और beam की चौड़ाई 2। paper से
नतीजे, points में पढ़े हुए
Lesson 13 में आए थे: दो % numbers का सीधा फ़र्क। जैसे 50.8% से 54.9% तक 4.1 points हैं। Paper के चार tasks ये हैं। PopQA में rare लोगों और चीज़ों पर 1,399 सवाल हैं, और PubHealth में health के दावों को सच या झूठ कहना है। ARC-Challenge में science के multiple-choice सवाल हैं, और Bio में biography लिखनी है। paper से
Task
Self-RAG 7B
ChatGPT + retrieval
ChatGPT
PopQAaccuracy
54.9
50.8
29.3
PubHealthaccuracy
72.4
54.7
70.1
ARC-Challengeaccuracy
67.3
75.3
75.3
BioFactScore, यानी सच्चे छोटे दावों का %
81.2
–
71.8
PopQA पर Self-RAG 7B, retrieval वाले ChatGPT से 54.9 − 50.8 = 4.1 points आगे है।
ARC पर ChatGPT, Self-RAG 7B से 75.3 − 67.3 = 8.0 points आगे है। Paper का 13B model भी 73.1 पर रहता है, यानी Self-RAG हर task पर नहीं जीतता।
Paper ने एक-एक हिस्सा हटाकर भी नापा, यानी किया। ये 50 हज़ार examples पर train हुए 7B model पर है, इसलिए पहली row ऊपर की table से नीची है: paper से
क्या बदला
PopQA
PubHealth
पूरा Self-RAG
45.5
73.5
जवाब देते वक्त कभी नहीं ढूँढता
24.7
73.0
हमेशा सिर्फ़ top 1 passage लेता है
41.8
73.1
δ की जगह तभी ढूँढता है, जब model खुद Retrieve = yes लिखे
28.3
72.6
Training data में critic के tokens नहीं
42.6
72.0
PopQA पर न ढूँढने से accuracy 45.5 से 24.7 पर आती है, यानी 20.8 points की गिरावट। PubHealth पर यही गिरावट सिर्फ़ 0.5 points है। यानी ढूँढना हर task पर बराबर काम का नहीं, और यही फ़ैसला 1 की वजह है। PopQA पर δ = 0.2 वाला नियम, सिर्फ़ Retrieve = yes पर ढूँढने से, 45.5 − 28.3 = 17.2 points बेहतर है, क्योंकि वो ज़्यादा बार ढूँढता है।
8CRAG का असली evaluator, thresholds और नतीजे
CRAG paper की पहली figure में दिक्कत साफ़ दिखती है। सवाल है Who was the screenwriter for Death of a Batman?, और retriever Batman (1989 film) वाला document लाता है। उसमें Hamm नाम आता है, और generator जवाब देता है Hamm, जो गलत है। paper से
CRAG का evaluator T5-large नाम का model है, जिसमें 0.77 billion, यानी 77 करोड़ parameters हैं। Self-RAG का critic Llama 2 7B है, यानी करीब 9 गुना बड़ा। Evaluator सवाल और एक document को साथ पढ़कर −1 से 1 के बीच एक score देता है। Training में सही document का label 1 था, और गलत का −1। paper से
PopQA में करीब 14 हज़ार सवाल हैं, और paper ने test वाले 1,399 छोड़कर बाकी सवालों पर evaluator को train किया। फिर वही evaluator बाकी तीन tasks पर भी चला। हर सवाल पर आम तौर पर 10 documents आते हैं, और evaluator हर एक को अलग score देता है। paper से
−1 से 1 वाला scale
आसान version में मैंने confidence 0 से 1 पर रखा था। Paper का scale −1 से 1 है, और दोनों एक सीधे नियम से जुड़ते हैं: c = (s + 1) ÷ 2। यहाँ s paper का score है, और c 0 से 1 वाला confidence। जैसे s = −1 से c = 0, s = 0 से c = 0.5, और s = 1 से c = 1। ये नियम हर score में 1 जोड़कर 2 से भाग देता है, इसलिए दोनों scales पर क्रम वही रहता है।
Paper ने thresholds हर dataset पर आज़माकर रखे, यानी ये हैं: paper से, आख़िरी column मेरा हिसाब
Dataset
ऊपर वाला
नीचे वाला
0 से 1 पर
PopQA
0.59
−0.99
0.795, 0.005
PubHealth, ARC
0.5
−0.91
0.75, 0.045
Biography
0.95
−0.91
0.975, 0.045
आख़िरी column नियम c = (s + 1) ÷ 2 से निकला। जैसे PubHealth का नीचे वाला threshold: (−0.91 + 1) ÷ 2 = 0.09 ÷ 2 = 0.045। नीचे वाले thresholds लगभग −1 पर हैं, यानी Incorrect तभी आता है, जब हर document लगभग पूरी तरह बेकार हो।
पहले सोचिए
आसान version में अकेली Homework की announcement 0.05 पर Incorrect थी। PubHealth वाले thresholds पर, 0 से 1 वाले scale में, उसका फ़ैसला क्या होगा?
जवाब देखिए
PubHealth के thresholds 0 से 1 पर 0.75 और 0.045 हैं। 0.05 न 0.75 से ऊपर है, न 0.045 से नीचे, इसलिए फ़ैसला Ambiguous है। Paper के thresholds पर CRAG documents को आसानी से नहीं छोड़ता, वो उन्हें रखकर web search भी करता है।
Documents के set पर फ़ैसला
Paper का नियम पूरे set पर लगता है: paper से
Correct: कम से कम एक document का score ऊपर वाले threshold से ज़्यादा है।
Incorrect: हर document का score नीचे वाले threshold से कम है।
Ambiguous: बाकी हर हालत।
अब paper के scale पर मेरे scores लीजिए: queue log 0.70, forum post −0.20, Homework −0.95 और project page −0.97। scores मेरे बनाए
Retriever क्या लाया
PopQA0.59, −0.99
PubHealth0.5, −0.91
Biography0.95, −0.91
Queue log, forum post, Homework
Correct
Correct
Ambiguous
अकेला forum post
Ambiguous
Ambiguous
Ambiguous
Homework, project page
Ambiguous
Incorrect
Incorrect
पहली row में queue log का 0.70, PopQA के 0.59 से ऊपर है, इसलिए पूरा set Correct है, भले उसमें Homework −0.95 पर हो। Biography पर ऊपर वाला threshold 0.95 है, जिसे queue log पार नहीं करता।
तीसरी row में PopQA का नीचे वाला threshold −0.99 है। Homework का −0.95 उससे ऊपर है, इसलिए फ़ैसला Ambiguous है। PubHealth पर −0.95 और −0.97, दोनों −0.91 से नीचे हैं, इसलिए Incorrect।
Ambiguous क्यों है, ये paper के एक शुरुआती experiment से दिखा। सिर्फ़ Correct और Incorrect के साथ CRAG evaluator की हर गलती पर पूरा गलत रास्ता लेता था। Ambiguous बीच का रास्ता है, जिसमें documents भी रहते हैं और web के नतीजे भी आते हैं। paper से
Strips और web search के numbers
Refinement में भी यही evaluator चलता है। लंबा document कुछ sentences वाली strips में टूटता है, और evaluator हर strip को score देता है। फिर −0.5 से ऊपर वाली strips में से सबसे ऊँची 5 रहती हैं। paper से Milestone वाले सवाल पर मान लीजिए syllabus की strips को 0.8, 0.1 और −0.7 मिले। मेरे scores पहली दो −0.5 से ऊपर हैं और रहती हैं, और Week 10 वाली −0.7 पर हटती है।
Web के लिए GPT-3.5 Turbo को एक prompt मिलता है, जो सवाल से ज़्यादा से ज़्यादा तीन keywords माँगता है, comma से अलग करके। Paper का example: What is Henry Feilden's occupation? से query Henry Feilden, occupation बनती है। Google Search API से top 5 pages आते हैं, और CRAG Wikipedia के pages को पहले रखता है। फिर इन pages के paragraphs पर भी वही evaluator चलता है। paper से
हमारे सवाल पर ऐसी query कुछ office hour, least crowded, this week जैसी होगी। मेरा example लेकिन इस course का queue log web पर नहीं है, इसलिए यहाँ web search से कुछ काम का नहीं आएगा। CRAG तब भी ढूँढेगा, क्योंकि वो सिर्फ़ evaluator के फ़ैसले पर चलता है।
नतीजे: points और %
Paper ने CRAG को सीधी RAG के ऊपर लगाया, और generator SelfRAG-LLaMA2-7b रखा, यानी वही model, जिसे Self-RAG ने train किया था: paper से
Task
RAG
CRAG
फ़र्क
PopQAaccuracy
52.8
59.8
+7.0
BiographyFactScore
59.2
74.1
+14.9
PubHealthaccuracy
39.0
75.6
+36.6
ARC-Challengeaccuracy
53.2
68.6
+15.4
Paper इन फ़र्कों को 7.0% accuracy जैसा लिखता है। ये points हैं, और % वाली बढ़त इससे अलग है:
Points: 59.8 − 52.8 = 7.0।
% वाली बढ़त: 7.0 ÷ 52.8 = 0.133, यानी 13.3%।
PubHealth पर 36.6 points की बढ़त 39.0 के हिसाब से 93.8% है, यानी accuracy करीब दोगुनी। जाँच: 75.6 ÷ 39.0 = 1.94।
Paper ने CRAG को Self-RAG के ऊपर भी लगाया, और इसे Self-CRAG कहा। PopQA पर Self-RAG के 54.9 से Self-CRAG 61.8 पर पहुँचा, यानी 6.9 points आगे। ARC पर 67.3 से 67.2, यानी 0.1 point नीचे। paper से
जब generator आम LLaMA2-hf-7b था, जिसे reflection tokens की training नहीं मिली थी, तब PopQA पर Self-RAG का तरीका 29.0 पर गिरा। उसी generator के साथ सीधी RAG 50.5 पर थी, और CRAG 54.9 पर। यही पड़ाव 5 वाली बात है: Self-RAG को अपना trained generator चाहिए, और CRAG किसी भी generator के साथ चलता है।
Evaluator कितना सही परखता है, ये PopQA पर नापा। T5 evaluator 84.3% बार सही था। ChatGPT से यही काम करवाने पर 58.0% आया, step by step सोचने वाले prompt के साथ 62.4%, और examples के साथ 64.7%। paper से
Ablation में refinement हटाने पर PopQA 59.8 से 54.2 पर आया, query rewriting हटाने पर 56.2, और web नतीजों में से चुनना हटाने पर 58.6। सीधी RAG में हर बार web जोड़ने से accuracy 52.8 से सिर्फ़ 53.8 हुई। यानी web अकेले 1.0 point देता है, और CRAG का परखना उसके ऊपर 6.0 points और। paper से
ये परखना मुफ़्त नहीं है। Generation वाले हिस्से में एक सवाल पर RAG को करीब 0.363 second लगे, और CRAG को 0.512, यानी करीब 1.41 गुना। Paper कहता है कि ये मोटा अंदाज़ा है, और इसमें retrieval और web search का वक्त नहीं गिना। paper से
9अब Stanford की slides खुद पढ़िए
नीचे Stanford की agentic RAG वाली तीनों slides हैं, बिना किसी बदलाव के, और साथ में उनके बड़े किए हिस्से। हर slide के नीचे कुछ सवाल हैं। पहले खुद जवाब सोचिए, फिर खोलिए। कोई बात अटके, तो जवाब में लिखे पड़ाव पर लौट जाइए। Phone पर slide छोटी दिखे, तो image पर click कीजिए, वो पूरे size में खुलेगी।
Stanford की slide: Agentic RAG, loop के अंदर retrieval।
Agentic RAG वाली slide पढ़िए
पहली line कहती है Everything so far answers one question well। इस lecture की कौन सी चीज़ें इसमें आती हैं, और उनमें क्या नहीं है?
जवाब देखिए
Chunking, BM25, DPR, hybrid search और reranking। ये सब एक सवाल पर एक बार के retrieval को बेहतर करते हैं। इनमें से कोई तय नहीं करता कि ढूँढना है या नहीं, क्या पूछना है, और कब रुकना है। (पड़ाव 2)
Retrieval should be an action the agent takes में action क्या है, tool क्या है, और observation क्या होगा?
जवाब देखिए
Search करना action है, retriever या search engine tool है, और जो passages लौटे, वो observation हैं। Agent उन्हें पढ़कर अगला action चुनता है। (पड़ाव 1)
Slide की ऊपर वाली line में when to stop है, लेकिन नीचे के तीन फ़ैसलों में stop शब्द नहीं है। ये बात किस फ़ैसले में है?
जवाब देखिए
तीसरे फ़ैसले में, whether the result is good enough। नतीजा काफ़ी अच्छा है, तो agent रुककर जवाब लिखता है। (पड़ाव 2)
Stanford की Self-RAG वाली slide, और नीचे उसके step 1 और 2, और फिर step 3, बड़े करके।
Self-RAG वाली slide पढ़िए
Step 1 का नाम Retrieve on demand है। on demand किस फ़ैसले की बात है, और paper में model कब ढूँढता है?
जवाब देखिए
फ़ैसला 1 की। Model Retrieve token लिखता है। Paper में system तब ढूँढता है, जब yes और no के बीच yes का हिस्सा δ = 0.2 से ऊपर हो। (पड़ाव 3 और 6)
Step 3 में 1 के आगे दो हरे box हैं, 3 के आगे एक हरा और एक नारंगी, और 2 के आगे एक लाल। ये कौन से tokens हैं, और score से 1 > 3 > 2 कैसे निकलता है?
जवाब देखिए
1 पर Relevant और Supported हैं, 3 पर Relevant और Partially, और 2 पर Irrelevant। IsSup में partially को आधा वज़न मिलता है, इसलिए 3 का score 1 से कम है। 2 का IsRel हिस्सा छोटा है, इसलिए वो सबसे नीचे है। हमारे example में यही क्रम 2.15, 1.475 और 0.425 से निकला था। (पड़ाव 6)
आख़िरी जवाब में citations 1 और 4 हैं, जबकि step 1 में सिर्फ़ तीन passages आए थे। 4 कहाँ से आया? और दाईं ओर के retrieve, critique और generate किन चीज़ों से जुड़ते हैं?
जवाब देखिए
Model ने दोबारा Retrieve लिखा, यानी Repeat वाला हिस्सा, और Utah वाली बात अगले round के passage 4 से आई। Retrieve token ढूँढने का फ़ैसला है, IsRel, IsSup और IsUse critique tokens हैं, और generate हर हिस्से का लिखना है। (पड़ाव 3 और 6)
Stanford की CRAG वाली slide, और नीचे उसका evaluator, दोनों boxes और generation वाली row, बड़े करके।
CRAG वाली slide पढ़िए
Evaluator के बादल में लिखा है If retrieved documents are correct to x? यहाँ x क्या है, और evaluator इसका जवाब किस रूप में देता है?
जवाब देखिए
x सवाल है। Evaluator हर सवाल-document जोड़े को −1 से 1 का score देता है, और दो thresholds से Correct, Ambiguous या Incorrect बनता है। बाईं ओर का नीला box यही कहता है: relevance परखना, और confidence से action चुनना। (पड़ाव 4 और 8)
Knowledge Refinement box में d1, d2, strip और kin क्या हैं? strip2 का रंग अलग क्यों है?
जवाब देखिए
d1 और d2 retriever के लाए documents हैं। Decompose उन्हें strips में तोड़ता है, Filter पर evaluator का निशान है, और Recompose बची strips को जोड़कर kin बनाता है, यानी अंदर का knowledge। strip2 Filter के बाद नहीं दिखती, इसलिए वो हटाई गई strip है, जैसे हमारे syllabus में Week 10 वाली। (पड़ाव 4 और 8)
Knowledge Searching box की query q सवाल x से कैसे अलग है, और kex क्या है? फिर नीचे की generation row पढ़िए।
जवाब देखिए
q में सिर्फ़ keywords हैं: Death of a Batman, screenwriter और Wikipedia। Paper का prompt ज़्यादा से ज़्यादा तीन keywords माँगता है, और CRAG Wikipedia के pages पहले रखता है। Web search से k1 से kn आते हैं, और Select के बाद kex बनता है, यानी बाहर का knowledge।
Generation row में Correct पर generator को x + kin मिलता है, Ambiguous पर x + kin + kex, और Incorrect पर x + kex। (पड़ाव 4 और 8)
इस lesson की 3 बातें
Agent loop में action लेता है, observation पढ़ता है, और अगला action तय करता है। हर कदम पर तीन फ़ैसले हैं: ढूँढें या नहीं, कौन सी query भेजें, और नतीजा काफ़ी अच्छा है या नहीं।
Self-RAG हर critique किस्म की probabilities को उसी किस्म के अंदर हिस्सों में बदलता है। इन हिस्सों का वज़न वाला जोड़ हर हिस्से का score है, और ढूँढने का फ़ैसला yes के हिस्से और δ = 0.2 से होता है।
CRAG का T5 evaluator −1 से 1 तक score देता है। एक document ऊपर वाले threshold से ऊपर हो, तो Correct, और सारे नीचे वाले से नीचे हों, तो Incorrect। PopQA पर ये RAG के 52.8 को 59.8 करता है, यानी 7.0 points।
इस lesson के नए शब्द
Agent
Loop में काम करने वाला LLM, जो action चुनता है, observation पढ़ता है, और अगला action तय करता है। जैसे OH timings की search खाली आई, तो agent ने नई query लिखी।
Action और tool
Agent का चुना काम, जैसे OH timings search करना। Tool वो program है, जो ये काम करता है, जैसे search engine।
Observation
Action का नतीजा, जो agent अगले कदम से पहले पढ़ता है। जैसे पहली search का नतीजा: हर passage का score 0।
Agentic RAG
RAG, जिसमें ढूँढना agent का action है, pipeline का तय step नहीं। जैसे 17 × 3 पर 0 searches, और Jed Hoyer वाले सवाल पर 3।
Self-RAG
Generator खुद reflection tokens लिखकर तय करता है कि कब ढूँढना है, और कौन सा हिस्सा रखना है। जैसे forum post वाले हिस्से पर Relevant और Partially।
Reflection tokens
Vocabulary में जोड़े गए खास tokens, जिन्हें model बाकी text की तरह लिखता है। जैसे Retrieve, Relevant या Irrelevant, और Supported या Partially।
CRAG
Corrective RAG: एक evaluator retrieval को Correct, Incorrect या Ambiguous कहता है, और उसी हिसाब से refinement, web search या दोनों चलते हैं। जैसे 0.4 वाला forum post Ambiguous है।
Retrieval evaluator
सवाल और एक document पढ़कर confidence देने वाला हल्का model। जैसे K = 1 पर forum post को 0.4।
Knowledge refinement
Documents को strips में तोड़ना, बेकार strips हटाना, और बाकी को क्रम से जोड़ना। जैसे milestone वाले सवाल पर syllabus की 3 में से 2 strips रहती हैं।
Threshold
पहले से तय limit, जिसके ऊपर या नीचे होने पर अलग action चलता है। जैसे CRAG में 0.6 से ऊपर Correct, और 0.2 से नीचे Incorrect।
Critic
किसी और के लिखे या लाए को grade देने वाला model। जैसे Self-RAG में Llama 2 7B का critic training data में reflection tokens लगाता है, और CRAG की slide अपने evaluator को critic कहती है।
Segment score (Self-RAG)
हर हिस्से के critique हिस्सों का वज़न वाला जोड़: S = 1.0 × sIsRel + 1.0 × sIsSup + 0.5 × sIsUse। जैसे queue log वाले हिस्से का S = 0.9 + 0.875 + 0.5 × 0.75 = 2.15।
Beam search
हर कदम पर सबसे ऊँचे score वाले B अधूरे जवाब रखकर आगे बढ़ना। जैसे B = 2 पर queue log (2.15) और forum post (1.475) वाले जवाब अगले कदम तक रहते हैं, और Homework (0.425) छूटता है।