छोटे और ऑन-डिवाइस मॉडल्सएडवांस्डपाठ 2317 मिनट का पाठ

किसी एक काम के लिए छोटे मॉडल को फाइन-ट्यून करना

फाइन-ट्यूनिंग एक छोटे मॉडल को एक खास काम सिखाती है। जानें कि यह कब काम आती है, डेटा कैसे तैयार करें, LoRA और QLoRA एक ही GPU पर कैसे फिट होते हैं, और पहले व बाद के नतीजे कैसे मापें।

✦ ट्यूटर से पूछें 🧪 लैब · 45 min 📝 पाठ का टेस्ट

स्पीड

पाठ वीडियो में

60 सेकंड में

किसी एक काम के लिए छोटे मॉडल को फाइन-ट्यून करना

फाइन-ट्यूनिंग एक छोटे मॉडल को एक खास काम सिखाती है। जानें कि यह कब काम आती है, डेटा कैसे तैयार करें, LoRA और QLoRA एक ही GPU पर कैसे फिट होते हैं, और पहले व बाद के नतीजे कैसे…

1/5

आसान शब्दों में

मिठाई की दुकान पर आया नया कैशियर पैसे गिनना पहले से जानता है। दुकान का मालिक उसे सिर्फ अपनी दुकान के सामान और उनके दाम सिखाता है। वे दोबारा स्कूल नहीं जाते। फाइन-ट्यूनिंग का मतलब है उस मॉडल को दुकान का काम सिखाना जो भाषा पहले से जानता है।

फाइन-ट्यूनिंग का मतलब है पहले से बने मॉडल को अपने उदाहरणों पर थोड़ा और ट्रेन करना, ताकि वह किसी एक काम में बेहतर हो सके। छोटे मॉडल्स के लिए, यह आपके काम में "ठीक-ठाक" चलने वाले आम मॉडल को भरोसेमंद बना सकता है, बिल्कुल उसी फॉर्मेट में जो आपको चाहिए।

पहले इन्हें आज़माएँ

1
बेहतर प्रॉम्प्ट्स
प्रॉम्प्ट में साफ निर्देश और कुछ उदाहरण। बदलने में सबसे सस्ते और तेज़।
2
रिट्रीवल (RAG)
अगर मॉडल के पास तथ्य (facts) नहीं हैं, तो उसे सही दस्तावेज़ दें। बहुत सारे नए तथ्य जोड़ने के लिए फाइन-ट्यूनिंग सही तरीका नहीं है।
3
कोई दूसरा मॉडल
हो सकता है कोई दूसरा छोटा मॉडल उस काम को पहले से ही अच्छे से कर लेता हो।
4
फिर फाइन-ट्यून करें
जब आपको ऐसा तय फॉर्मेट, स्टाइल या हुनर चाहिए जो सिर्फ प्रॉम्प्ट से भरोसेमंद तरीके से न मिल पा रहा हो।

फाइन-ट्यून करने की अच्छी वजहें	कमज़ोर वजहें
आउटपुट हर बार एक सख्त फॉर्मेट में ही आना चाहिए	आप चाहते हैं कि मॉडल आपकी कंपनी की पूरी विकी सीख ले
बहुत सारे उदाहरणों वाला कोई खास क्लासिफिकेशन या एक्सट्रैक्शन का काम	आपके पास सिर्फ दस उदाहरण हैं
किसी एक काम के लिए एक बड़े और महंगे मॉडल की जगह छोटा मॉडल इस्तेमाल करना है	प्रॉम्प्टिंग को अभी ठीक से आज़माया ही नहीं गया है
कोई खास टोन या किसी क्षेत्र का खास अंदाज़	काम हर हफ्ते बदल जाता है

डेटा तैयार करना

