11/30अध्याय 11 / 30

Base Model से Assistant तक: SFT, RLHF, DPO और GRPO

Base model टेक्स्ट जारी करता है; SFT, RLHF, DPO और GRPO उसे जवाब देने वाला assistant बनाते हैं।

9 जुलाई 2026अपडेट किया गया 11 सितंबर 202619 मिनट पढ़ें

इस पेज पर

GPT-2 — एक सक्षम रूप से pretrained language model — से समुद्र पर एक haiku लिखने को कहिए:

TEXT

prompt: Write a haiku about the sea.

The sea is a beautiful place.

The sea is a beautiful place.

The sea is a beautiful place.

The sea is a beautiful place.

The sea is a beautiful place.

यह भ्रमित नहीं है, और अपने काम में विफल भी नहीं हुआ है। यह ठीक वही कर रहा है जिसके लिए अध्याय 10 ने इसे train किया था: कुछ टेक्स्ट दिए जाने पर, संभव अगला टेक्स्ट बनाना। इंटरनेट पर, Write a haiku about the sea. जैसी पंक्ति के बाद अक्सर समुद्र के बारे में गद्य आता है, और जो वाक्य अभी-अभी आया हो, उसके फिर से आने की संभावना असामान्य रूप से अधिक होती है। model एक शानदार next-token predictor है और एक बेकार assistant।

अब वही अनुरोध उसी तरह बने एक model से — Qwen2.5, आधा अरब parameters, ऊपर वाले GPT-2 से चार गुना बड़ा और फिर भी 2026 के किसी भी मानक से छोटा — उन training stages के बाद जिनके बारे में यह अध्याय है:

TEXT

Whispers of the ocean,
Silent depths where waves meet,
Mysteries in the vast blue.

चार गुना parameters किसी model को बोलना बंद करना नहीं सिखाते। उन दो outputs के बीच का अंतर scale नहीं, architecture नहीं और data volume नहीं है। यह post-training है: pretraining से कई orders of magnitude छोटा दूसरा phase, जो text predictor को ऐसी चीज़ में बदलता है जो जवाब देती है।

पहला stage: इसे दिखाना कि जवाब कैसा दिखता है

सेक्शन का लिंक: पहला stage: इसे दिखाना कि जवाब कैसा दिखता है

पहला कदम सबसे कम आकर्षक है और अधिकांश काम वही करता है। instructions और अच्छे responses के जोड़े के examples इकट्ठा कीजिए, और अध्याय 8 वाले ठीक उसी loss — अगले token की prediction — के साथ training जारी रखिए, लेकिन सिर्फ response वाले हिस्से पर। यह supervised fine-tuning, या SFT है।

भाषा के बारे में कुछ नया नहीं सिखाया जा रहा। जो सिखाया जा रहा है वह एक format है: कि इस आकार के टेक्स्ट के बाद उस आकार का टेक्स्ट आता है, और फिर वह रुकता है। base model की विफलता को फिर देखिए। उसने पहले वाक्य में सवाल का जवाब दे दिया था और फिर रुक नहीं सका, क्योंकि उसकी training में किसी response का अंत कभी mark नहीं किया गया था। रुकना एक सीखा हुआ व्यवहार है।

इसीलिए model को यह भी बताना पड़ता है कि boundaries कहाँ हैं, और यही एक chat template करता है:

TEXT

<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>
<|im_start|>user
What is the capital of France?<|im_end|>
<|im_start|>assistant

वे <|im_start|> और <|im_end|> markers vocabulary में वास्तविक tokens हैं, fine-tuning से पहले जोड़े गए, और model ने उन्हें लाखों बार ठीक इन्हीं positions में देखा। इन्हीं से उसे पता चलता है कि किसकी बारी है और कोई turn कहाँ खत्म होता है।

template छोड़ दीजिए और model को एक नंगा सवाल दे दीजिए, तो आप उसे ऐसी sequence दे रहे हैं जो उसने training में नहीं देखी। मापा गया, वही model, वही सवाल, वही greedy decoding:

template के बिना — raw string What is the capital of France?:

