LLM को फ़ाइन-ट्यून कैसे करें [और इसके बजाय RAG या प्रॉम्प्टिंग का इस्तेमाल कब करें]

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

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

अगर आप LLM के आउटपुट से संतुष्ट नहीं हैं, तो पहले अपने प्रॉम्प्ट और रिट्रीवल-ऑगमेंटेड जनरेशन (RAG) को बेहतर बनाएँ। फ़ाइन-ट्यूनिंग यह बदलती है कि LLM कैसे व्यवहार करता है। जब आपको उससे नई या मालिकाना (प्रोप्राइटरी) जानकारी का इस्तेमाल करवाना हो, तो आम तौर पर प्रॉम्प्टिंग और RAG बेहतर विकल्प होते हैं।

यहाँ जानिए कि LLM को चरण-दर-चरण कैसे फ़ाइन-ट्यून करें, फ़ाइन-ट्यूनिंग के मुख्य तरीके (LoRA और QLoRA) क्या हैं, और कौन-सी चुनौतियाँ और गलतियाँ इस प्रक्रिया को बिगाड़ सकती हैं।

LLM फ़ाइन-ट्यूनिंग क्या है और यह LLM प्री-ट्रेनिंग से कैसे अलग है

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

LLM प्री-ट्रेनिंग वह संसाधन-भारी चरण है जिससे बेस मॉडल तैयार होता है। यह मॉडल टेक्स्ट के एक व्यापक कॉर्पस से सीखता है, जिससे उसे सामान्य व्याकरण, तथ्य और तर्क-क्षमता तो मिलती है, लेकिन आपके टास्क के लिए कोई विशेषज्ञता नहीं।

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

LLM को कब फ़ाइन-ट्यून करें और कब इसके बजाय प्रॉम्प्टिंग या RAG का इस्तेमाल करें

LLM का प्रदर्शन बेहतर बनाने के लिए सीढ़ी-दर-सीढ़ी ऊपर बढ़ें: प्रॉम्प्टिंग -> RAG -> फ़ाइन-ट्यूनिंग।

ज़्यादा विस्तृत निर्देशों के साथ अपने प्रॉम्प्ट को बेहतर बनाएँ और मॉडल को अप-टू-डेट जानकारी देने के लिए RAG का इस्तेमाल करें। फ़ाइन-ट्यूनिंग का इस्तेमाल तभी करें जब प्रॉम्प्ट और रिट्रीवल में सुधार से काम न बने।

कब बेहतर प्रॉम्प्ट फ़ाइन-ट्यूनिंग से आगे निकल जाते हैं और कब वे काफ़ी नहीं होते

प्रॉम्प्टिंग सबसे तेज़ और सबसे सस्ता उपाय है। कई मामलों में, ज़्यादा सटीक और विस्तृत प्रॉम्प्ट से ही व्यवहार में मनचाहे बदलाव हासिल हो जाते हैं।

लेकिन लंबे प्रॉम्प्ट काम को धीमा और महँगा बना देते हैं, और मॉडल की मौजूदा सीमाओं को पार नहीं कर सकते।

संकेत कि प्रॉम्प्टिंग शायद अपनी सीमा तक पहुँच चुकी है:

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

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

कब मॉडल को फ़ाइन-ट्यून करने के बजाय RAG बेहतर विकल्प है

RAG यह बदलता है कि LLM क्या जानता है, जबकि LLM फ़ाइन-ट्यूनिंग यह बदलती है कि वह कैसे व्यवहार करता है। अगर कमी ज्ञान की है, खासकर ऐसे ज्ञान की जो अक्सर बदलता है या आपके अपने दस्तावेज़ों में मौजूद है, तो RAG ही जवाब है। अगर कमी व्यवहार की है, तो फ़ाइन-ट्यून करें।

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

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

RAG की कमी? यह बनाने और मेंटेन करने के लिए एक अतिरिक्त लेयर है, और इससे लेटेंसी बढ़ती है।