फॉर्मेट: कई टूल्स JSON Lines स्वीकार करते हैं, जिसमें हर लाइन पर एक उदाहरण होता है, अक्सर चैट मैसेज की तरह जिसमें एक यूज़र का टर्न और एक सटीक असिस्टेंट का टर्न होता है।
मात्रा से बेहतर गुणवत्ता: कुछ सौ साफ, अलग-अलग तरह के और सही उदाहरण अक्सर हज़ारों खराब उदाहरणों से बेहतर होते हैं।
असली तरह का डेटा शामिल करें: छोटे और बड़े इनपुट्स, टाइपिंग की गलतियाँ, हिंग्लिश और दूसरी मिली-जुली भाषाएँ शामिल करें, अगर आपके यूज़र्स उसी तरह लिखते हैं।
पहले ही अलग बाँट लें: ट्रेनिंग से पहले एक टेस्ट सेट अलग रख लें, और उस पर कभी ट्रेन न करें।
प्राइवेसी: नाम, फोन नंबर, आधार जैसे नंबर और दूसरा निजी डेटा हटा दें, जब तक कि आपके पास कोई कानूनी वजह और मंज़ूरी न हो।

Python: clean, de-duplicate and split a JSONL dataset (standard library)python

import json, random

def load(path):
    with open(path, encoding="utf-8") as f:
        return [json.loads(line) for line in f if line.strip()]

rows = load("examples.jsonl")          # each row: {"input": "...", "output": "..."}
seen, clean = set(), []
for r in rows:
    key = r["input"].strip().lower()
    if key and r.get("output") and key not in seen:
        seen.add(key)
        clean.append(r)