TEXT

 The capital of France is Paris.

To verify this, I will use a simple
Python code snippet to confirm that
Paris is indeed the capital city of
France.

[...and then it starts writing a
Python script to check its own answer]

template के साथ:

TEXT

The capital of France is Paris.

जवाब दोनों में सही है, लेकिन markers के बिना model खुद को check करने के लिए Python लिखने की ओर भटक जाता है, क्योंकि उसे मिला prompt उस चीज़ जैसा नहीं दिखता जिस पर उसे fine-tune किया गया था। “model को सीधे call करने पर वह बेवकूफ हो गया” का यह सबसे आम कारण है: template model के चारों ओर सजावट नहीं है, यह model का हिस्सा है, और गलत template बिना किसी error के चुपचाप degradation पैदा करती है।

Tool calling एक trained behaviour है, emergent capability नहीं।

इसे यहाँ दर्ज कर देना उपयोगी है क्योंकि इससे अध्याय 18 पढ़ने योग्य हो जाता है। जब कोई model किसी function को call करने के लिए structured request emit करता है, तो कोई रहस्यवादी चीज़ नहीं हो रही होती: post-training के दौरान उसे हजारों conversations दिखाए गए थे जिनमें user ने कुछ पूछा, assistant turn में एक specific format में tool call था, tool result एक specific role में वापस आया, और assistant ने फिर उसका उपयोग करके जवाब दिया।

model ने वह format उसी तरह सीखा जैसे उसने बोलना बंद करना सीखा। यही कारण है कि tool-calling reliability उन models के बीच इतनी बदलती है जो अन्यथा comparable हैं, format model-specific होता है, और कोई model ऐसा tool call कर सकता है जिसे उसने कभी नहीं देखा — shape trained था, specific tool prompt से आता है।

दूसरा stage, और वह समस्या जिसे हल करने के लिए यह है

सेक्शन का लिंक: दूसरा stage, और वह समस्या जिसे हल करने के लिए यह है

SFT की एक ceiling है, और वह ceiling data है। किसी demonstration पर fine-tune करने के लिए आपको किसी से ideal response लिखवाना पड़ता है — और अधिकांश दिलचस्प सवालों के लिए अच्छा जवाब लिखना कठिन, धीमा, महंगा है, और ठीक एक ऐसा answer देता है जिसकी quality आप verify नहीं कर सकते।

जिस चीज़ में लोग अच्छे हैं, वह है comparison। दो responses दिखाए जाने पर, annotator कुछ सेकंड में भरोसे से बता सकता है कि कौन सा बेहतर है, भले ही वह दोनों में से कोई भी खुद न बना सके। यही तथ्य पूरे दूसरे stage की नींव है, और यही वह हिस्सा है जिसे अधिकांश explanations उल्टा समझाते हैं:

Humans answers नहीं लिखते। वे pairs rank करते हैं।

इसलिए data pairs है — एक prompt, दो responses, और कौन जीता। इसे next-token loss में plug नहीं किया जा सकता, क्योंकि कोई target sequence नहीं है। इसके लिए एक अलग machine चाहिए।

reinforcement learning vocabulary, बिना reinforcement learning course के।

पाँच शब्द, यहाँ अपने मूल field की तुलना में संकरे अर्थों में उधार लिए गए। यह box इसलिए है ताकि “GRPO removes the critic by using the group mean as the baseline” एक sentence बने, noise नहीं।

policy model है। state — prompt और अब तक के tokens — दिए जाने पर, यह आगे क्या करना है उस पर एक distribution बनाता है, और “आगे क्या करना है” एक token है। यह अध्याय 8 वाली वही object है, बस नाम अलग है।

reward outcome को score करने वाली संख्या है। इस अध्याय में यह पूरे response को score करता है, हर token को नहीं — आप यह नहीं कह सकते कि सातवां token अच्छा था या नहीं, जब तक पूरा answer न देख लें। return actions की sequence से मिला कुल reward है; यहाँ वे वही चीज़ हैं, क्योंकि reward केवल अंत में आता है।