असल में, आपको अक्सर दोनों की ज़रूरत होगी। प्रोडक्शन सिस्टम फ़ाइन-ट्यून किए गए मॉडल को RAG के साथ जोड़ते हैं, एक का इस्तेमाल एक जैसे व्यवहार के लिए और दूसरे का मौजूदा तथ्यों के लिए करते हैं।

फ़ाइन-ट्यूनिंग की आम गलतियाँ, जोखिम और चुनौतियाँ

जब फ़ाइन-ट्यूनिंग सही टूल हो, तब भी इसकी अपनी लागतें और जोखिम होते हैं:

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

फ़ाइन-ट्यूनिंग के मुख्य तरीके

LLM फ़ाइन-ट्यूनिंग के मुख्य प्रकार इस बात में अलग होते हैं कि वे मॉडल का कितना हिस्सा बदलते हैं: फ़ुल फ़ाइन-ट्यूनिंग पूरे मॉडल को दोबारा ट्रेन करती है, जबकि LoRA और QLoRA जैसे पैरामीटर-एफ़िशिएंट फ़ाइन-ट्यूनिंग (PEFT) तरीके केवल कुछ वेट्स को अपडेट करते हैं। PEFT तरीकों में फ़ुल फ़ाइन-ट्यूनिंग की तुलना में मेमोरी का एक छोटा-सा हिस्सा ही लगता है, और सही सेटिंग्स के साथ ये उसके बराबर नतीजे दे सकते हैं।

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

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

कम रैंक पर, PEFT फ़ुल फ़ाइन-ट्यून की तुलना में कम सीखता है, लेकिन रैंक बढ़ाने और लर्निंग रेट को ट्यून करने से इंस्ट्रक्शन-ट्यूनिंग टास्क पर यह अंतर काफ़ी हद तक खत्म हो जाता है।

PEFT तरीकों में शामिल हैं:

• LoRA (लो-रैंक एडैप्टेशन): आम तौर पर शुरुआत इसी से होती है। यह मूल वेट्स को फ़्रीज़ कर देता है और जोड़े गए एडैप्टर पैरामीटर के एक छोटे सेट को ट्रेन करता है, जो अक्सर कुल का 1% से भी कम होता है, इसलिए यह एक ही कंज़्यूमर GPU पर चल जाता है।
• QLoRA (क्वांटाइज़्ड लो-रैंक एडैप्टेशन): यह LoRA लागू करने से पहले बेस मॉडल को 4-बिट प्रिसिज़न में कंप्रेस करता है, जिससे आप एक ही GPU पर बड़े मॉडल को फ़ाइन-ट्यून कर सकते हैं।

इनके अलावा, हम इंस्ट्रक्शन-ट्यूनिंग और प्रेफ़रेंस-ट्यूनिंग तरीकों का इस्तेमाल करते हैं, RLHF (Reinforcement Learning from Human Feedback) से लेकर Direct Preference Optimization (DPO) और Odds Ratio Preference Optimization (ORPO) जैसे हल्के विकल्पों तक, ताकि यह तय किया जा सके कि मॉडल निर्देशों का पालन कैसे करे और मानवीय प्राथमिकताओं के अनुरूप कैसे चले।

LLM को चरण-दर-चरण कैसे फ़ाइन-ट्यून करें

जब आप तय कर लें कि LLM को फ़ाइन-ट्यून करना ही सही फ़ैसला है, तो यह रहा वर्कफ़्लो।

बड़ा करें

चरण 1: टास्क तय करें और यह भी कि आप सफलता कैसे मापेंगे

तय करें कि आप LLM से कैसा व्यवहार चाहते हैं और आपको कैसे पता चलेगा कि वह हासिल हो गया।

वह खास काम बताएँ जो आप फ़ाइन-ट्यून किए गए मॉडल से करवाना चाहते हैं, जैसे सपोर्ट टिकट को वर्गीकृत करना, कॉन्ट्रैक्ट का एक तय फ़ॉर्मैट में सारांश बनाना, या अपनी कंपनी की स्टाइल में कोड जनरेट करना।

