फ़ाइन-ट्यूनिंग
फ़ाइन-ट्यूनिंग का अर्थ है एक मौजूदा मॉडल लेना और अपने स्वयं के उदाहरणों पर इसे प्रशिक्षित करना जारी रखना, ताकि इसका डिफ़ॉल्ट व्यवहार आप जो चाहते हैं उसकी ओर स्थानांतरित हो। यह अध्याय इस बात का कार्यकारी चित्र है कि यह क्या बदलता है, यह किस लिए अच्छा है, और कब आप इसे प्रॉम्पट या पुनर्प्राप्ति के बजाय चुनें।
प्रशिक्षण वास्तव में क्या करता है
फ़ाइन-ट्यूनिंग क्या बदलती है यह देखने के लिए, यह जानना मदद करता है कि एक मॉडल कहाँ से आता है। एक मॉडल दो व्यापक चरणों में बनाया जाता है।
पहला चरण प्रीट्रेनिंग है: मॉडल बड़ी मात्रा में पाठ पढ़ता है और अगले टोकन की भविष्यवाणी करना सीखता है, बार-बार, जब तक कि व्याकरण, तथ्य, और तर्क के पैटर्न इसमें एक दुष्प्रभाव के रूप में settle न हो जाएं। जो निकलता है वह एक आधार मॉडल है, प्रवाह से भरपूर लेकिन unfocused। यह आपके पाठ को जारी रखेगा, लेकिन इसे सहायक सहायक बनने के लिए नहीं सिखाया गया है जो प्रश्नों के उत्तर देता है।
दूसरा चरण पोस्ट-ट्रेनिंग है: आधार मॉडल को अच्छी प्रतिक्रियाओं के curated उदाहरणों पर, साथ ही मानव प्रतिक्रिया के साथ आगे प्रशिक्षित किया जाता है कि कौन से उत्तर बेहतर हैं। यह एक कच्चे पाठ प्रेडिक्टर को निर्देश-अनुगामी सहायक में बदल देता है जिससे आप वास्तव में बात करते हैं। API से जो मॉडल आप कॉल करते हैं वह दोनों से गुजर चुका है।
दोनों चरण एक ही तंत्र से काम करते हैं: मॉडल को उदाहरण दिखाएं और इसके आंतरिक संख्याओं को, इसके पैरामीटर या weights को nudge करें, ताकि इसकी भविष्यवाणियां उन उदाहरणों की ओर बढ़ें। प्रशिक्षण भविष्यवाणी का अभ्यास है जो मॉडल को स्थायी रूप से बदल देता है।
फ़ाइन-ट्यूनिंग क्या है
फ़ाइन-ट्यूनिंग वह दूसरा चरण का एक छोटा, targeted version है, आप द्वारा run। आप एक मॉडल लेते हैं जो पहले से trained है और अपने स्वयं के उदाहरणों के एक set पर इसे प्रशिक्षित करना जारी रखते हैं, प्रत्येक एक input है जो output के साथ paired है जिसे आप चाहते हैं कि यह produce करे। पर्याप्त उदाहरणों के बाद, मॉडल के weights shift हो जाते हैं ताकि इस तरह की प्रतिक्रिया इसका default बन जाए, बिना आपसे हर बार prompt में इसके लिए पूछे।
प्रॉम्पटिंग और RAG से असली अंतर यह है कि change कहां रहता है। प्रॉम्पटिंग और RAG मॉडल को frozen रखते हैं और इसे उस context के माध्यम से steer करते हैं जो आप call के समय supply करते हैं। फ़ाइन-ट्यूनिंग मॉडल को itself change करती है, इसलिए नया व्यवहार baked in है और short prompt के साथ भी दिखाई देता है। आप runtime में बेहतर instructions नहीं दे रहे हैं; आप एक ऐसा मॉडल ship कर रहे हैं जो पहले से ही उस तरीके से leans है जो आप चाहते हैं।
व्यवहार में आप provider को example conversations की एक file hand करते हैं, यह एक training job run करता है, और यह आपको एक नया model id देता है। आप उस id को किसी भी अन्य मॉडल की तरह exactly कॉल करते हैं, सिवाय इसके कि इसके उत्तर अब वह reflect करते हैं जिस पर आपने प्रशिक्षण दिया है। फ़ाइन-ट्यूनिंग मॉडल को व्यवहार ले जाती है, प्रॉम्पटिंग और RAG एक frozen को steer करते हैं।
यह किस चीज में अच्छा है, और किस में नहीं
फ़ाइन-ट्यूनिंग अपनी जगह अर्जित करती है जब आपको एक consistent behavior की जरूरत है जिसे एक prompt narrow down करने के लिए संघर्ष करता है: हर बार precise output format, एक specific tone या house style, या classification जैसा narrow task reliably हजारों calls में। यह calls को भी सस्ता और तेजी से बना सकता है, क्योंकि behavior जिसे आप अन्यथा long prompt में spell out करेंगे वह मॉडल में baked है, इसलिए आपके prompts छोटे हो जाते हैं।
जहां यह गिरता है वह knowledge है। फ़ाइन-ट्यूनिंग एक मॉडल को नए तथ्य सिखाने में poor है, और तथ्यों में जो change करते हैं worse। प्रशिक्षण उदाहरण blur general patterns में rather than exact, lookup-able entries को store किए जाते हैं, इसलिए एक fine-tuned मॉडल अभी भी details invent करता है और अभी भी stale हो जाता है moment जब आपकी information update होती है। हर बार जब एक price या policy change होता है retraining slow और expensive है। जब समस्या है "मॉडल को X नहीं पता है", जवाब almost always RAG है, not fine-tuning।
Rule of thumb: form change करने के लिए fine-tune करें, facts add करने के लिए नहीं। मॉडल को कैसे answer करना है सिखाएं, और retrieval को यह handle करने दें कि क्या answer करना है।
Prompt, RAG, या fine-tune?
Most of the समय आप यहां start नहीं करते। तीन techniques एक ladder form करते हैं, cheapest and fastest to change first:
- Prompting। हमेशा यह पहले try करें। यह instant iterate करने में, कोई extra cost नहीं, और एक clear prompt कुछ उदाहरणों के साथ अधिक solve करता है जो लोग expect करते हैं। यदि आपने prompt को काम नहीं किया है, आप fine-tune करने के लिए ready नहीं हैं।
- RAG। इसे reach करें जब gap knowledge है: मॉडल को तथ्यों की जरूरत है जो उसके पास नहीं हैं, या जो समय के साथ change होते हैं। RAG उन्हें question time पर supply करता है model को touch किए बिना।
- Fine-tuning। इसे reach करें जब gap behavior है rather than knowledge और prompting इसे consistent enough नहीं बना सकता, या जब आपके prompts इतने long हो गए हों कि instructions को मॉडल में bake करना scale पर सस्ता और तेजी से है।
वे exclusive नहीं हैं, और strongest systems उन्हें combine करते हैं: अपने format और tone के लिए एक मॉडल को fine-tune करें, फिर runtime पर इसे current facts feed करने के लिए RAG use करें। Training से behavior, retrieval से knowledge।
तो fine-tune करने से पहले एक quick test। क्या आप एक better prompt के साथ वहां पहुंच सकते हैं? फिर वह करें। क्या gap missing knowledge है? तब यह RAG है।
Ladder को climb करें; fine-tuning last rung है, not first। केवल जब prompt पहले से ही सही है, facts पहले से available हैं, और मॉडल अभी भी consistently enough behave नहीं करेगा तब fine-tuning tool है जो fits।
व्यवहार में
Fine-tuning data कुछ exotic नहीं है। प्रत्येक उदाहरण एक short conversation है सटीक shape में जो आप runtime पर भेजते हैं, answer के साथ ending जिसे आप चाहते हैं कि मॉडल ने दिया होता:
# कुछ यहां shown हैं; एक real dataset सैकड़ों से हजारों उदाहरण हैं,
# runtime पर आप expect करते हैं inputs की पूरी range को covering करते हुए।
training_examples = [
{"messages": [
{"role": "system", "content": "टिकट की तात्कालिकता को low, medium, या high के रूप में वर्गीकृत करें।"},
{"role": "user", "content": "मुझे इस सप्ताह दो बार charge किया गया और मुझे इसे आज ठीक करना है।"},
{"role": "assistant", "content": "high"},
]},
{"messages": [
{"role": "system", "content": "टिकट की तात्कालिकता को low, medium, या high के रूप में वर्गीकृत करें।"},
{"role": "user", "content": "क्या कहीं एक dark mode setting है?"},
{"role": "assistant", "content": "low"},
]},
# ...
]आप इन्हें एक file में save करते हैं, provider के साथ एक training job start करते हैं, और इसे खत्म होने का wait करते हैं। जो वापस आता है वह एक नया model id है, जिसे आप फिर किसी अन्य मॉडल की तरह exactly कॉल करते हैं:
# Fine-tuned मॉडल एक और id है; बाकी सब कुछ unchanged है।
response = client.chat.completions.create(
model="your-org/urgency-classifier-v1",
messages=[
{"role": "system", "content": "टिकट की तात्कालिकता को low, medium, या high के रूप में वर्गीकृत करें।"},
{"role": "user", "content": "Export button कुछ नहीं करता जब मैं इसे click करता हूं।"},
],
)
# response.choices[0].message.content -> "low" (label केवल, behavior जिसे आपने trained किया)Win यह है कि behavior अब मॉडल में रहती है। Instructions छोटे हो सकते हैं, format हजारों calls में hold होता है, और आपको prompt को grow करना नहीं पड़ा वहां पहुंचने के लिए। Cost सब कुछ है जो इसके around है: आपको एक quality dataset की जरूरत है, एक training run, और एक fresh job हर बार जब आप change करना चाहते हैं जो उसने सीखा, जो exactly यह है कि क्यों यह ladder के bottom पर बैठता है। Upload उदाहरण, एक model id पाएं, इसे किसी अन्य की तरह कॉल करें।
यह shape करने के तरीके के अंतिम भाग है कि एक मॉडल क्या जानता है और कैसे उत्तर देता है, सभी जिसे यह एक desk पर text predict करने देता है जिसे आपने arranged किया। अगले अध्याय इसे act करने की ability देते हैं: Tool use में मॉडल आपके स्वयं के functions को calls करता है, और फिर agent के रूप में एक loop में उन्हें run करता है।