advantage यह है कि कोई action expected से कितना बेहतर था। Raw rewards खराब training signal हैं क्योंकि उनमें arbitrary offset होता है: अगर हर response 8.0 और 8.4 के बीच score करता है, तो gradient constant 8 से dominated हो जाता है। baseline — इस prompt के लिए expected reward का estimate — घटाने से केवल वह हिस्सा बचता है जो बदलता है, और वही हिस्सा information carry करता है। critic एक दूसरा model है जिसे वह baseline predict करने के लिए train किया जाता है।

policy gradient ही इसे trainable बनाता है। आप “annotator ने इस response को prefer किया” के through backpropagate नहीं कर सकते, क्योंकि human का कोई derivative नहीं होता। आप जो कर सकते हैं वह है baseline से ऊपर score करने वाले responses में tokens की probability बढ़ाना और नीचे वालों के लिए घटाना, advantage से weighted। पूरा idea यही है, और इस अध्याय के लिए यह काफी है।

जो जानबूझकर यहाँ नहीं है: Markov decision processes, Bellman equations, value iteration, discount factors, exploration। वे proper reinforcement learning में मायने रखते हैं और नीचे के algorithms में नहीं आते। असली विषय के लिए, Sutton और Barto।¹

reward model, और यह सच में क्या सीखता है

सेक्शन का लिंक: reward model, और यह सच में क्या सीखता है

आप training के दौरान हर response को score करने के लिए human से नहीं पूछ सकते — वे millions of judgements होंगे। इसलिए आप humans की नकल करने के लिए एक model train करते हैं: एक reward model जो response लेता है और scalar लौटाता है।

comparisons से इसे train करना 1952 के एक result का उपयोग करता है। Bradley–Terry model² कहता है कि अगर दो items में latent strengths हैं, तो एक के दूसरे को हराने की probability उनके difference का logistic function है। इसे उलट दीजिए और यह loss बन जाता है: जब human ने $y_l$ की तुलना में $y_w$ को prefer किया, तो maximise कीजिए

P(y_w \succ y_l) = \sigma\big(r(y_w) - r(y_l)\big)

जो code में पूरी training loop है:

reward_model.pyPYTHON

loss = -F.logsigmoid(reward(chosen) - reward(rejected)).mean()

ध्यान दीजिए model क्या कभी नहीं देखता: absolute score। यह केवल differences सीखता है, और data में ठीक वही मौजूद है।

अब वह हिस्सा जिसे मापना जरूरी है। reward model वही सीखता है जिसे annotators ने reward किया, और annotators लोग होते हैं। यहाँ एक simulation है जहाँ किसी response की true quality केवल useful और correct होने पर निर्भर करती है — length की कोई कीमत नहीं — लेकिन simulated annotator की, बाकी सब करीब होने पर, longer answers के लिए हल्की preference है, जो एक अच्छी तरह documented human bias है। reward model को 2000 comparisons पर train कीजिए और उसके weights पढ़िए:

annotator का length bias	useful पर learned weight	correct पर	length पर
0.0	+1.00	+1.00	+0.01
0.3	+0.98	+1.00	+0.15
0.6	+0.97	+1.00	+0.27
1.2	+1.00	+0.99	+0.59

reward model बिल्कुल सही काम कर रहा है। उसने उसे दिखाई गई preferences को ईमानदारी से सीखा है — उन preferences के उस हिस्से सहित जिसका quality से कोई लेना-देना नहीं। reward model अच्छेपन का measure नहीं है; यह annotators ने क्या चुना उसका measure है, और annotation pool का हर bias अब एक differentiable function में coefficient है जिसके against अब एक बहुत बड़ा model optimise होने वाला है।

Reward hacking, मापा हुआ

सेक्शन का लिंक: Reward hacking, मापा हुआ

जिससे हम वहाँ पहुँचते हैं कि इसे optimise करने पर क्या होता है। policy को response की properties में खर्च करने के लिए effort का fixed budget दीजिए, एक realistic asymmetry के साथ: useful और correct होना महंगा है, और longer होना सस्ता — आप बस लिखते जाते हैं।