फिर सफलता को परिभाषित करें। आम विकल्पों में शामिल हैं:

• आउटपुट की वैधता: उदाहरण के लिए, क्या नतीजा मान्य JSON के रूप में पार्स होता है या आपकी ज़रूरत के Markdown ढाँचे से मेल खाता है?
• स्वचालित स्कोर: BLEU या ROUGE जैसे मेट्रिक इस्तेमाल करें, जो जनरेट किए गए टेक्स्ट की तुलना संदर्भ उत्तरों से करते हैं, या किसी लेबल किए गए सेट पर टास्क की सटीकता देखें।
• मानवीय रेटिंग: लहजे या मददगार होने जैसे गुणों के लिए स्कोर वाला या पास/फ़ेल रूब्रिक, जिन्हें कोई स्क्रिप्ट ठीक से स्कोर नहीं कर पाती।
• कठिन इनपुट पर विश्वसनीयता: क्या यह उन असामान्य इनपुट को संभाल पाता है जिन पर बेस मॉडल लड़खड़ा गया था?

चरण 2: अपना डेटासेट तैयार करें

फ़ाइन-ट्यून की सफलता डेटा की गुणवत्ता पर निर्भर करती है, इसलिए सही फ़ाइन-ट्यूनिंग डेटासेट जुटाने में मेहनत करें।

अपने डेटा को JSONL में इंस्ट्रक्शन/रिस्पॉन्स जोड़ों के रूप में फ़ॉर्मैट करें, जहाँ हर पंक्ति में इनपुट (और कोई भी संदर्भ) और ठीक वही आउटपुट हो जो आप वापस पाना चाहते हैं।

उदाहरण के लिए, सामान्य निर्देशों वाले Alpaca-cleaned डेटासेट या Databricks के Dolly जैसे सार्वजनिक डेटासेट देखें, या टास्क-विशिष्ट banking77 देखें, जिसमें 77 इंटेंट में लेबल की गई 13,000 से ज़्यादा असली सपोर्ट क्वेरी शामिल हैं।

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

अभी तक इनपुट/आउटपुट जोड़े नहीं हैं? अपने पास पहले से मौजूद डेटा से सेट बनाएँ, जैसे सपोर्ट टिकट और उनके सबसे अच्छे जवाब, या दस्तावेज़ और उनके सारांश।

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

अंत में डेटा को ट्रेनिंग, वैलिडेशन और टेस्ट सेट में बाँटें, ताकि आप उन उदाहरणों पर माप सकें जिन्हें मॉडल ने नहीं देखा है।

चरण 3: बेस मॉडल और तरीका चुनें

3 से 7 अरब पैरामीटर वाले किसी छोटे ओपन-सोर्स मॉडल और LoRA या QLoRA जैसे पैरामीटर-एफ़िशिएंट फ़ाइन-ट्यूनिंग तरीके से शुरुआत करें।

Llama, Mistral और Qwen जैसे ओपन मॉडल परिवार आपको एक मज़बूत बेस देते हैं जिसे आप खुद होस्ट कर सकते हैं, और PEFT तरीके हार्डवेयर की ज़रूरत कम रखते हैं: QLoRA बेस को 4-बिट में क्वांटाइज़ करता है, इसलिए 7B मॉडल को फ़ाइन-ट्यून करने के लिए सिर्फ़ 16-24GB का कंज़्यूमर कार्ड चाहिए। उसी मॉडल की फ़ुल फ़ाइन-ट्यूनिंग के लिए इससे कई गुना ज़्यादा मेमोरी चाहिए।

चरण 4: अपने ट्रेनिंग हाइपरपैरामीटर सेट करें

यहाँ LLM फ़ाइन-ट्यूनिंग के मुख्य पैरामीटर और शुरुआत के लिए सुझाई गई रेंज दी गई हैं:

• लर्निंग रेट यह नियंत्रित करता है कि वेट्स में हर अपडेट कितना बड़ा हो। Biderman et al. के 2024 के एक अध्ययन में पाया गया कि LoRA के लिए सबसे अच्छे रेट फ़ुल फ़ाइन-ट्यूनिंग की तुलना में लगभग दस गुना ज़्यादा थे, आम तौर पर 5e-5 से 5e-4, जबकि फ़ुल फ़ाइन-ट्यूनिंग के लिए 1e-5 से 5e-5। अध्ययन 1e-5 से 5e-4 तक स्वीप करने और उस सबसे ऊँचे मान का इस्तेमाल करने की सलाह देता है जिस पर ट्रेनिंग स्थिर रहे।
• बैच साइज़ यह है कि हर वेट अपडेट से पहले मॉडल कितने उदाहरणों से सीखता है। एक GPU पर, प्रति-डिवाइस 1 से 8 का छोटा बैच और ग्रेडिएंट एक्यूमुलेशन इस्तेमाल करें, ताकि लगभग 16 से 64 का प्रभावी बैच मिल सके।
• एपॉक की संख्या यह बताती है कि मॉडल पूरा डेटासेट कितनी बार देखता है। मॉडल को खास टास्क करने के लिए ट्रेन करते समय 1-3 एक अच्छा सामान्य नियम है, लेकिन LoRA रन को अक्सर इससे ज़्यादा की ज़रूरत होती है।
• LoRA रैंक (r) अडैप्टर की क्षमता तय करती है, यानी वह कितना सीख सकता है। आसान टास्क के लिए 8 से 32 से शुरू करें और कठिन टास्क के लिए इसे बढ़ाएँ: ऊपर उद्धृत Biderman et al. के LoRA अध्ययन में, कोड पर 7B मॉडल की इंस्ट्रक्शन-ट्यूनिंग करते समय फ़ुल फ़ाइन-ट्यूनिंग की बराबरी के लिए रैंक 256 की ज़रूरत पड़ी, जबकि गणित पर रैंक 64 उसके क़रीब पहुँच गई।
• अधिकतम सीक्वेंस लंबाई वह सबसे लंबा इनपुट है जिसे रन प्रोसेस करेगा। इसे मॉडल की कॉन्टेक्स्ट विंडो की सीमा के भीतर इतना रखें कि आपके सबसे लंबे उदाहरण इसमें आ जाएँ, क्योंकि इससे लंबा कुछ भी काट दिया जाता है।
• वॉर्मअप और शेड्यूल यह नियंत्रित करते हैं कि रन के दौरान लर्निंग रेट कैसे बढ़ता और बदलता है। छोटा वॉर्मअप और कोसाइन डिके आम डिफ़ॉल्ट हैं। हालाँकि, Pareja et al. के छोटे-मॉडल अध्ययन में पाया गया कि वॉर्मअप हटाने से अंतिम स्कोर पर कोई बुरा असर नहीं पड़ा।

इन्हें तय सेटिंग्स नहीं, बल्कि स्वीप के शुरुआती बिंदु मानें।

चरण 5: ट्रेन करें और लॉस मॉनिटर करें

ट्रेनिंग चलने के दौरान, ट्रेनिंग और वैलिडेशन लॉस कर्व पर नज़र रखें, ताकि पता चले कि यह काम कर रही है या नहीं।

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

अगर ट्रेनिंग लॉस और वैलिडेशन लॉस साथ-साथ घटते हैं, तो मॉडल सामान्यीकरण करना सीख रहा है। अगर ट्रेनिंग लॉस घटता रहता है लेकिन वैलिडेशन लॉस स्थिर हो जाता है या बढ़ने लगता है, तो मॉडल पैटर्न सीखने के बजाय ट्रेनिंग सेट को रट रहा है (ओवरफ़िटिंग)।

बड़ा करें

चरण 6: मूल्यांकन करें, फिर डिप्लॉय करें

कम ट्रेनिंग लॉस सही आउटपुट की गारंटी नहीं देता, इसलिए फ़ाइन-ट्यून किए गए मॉडल का आकलन उन मानदंडों पर करें जो आपने चरण 1 में तय किए थे।