random.seed(42)
random.shuffle(clean)
n_test = max(20, len(clean) // 10)
test, train = clean[:n_test], clean[n_test:]

for name, part in (("train.jsonl", train), ("test.jsonl", test)):
    with open(name, "w", encoding="utf-8") as f:
        for r in part:
            f.write(json.dumps(r, ensure_ascii=False) + "\n")
print(f"{len(rows)} rows -> {len(clean)} unique -> {len(train)} train, {len(test)} test")

कम बजट में LoRA और QLoRA

LoRA मॉडल को फ्रीज़ कर देता है और उसकी कुछ लेयर्स के साथ छोटे अतिरिक्त मैट्रिसेस (matrices) को ट्रेन करता है (देखें "स्टेप 16 · LoRA, वह रास्ता जो ज़्यादातर लोग चुनते हैं")। QLoRA इससे भी आगे जाता है: यह फ्रीज़ किए गए बेस मॉडल को 4-बिट में लोड करता है और उसके ऊपर LoRA अडैप्टर्स को ट्रेन करता है। इससे मेमोरी की बहुत बचत होती है, जिससे एक छोटे मॉडल को अक्सर एक आम GPU पर या कुछ नोटबुक सर्विसेज़ के मुफ्त GPU टियर पर फाइन-ट्यून किया जा सकता है। फ्री टियर में समय और इस्तेमाल की सीमाएँ बदलती रहती हैं, इसलिए मौजूदा नियम ज़रूर देखें और अपना काम बार-बार सेव करते रहें।

आम ओपन टूल्स में Hugging Face की transformers, peft और trl लाइब्रेरीज़, और 4-बिट लोडिंग के लिए bitsandbytes शामिल हैं। इनके APIs नए वर्ज़न के साथ बदलते रहते हैं, इसलिए पुराने ब्लॉग पोस्ट देखने के बजाय उनके ताज़ा डॉक्यूमेंटेशन को देखें।

पहले और बाद का फ़र्क मापें

1
बेसलाइन
टेस्ट सेट पर बेस मॉडल को (अपने सबसे अच्छे प्रॉम्प्ट के साथ) चलाएँ। उसका स्कोर नोट करें।
2
ट्रेन करें
सिर्फ ट्रेनिंग सेट पर ही फाइन-ट्यून करें। सेटिंग्स और डेटा के वर्ज़न के नोट्स रखें।
3
फिर से टेस्ट करें
फाइन-ट्यून किए गए मॉडल को उसी टेस्ट सेट पर, उसी स्कोरिंग के साथ चलाएँ।
4
साइड इफेक्ट्स जाँचें
कुछ सामान्य सवाल और सेफ़्टी प्रॉम्प्ट्स आज़माएँ। क्या कुछ बिगड़ा तो नहीं?
5
फैसला लें
इसे तभी रखें जब यह उस काम में बेसलाइन से साफ तौर पर बेहतर हो और इसने किसी ज़रूरी चीज़ को न बिगाड़ा हो।

सावधान रहें

ओवरफ़िटिंग (overfitting) पर नज़र रखें: ट्रेनिंग लॉस कम होता जाता है लेकिन टेस्ट के नतीजे सुधरने बंद हो जाते हैं या खराब होने लगते हैं। इसका मतलब है कि मॉडल काम सीखने के बजाय उदाहरणों को रट रहा है। कम ट्रेनिंग राउंड्स या ज़्यादा अलग-अलग तरह का डेटा आमतौर पर इसमें मदद करता है।

इसे आज़माएँ। अपनी पसंद के किसी काम के लिए, अपनी मनचाही फॉर्मेट में 10 इनपुट और आउटपुट के जोड़े लिखें। क्या आउटपुट का फॉर्मेट सभी 10 में पूरी तरह एक जैसा है?

और देखें और पढ़ें

LoRA: Low-Rank Adaptation of Large Language ModelsarXiv · paper QLoRA: Efficient Finetuning of Quantized LLMsarXiv · paper

लैब

एक खास काम के लिए साफ, अलग-अलग हिस्सों में बँटा डेटासेट और पहले-और-बाद के मूल्यांकन की योजना।

~45 min

समस्या

काम: "किराना दुकान के वॉट्सऐप ऑर्डर मैसेज से सामान, मात्रा और डिलीवरी की तारीख को JSON के रूप में निकालना।"

कम से कम 40 असली जैसे, बनाए गए ऑर्डर मैसेज उसी तरह लिखें जैसे लोग असल में टाइप करते हैं (अंग्रेज़ी, हिंग्लिश, शॉर्ट फॉर्म, स्पेलिंग की गलतियाँ), और हर एक के साथ सही JSON आउटपुट दें।
उन्हें JSONL के रूप में सेव करें और पाठ से डेटा की सफाई और विभाजन वाली स्क्रिप्ट चलाएँ।
स्कोरिंग का एक नियम लिखें: उदाहरण के लिए, हर बिल्कुल सही फील्ड के लिए 1 अंक।
टेस्ट सेट पर एक अच्छे प्रॉम्प्ट के साथ एक छोटा लोकल मॉडल चलाएँ और बेसलाइन स्कोर नोट करें, या कागज़ पर लिखें कि आप इसे कैसे करेंगे।
अपनी फाइन-ट्यूनिंग योजना लिखें: बेस मॉडल (लाइसेंस की जाँच के साथ), LoRA या QLoRA, आप कहाँ ट्रेन करेंगे, और किस स्कोर के आने पर इसे रखना फायदेमंद होगा।

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

रन करने के लिए Ctrl + Enter दबाएं

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

आपका काम तब पूरा होगा जब

डेटासेट में अलग-अलग तरह के, असली जैसे मैसेज हैं, जिनमें मिली-जुली भाषा वाला टेक्स्ट भी शामिल है
किसी भी ट्रेनिंग या प्रॉम्प्ट ट्यूनिंग से पहले टेस्ट सेट को अलग कर लिया गया था
उसी स्कोरिंग नियम के साथ, एक बेसलाइन स्कोर मापा गया है या उसकी साफ योजना बनाई गई है
योजना में जाँचे गए लाइसेंस वाले बेस मॉडल का नाम है और उसे रखने या हटाने का साफ नियम है

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1आपने टेस्ट सेट को देखते हुए अपने प्रॉम्प्ट को कई बार ट्यून किया, और फिर फाइन-ट्यून किया। आपकी यह तुलना सही क्यों नहीं हो सकती, और आप इसे कैसे ठीक करेंगे?दिखाएं

टेस्ट सेट पर प्रॉम्प्ट को ट्यून करके, आपने इसे कुछ हद तक उन उदाहरणों के हिसाब से ढाल लिया है, इसलिए नए डेटा की तुलना में बेसलाइन स्कोर बहुत ज़्यादा या बहुत कम हो सकता है। तीन हिस्से रखें: एक ट्रेनिंग सेट, प्रॉम्प्ट और सेटिंग्स आज़माने के लिए एक डेवलपमेंट सेट, और एक टेस्ट सेट जिसे आप सिर्फ आखिर में अंतिम तुलना के लिए इस्तेमाल करते हैं।

Q2एक फाइन-ट्यून किया गया छोटा मॉडल, लंबे प्रॉम्प्ट वाले बड़े मॉडल से सस्ता क्यों हो सकता है, भले ही दोनों सही जवाब देते हों?दिखाएं

निर्देशों और उदाहरणों से भरे लंबे प्रॉम्प्ट वाले बड़े मॉडल में हर रिक्वेस्ट पर उन सभी इनपुट टोकन्स के पैसे लगते हैं, और बड़े मॉडल पर हर टोकन ज़्यादा महंगा होता है। फाइन-ट्यून किया गया छोटा मॉडल फॉर्मेट सीख चुका होता है, इसलिए उसे छोटे प्रॉम्प्ट की ज़रूरत होती है, और हर टोकन को प्रोसेस करना सस्ता होता है। ज़्यादा ट्रैफ़िक होने पर यह फ़र्क बहुत बड़ा हो सकता है। फिर भी आपको इसे ट्रेन करने और चलाने की लागत जोड़नी होगी।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

क्या मैं बिना GPU के फाइन-ट्यून कर सकता हूँ?

बहुत छोटे मॉडल्स के लिए CPU पर ट्रेनिंग संभव है, लेकिन यह आमतौर पर बहुत धीमी होती है। ज़्यादातर लोग एक सिंगल GPU, मुफ्त नोटबुक टियर, या कुछ समय के लिए पेड रेंटल का इस्तेमाल करते हैं। प्लानिंग, डेटा तैयार करना और मूल्यांकन का काम किसी भी लैपटॉप पर किया जा सकता है।

क्या फाइन-ट्यूनिंग से मॉडल नए तथ्य सीख जाएगा?

थोड़े-बहुत, लेकिन भरोसेमंद तरीके से नहीं। यह फॉर्मेट, स्टाइल और किसी खास हुनर को सिखाने के लिए कहीं बेहतर है। बदलने वाले तथ्यों के लिए, जैसे कि कीमतें या नियम, रिट्रीवल का इस्तेमाल करें।

LoRA ट्रेनिंग के अंत में मुझे क्या मिलता है?

एक छोटी अडैप्टर फ़ाइल। आप इसे मूल बेस मॉडल के साथ लोड करते हैं। कुछ टूल्स इसे बेस मॉडल में मर्ज भी कर सकते हैं और फिर नतीजे को क्वांटाइज़ कर सकते हैं, उदाहरण के लिए लोकल इस्तेमाल के लिए GGUF में।

मेरा फाइन-ट्यून किया गया मॉडल सामान्य बातचीत में खराब हो गया। क्या यह सामान्य है?

ऐसा हो सकता है, खासकर सीमित डेटा या बहुत ज़्यादा ट्रेनिंग के साथ। अगर सामान्य बातचीत की क्षमता मायने रखती है, तो कुछ सामान्य उदाहरण भी मिलाएँ, कम समय के लिए ट्रेन करें, और अपने मूल्यांकन में हमेशा साइड इफेक्ट्स की जाँच करें।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें

किसी एक काम के लिए छोटे मॉडल को फाइन-ट्यून करना

किसी एक काम के लिए छोटे मॉडल को फाइन-ट्यून करना

पहले इन्हें आज़माएँ

बेहतर प्रॉम्प्ट्स

रिट्रीवल (RAG)

कोई दूसरा मॉडल

फिर फाइन-ट्यून करें

डेटा तैयार करना

कम बजट में LoRA और QLoRA

पहले और बाद का फ़र्क मापें

बेसलाइन

ट्रेन करें

फिर से टेस्ट करें

साइड इफेक्ट्स जाँचें

फैसला लें

और देखें और पढ़ें

समस्या

प्रैक्टिस लैब

आपका काम तब पूरा होगा जब

कठिन सवाल

अक्सर पूछे जाने वाले सवाल