ऊपर trained model के लिए effort की प्रति unit reward: useful 8.26, correct 8.31, length 31.70। Length correctness से लगभग चार गुना बेहतर भुगतान करती है, इसलिए नहीं कि reward model टूटा हुआ है, बल्कि इसलिए कि यह सस्ती है।

उस reward के against optimise कीजिए और दोनों numbers देखिए:

	reward model का score	true quality	produced length
starting policy	12.588	0.974	3.365
optimisation के बाद	31.696	0.000	12.497

reward 2.5 गुना बढ़ गया। जिस चीज़ को reward मापने वाला था वह zero पर चली गई। policy ने खोज लिया कि वह लंबा लिखकर और कुछ न कहकर बहुत बड़ा score कर सकती है, और training loop के किसी हिस्से के पास यह notice करने का कोई तरीका नहीं था, क्योंकि loop के अंदर reward model ही good की definition है।

यह reward hacking है, और अगर आपने कभी सोचा है कि chat models इतने verbose क्यों होते हैं, तो यह table जवाब का बड़ा हिस्सा है।

KL penalty वास्तव में क्या देती है

सेक्शन का लिंक: KL penalty वास्तव में क्या देती है

standard defence है policy को उसके शुरू किए हुए point से बहुत दूर जाने पर penalise करना, अध्याय 4 वाली KL divergence से distance मापते हुए:

\text{objective} = \mathbb{E}\big[r(y)\big] - \beta \, D_{\mathrm{KL}}\big(\pi_\theta \,\|\, \pi_{\text{ref}}\big)

reference $\pi_{\text{ref}}$ SFT model है — reinforcement stage से पहले की policy। दावा है कि यह model को degenerate behaviour में भटकने से रोकता है। आइए देखते हैं कि इस दावे का कितना हिस्सा measurement में बचता है। वही setup, $\beta$ sweep करते हुए:

$\beta$	reward	true quality	length	KL
0	31.699	0.000	12.498	2.994
1	31.697	0.000	12.497	2.993
5	28.318	0.285	10.700	2.163
15	12.860	1.542	2.552	0.151
30	10.426	1.719	1.303	0.025
60	9.632	1.769	0.908	0.005
सिर्फ reference model	9.162	1.791	0.687	0

आखिरी row को बाकी के against पढ़िए। $\beta = 0$ और $\beta = 1$ पर penalty कुछ भी नहीं करती: reward KL से इतना ज्यादा मूल्यवान है कि optimiser fine भर देता है और फिर भी hack करता है। 5 और 15 के बीच behaviour झूलता है। और $\beta = 60$ तक true quality वापस 1.769 पर चढ़ गई है — जो फिर भी उस 1.791 से नीचे है जो reference model के पास इनमें से कुछ भी शुरू होने से पहले था।

उस number को कहीं quote करने से पहले एक caveat: last row का 1.791 और पहली table में starting policy को मिला 0.974 उसी pre-RL model के दो अलग measurements हैं, जिन्हें दो experiments ने अलग-अलग लिया। किसी table के अंदर rows compare कीजिए, tables के पार नहीं — हर table का conclusion अपनी rows पर खड़ा है, और कोई भी दूसरे के baseline पर निर्भर नहीं है।

इसलिए ईमानदार summary “KL penalty reward hacking रोकती है” नहीं है। यह है:

KL penalty reward hacking नहीं रोकती। यह limit करती है कि policy reference से कितनी दूर जा सकती है — और क्योंकि failure को move करना पड़ता है, इससे मदद मिलती है। लेकिन यह corrective नहीं, leash है: कम $\beta$ पर leash टूट जाती है, और ज्यादा $\beta$ पर आपको reference model वापस मिल जाता है और पूरा महंगा stage कुछ नहीं खरीदता।

useful band संकरा है, उसका location reward model पर निर्भर करता है, और उसे देखने के अलावा खोजने का कोई तरीका नहीं है। इसीलिए reference model अच्छा होना चाहिए — KL reference की quality पर floor है, failure पर ceiling नहीं — और यही इस stage के principle में नहीं बल्कि practice में कठिन होने का बड़ा कारण है।