जब मॉडल इसमें पास हो जाए, तो डिप्लॉय करने के आपके पास दो तरीके हैं:

• अडैप्टर को बेस मॉडल के ऊपर सर्व करें और रनटाइम पर दोनों को लोड करें; इससे अडैप्टर को बदलना आसान रहता है।
• अडैप्टर को बेस वेट्स में मर्ज करें, ताकि एक स्टैंडअलोन मॉडल मिले जिसे होस्ट करना आसान हो।

अपने LLM को ताज़ा जानकारी तक पहुँच देने के लिए Perplexity का इस्तेमाल करें

जब आप मॉडल के व्यवहार को अपनी ज़रूरतों के हिसाब से ढालना चाहते हैं, तब फ़ाइन-ट्यूनिंग सही विकल्प है।

अगर आपके मॉडल को मौजूदा जानकारी चाहिए, ख़ासकर ऐसी जानकारी जो तेज़ी से बदलती है, तो आपको RAG या किसी भरोसेमंद थर्ड-पार्टी सर्च टूल की ज़रूरत है।

कस्टम रिट्रीवल स्टैक मालिकाना डेटासेट के लिए सबसे अच्छा काम करता है, जैसे आपकी इंटरनल विकी, ग्राहक सहायता का इतिहास, अनुबंध या प्रोडक्ट डॉक्स।

जब आप जिस जानकारी का इस्तेमाल करना चाहते हैं वह सार्वजनिक हो, तो कस्टम रिट्रीवल लेयर बनाने की ज़रूरत नहीं है। Perplexity एक आंसर इंजन है जो लाइव वेब इंडेक्स से इनलाइन, क्लिक करने योग्य उद्धरणों के साथ जवाब देता है। इसका Agent API वेब पर आधारित, उद्धरण-सहित ये जवाब एक ही कॉल में देता है, ताकि आपका ऐप मौजूदा स्रोतों का इस्तेमाल कर सके।

LLM फ़ाइन-ट्यूनिंग के बारे में अक्सर पूछे जाने वाले सवाल

क्या आप किसी LLM को मुफ़्त में फ़ाइन-ट्यून कर सकते हैं?

हाँ, आप किसी छोटे ओपन LLM को मुफ़्त में फ़ाइन-ट्यून कर सकते हैं। उदाहरण के लिए, Google Colab के फ़्री टियर में 3B से 8B मॉडल पर QLoRA चलाने लायक GPU मिल जाता है, जो किसी केंद्रित टास्क के लिए काफ़ी है। जब आपको फ़्री टियर की क्षमता से ज़्यादा मेमोरी, लंबे रन या बड़े बेस मॉडल की ज़रूरत होती है, तब आपको भुगतान करना पड़ता है।

क्या आपको अपने GPU की ज़रूरत है, या आप क्लाउड में फ़ाइन-ट्यून कर सकते हैं?

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

LLM को फ़ाइन-ट्यून करने में कितना समय लगता है?

किसी छोटे LLM के लिए, डेटासेट के आकार और हार्डवेयर के आधार पर, रन कुछ मिनटों से लेकर कुछ घंटों में पूरा हो सकता है। उदाहरण के लिए, Oumi ने अपने होस्टेड प्लेटफ़ॉर्म पर 0.8B मॉडल को एक घंटे से थोड़े ज़्यादा समय में पूरी तरह फ़ाइन-ट्यून किया।

बड़े मॉडल या दसियों हज़ार उदाहरण इस समय को एक दिन या उससे ज़्यादा तक ले जाते हैं: एक 40GB GPU पर 7B मॉडल के साथ Emburse के LoRA रन में 5,000 उदाहरणों के लिए 8 घंटे और 50,000 के लिए लगभग 30 घंटे लगे।

क्या डेटा बदलने के साथ आप फ़ाइन-ट्यून किए गए मॉडल को अपडेट करते रह सकते हैं?

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