PPO, और DPO ने उसे क्यों खा लिया

सेक्शन का लिंक: PPO, और DPO ने उसे क्यों खा लिया

जिस algorithm ने इसे scale पर काम कराया वह Proximal Policy Optimization है।³ एक paragraph में: यह हर response का advantage estimate करता है, policy को above-baseline responses की probability बढ़ाने के लिए update करता है, और किसी भी single update के size को clip करता है ताकि बड़ा advantage estimate एक step में policy को destroy न कर दे। language models⁴ पर लागू करने का मतलब है एक साथ चार models चलाए रखना — policy, reference, reward model, और critic — और training के दौरान policy से fresh samples generate कराते रहना।

यह काम करता है, इसने InstructGPT और उससे निकली हर चीज़ बनाई, और यह सचमुच कठिन है: memory में चार models, training loop में sampling, और instability की ऐसी reputation जो deserved है। यह pretend करना कि आप इसे blog post में implement कर सकते हैं, बेईमानी होगी, इसलिए यह अध्याय ऐसा नहीं करता।

अधिकांश purposes के लिए इसकी जगह जो आया, वह एक observation से आया। ऊपर वाले KL-regularised objective की closed-form optimal policy है, और उस expression को invert किया जा सकता है: reward को optimal policy और reference के terms में लिखा जा सकता है। उसे Bradley–Terry loss में वापस substitute करने पर reward model पूरी तरह गायब हो जाता है। जो बचता है वह preference pairs पर supervised loss है — कोई sampling नहीं, कोई critic नहीं, कोई reward model नहीं, memory में चार की बजाय दो models।

यह Direct Preference Optimization है,⁵ और यह दो lines है:

dpo.pyPYTHON

def dpo_loss(pi_w, pi_l, ref_w, ref_l, beta=0.1):
    """pi_* and ref_* are summed log-probabilities of a full response."""
    logits = beta * ((pi_w - ref_w) - (pi_l - ref_l))   
    return -F.logsigmoid(logits)

पढ़िए यह क्या कहता है। जिस quantity को ऊपर push किया जा रहा है वह है policy winner को reference की तुलना में कितना ज्यादा prefer करती है, minus वह loser को कितना ज्यादा prefer करती है। reference बाद में bolt की गई penalty नहीं है — यह loss के अंदर है, इसीलिए DPO को separate KL term की जरूरत नहीं होती।

सबसे महत्वपूर्ण property gradient में है। उसी pair पर policy की पाँच अलग states में loss और उसका gradient evaluate कीजिए:

policy की state	loss	gradient magnitude
winner को पहले से strongly prefer करती है	0.5130	0.0401
उसे पहले से prefer करती है, weakly	0.6685	0.0488
reference जैसी ही	0.6931	0.0500
loser को prefer करती है	0.7981	0.0550
loser को strongly prefer करती है	1.0055	0.0634

policy जितना ज्यादा गलत होती है, gradient उतना बढ़ता है। जिन pairs को model पहले से handle कर लेता है वे लगभग कुछ contribute नहीं करते; जिन pairs में वह उल्टा करता है वे update पर dominate करते हैं। DPO हर example को इस हिसाब से weight करता है कि policy अभी कितनी गलत है, अपने आप, बिना किसी scheduling के — और यही self-weighting वह mechanism है जो PPO के advantage estimate और critic वाला काम कर रहा था। (तीसरी row का loss ठीक $\ln 2$ है, जो किसी भी implementation को check करने का anchor है: reference जैसी policy ने कुछ नहीं सीखा है और उसे $\ln 2$ पर बैठना चाहिए।)

GRPO⁶ उसी problem से बाहर आने का अलग route लेता है। यह sampling loop रखता है लेकिन critic हटा देता है: baseline predict करने के लिए model train करने की बजाय, यह उसी prompt पर responses का एक group sample करता है और group के mean reward को सीधे baseline के रूप में use करता है। किसी response का advantage यह है कि वह अपने siblings से कितना बेहतर था। इससे पूरा एक model हटाकर larger batch मिलती है, और इसी ने verifiable-reward training — अध्याय 12 का विषय — को practical बनाया।

विवरण दिखाएँ

post-training landscape के तीन और हिस्से, संक्षेप में।

RLAIF और Constitutional AI।⁷ annotator human होना जरूरी नहीं। किसी model को principles का लिखा हुआ set दीजिए और उससे अपने outputs को critique और revise करने को कहिए, या दो candidates में से चुनने को कहिए, और आपके पास machine speed और cost पर बना preference dataset है। स्पष्ट objection — model अपनी ही homework grade कर रहा है — वास्तविक है, और ईमानदार answer यह है कि यह सुनने से बेहतर काम करता है क्योंकि judging, generating से आसान है, और यही वही asymmetry है जिस पर पूरा अध्याय टिका है।

LIMA, और इसे कितना कम data चाहिए।⁸ हजार carefully curated demonstrations ने competitive assistant बना दिया। proposed explanation यह है कि pretraining ने knowledge और format पहले ही install कर दिया था, और post-training को बस यह select करना है कि model के existing behaviours में से कौन से surface हों। अगर यह सही है, तो post-training data quality quantity पर dominate करती है — और field का तब से व्यवहार बताता है कि लोग इसे मानते हैं।

LoRA और QLoRA।⁹¹⁰ large model के हर weight को fine-tune करने के लिए weights, उनके gradients और optimiser state के लिए memory चाहिए — अध्याय 10 के sixteen bytes per parameter, उन दो averages के ऊपर जिन्हें अध्याय 6 ने हाथ से बनाया — ऐसे scale पर जिसे cluster चाहिए। LoRA original weights को freeze करता है और उनके साथ matrices की low-rank pair train करता है, जिससे trainable parameters orders of magnitude कम हो जाते हैं; QLoRA frozen base को अतिरिक्त रूप से 4 bits में quantize करता है। दोनों को यहाँ technique के रूप में cover किया गया है। fine-tuning पर पैसा खर्च करना सही चीज़ है या नहीं, यह अलग सवाल है, और वह अध्याय 20 का है।

alignment tax, और वह सवाल जिसका जवाब किसी ने नहीं दिया

सेक्शन का लिंक: alignment tax, और वह सवाल जिसका जवाब किसी ने नहीं दिया

आगे ले जाने के लिए दो चीज़ें।

पहली यह कि इस stage की एक cost है, और वह capability के रूप में दिखती है। Models अक्सर alignment training के बाद कुछ benchmark tasks पर measurably worse हो जाते हैं — alignment tax — क्योंकि objective बदल गया: safe, hedged और well-formatted response हमेशा वह response नहीं होता जो accuracy maximise करे। उस gap का कुछ हिस्सा engineer करके हटाया गया है, और कुछ हिस्सा fix करने वाले bug के बजाय वास्तविक trade है।

दूसरी वह सवाल है जिसे aligned शब्द छिपा देता है। किसके साथ aligned? chain यह है: company guidelines लिखती है, contractors उन्हें interpret करते हैं, उनकी comparisons reward model train करती हैं, reward model policy को shape करता है, और policy ऐसे व्यक्ति के सवाल का जवाब देती है जिसने इनमें से कुछ नहीं देखा। हर link specific लोगों द्वारा किया गया choice है, और इस अध्याय के algorithms में से किसी की कोई राय नहीं कि वे choices अच्छे हैं या नहीं।

यह rhetorical flourish नहीं है। यही concrete reason है कि दो frontier models अलग-अलग requests refuse करते हैं, वही model versions के बीच अपना mind बदलता है, और “aligned” किसी artefact की property नहीं बल्कि एक process का description है। इस अध्याय की mathematics settled है। वह हिस्सा नहीं।

आगे यह कहाँ जाता है

सेक्शन का लिंक: आगे यह कहाँ जाता है

Post-training ने model को जवाब देना सिखाया। इसने उसे जवाब देने से पहले सोचना नहीं सिखाया, और ये दोनों ऐसे अलग हैं जो trainable निकलते हैं।

अध्याय 12 इस बारे में है कि जब आप model को किसी कठिन सवाल पर training time की बजाय answer time पर अधिक computation खर्च करने देते हैं तो क्या होता है — chain of thought, verifiable rewards से reinforcement learning, और वह कारण कि अपना working दिखाने वाला model केवल खुद को explain नहीं कर रहा होता बल्कि अलग ढंग से compute कर रहा होता है। यह इस अध्याय का debt भी चुकाता है: GRPO उसमें मौजूद है, वही काम करते हुए जो PPO का critic करता था, ऐसे rewards पर जिन्हें किसी annotator की जरूरत नहीं क्योंकि proof या तो check होता है या नहीं।

Sources and method

सेक्शन का लिंक: Sources and method

ऊपर की generations gpt2 और Qwen/Qwen2.5-0.5B-Instruct से greedy decoding के साथ आती हैं, इसलिए वे exactly reproduce होती हैं। Hugging Face LLM Course का अध्याय 11 trl और peft के साथ SFT और DPO समझाता है अगर आप simulation की बजाय असली चीज़ run करना चाहते हैं; Sebastian Raschka की Build a Large Language Model (From Scratch) का अध्याय 7 बिना library के instruction fine-tuning end to end implement करता है।

संदर्भ

सेक्शन का लिंक: संदर्भ

Sutton, R. S. and Barto, A. G. Reinforcement Learning: An Introduction, 2nd edition (MIT Press, 2018). delegation जानबूझकर है: ऊपर वाला vocabulary box सबसे छोटा usable subset है, और असली विषय एक किताब है। ↩
Bradley, R. A. and Terry, M. E. Rank Analysis of Incomplete Block Designs: I. The Method of Paired Comparisons. Biometrika 39(3/4), pp. 324–345 (1952). आज उपयोग में हर reward model के नीचे मौजूद pairwise-comparison model। ↩
Schulman, J., Wolski, F., Dhariwal, P., Radford, A. and Klimov, O. Proximal Policy Optimization Algorithms. arXiv:1707.06347 (2017). ↩
Ouyang, L. et al. Training language models to follow instructions with human feedback. arXiv:2203.02155 (2022). InstructGPT — वह paper जिसने three-stage recipe को standard बनाया। इससे पहले Christiano et al. (arXiv:1706.03741) था, जिसने human comparisons से reward model सीखना introduce किया, और Stiennon et al. (arXiv:2009.01325) था, जिसने इसे summarisation पर लागू किया। ↩
Rafailov, R., Sharma, A., Mitchell, E., Ermon, S., Manning, C. D. and Finn, C. Direct Preference Optimization: Your Language Model is Secretly a Reward Model. arXiv:2305.18290 (2023). reward model हटाने वाली derivation section 4 में है और पूरी पढ़ने लायक है; यह अपनी reputation से छोटी है। ↩
Shao, Z. et al. DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models. arXiv:2402.03300 (2024). section 4.1 में GRPO introduce करता है। ↩
Bai, Y. et al. Constitutional AI: Harmlessness from AI Feedback. arXiv:2212.08073 (2022). ↩
Zhou, C. et al. LIMA: Less Is More for Alignment. arXiv:2305.11206 (2023). ↩
Hu, E. J. et al. LoRA: Low-Rank Adaptation of Large Language Models. arXiv:2106.09685 (2021). ↩
Dettmers, T., Pagnoni, A., Holtzman, A. and Zettlemoyer, L. QLoRA: Efficient Finetuning of Quantized LLMs. arXiv:2305.14314 (2023). ↩

पहला stage: इसे दिखाना कि जवाब कैसा दिखता है

दूसरा stage, और वह समस्या जिसे हल करने के लिए यह है

reward model, और यह सच में क्या सीखता है

Reward hacking, मापा हुआ

KL penalty वास्तव में क्या देती है

PPO, और DPO ने उसे क्यों खा लिया

alignment tax, और वह सवाल जिसका जवाब किसी ने नहीं दिया

आगे यह कहाँ जाता है

Sources and method

संदर्भ

मॉडल चुनने का काम LIA पर छोड़ने के लिए तैयार हैं?