LLM फाइन-ट्यून कसे करावे [आणि त्याऐवजी RAG किंवा प्रॉम्प्टिंग केव्हा वापरावे]

लार्ज लँग्वेज मॉडेल (LLM) फाइन-ट्यून करणे म्हणजे आधीच प्रशिक्षित (pre-trained) LLM ला एका लहान, विशिष्ट कार्यासाठीच्या डेटासेटवर अधिक परिष्कृत करणे, जेणेकरून केवळ प्रॉम्प्टिंगने मिळू न शकणारे आउटपुट ते देऊ शकेल.

फाइन-ट्यूनिंगमध्ये तुम्हाला हवे असलेले वर्तन दाखवणाऱ्या इनपुट/आउटपुट उदाहरण जोड्या गोळा करणे, मॉडेलचे वेट्स त्यांच्या दिशेने सरकवणारे प्रशिक्षण पास चालवणे आणि मूळ मॉडेलच्या आउटपुटशी निकालाची तुलना करून तपासणे यांचा समावेश होतो. LoRA सारख्या पॅरामीटर-एफिशियंट पद्धतींमुळे हे एकाच GPU वर चालवण्याइतके स्वस्त होते.

LLM च्या आउटपुटबाबत तुम्ही समाधानी नसल्यास, आधी तुमचे प्रॉम्प्ट्स आणि रिट्रीव्हल-ऑगमेंटेड जनरेशन (RAG) सुधारा. फाइन-ट्यूनिंगमुळे LLM चे वर्तन बदलते. जेव्हा त्याने ताजी किंवा मालकीची (proprietary) माहिती वापरावी अशी तुमची गरज असते, तेव्हा प्रॉम्प्टिंग आणि RAG हे सहसा अधिक चांगले पर्याय ठरतात.

LLM टप्प्याटप्प्याने कसे फाइन-ट्यून करायचे, फाइन-ट्यूनिंगच्या मुख्य पद्धती (LoRA आणि QLoRA), आणि ही प्रक्रिया बिघडवू शकणारी आव्हाने व चुका यांची माहिती येथे दिली आहे.

LLM फाइन-ट्यूनिंग म्हणजे काय आणि ते LLM प्री-ट्रेनिंगपेक्षा कसे वेगळे आहे

LLM प्री-ट्रेनिंग प्रचंड मजकूर संग्रहावर (corpus) अगदी सुरुवातीपासून मॉडेलची सामान्य भाषिक क्षमता घडवते, तर LLM फाइन-ट्यूनिंग आधीच प्रशिक्षित मॉडेलला एका विशिष्ट कामासाठी लहान डेटासेटवर समायोजित करते.

LLM प्री-ट्रेनिंग हा भरपूर संसाधने लागणारा टप्पा आहे, ज्यातून बेस मॉडेल तयार होते. ते व्यापक मजकूर संग्रहातून शिकते, ज्यामुळे त्याला सामान्य व्याकरण, तथ्ये आणि कारणमीमांसा मिळते, पण तुमच्या कामासाठी कोणतेही विशेषीकरण मिळत नाही.

LLM फाइन-ट्यूनिंग लहान, निवडक (curated) डेटासेटवर बेस मॉडेलचे प्रशिक्षण पुढे सुरू ठेवते, जेणेकरून ते विशिष्ट कार्य किंवा वापराच्या प्रकरणासाठी अपेक्षित आउटपुट देईल. उदाहरणार्थ, सुसंगत फॉरमॅट, ब्रँडची शैली किंवा टोन, डोमेन-विशिष्ट पॅटर्न, किंवा विश्वासार्ह टूल आणि फंक्शन कॉल्स.

LLM केव्हा फाइन-ट्यून करावे आणि त्याऐवजी केव्हा प्रॉम्प्टिंग किंवा RAG वापरावे

LLM ची कामगिरी सुधारण्यासाठी एकेक पायरी पुढे जा: प्रॉम्प्टिंग -> RAG -> फाइन-ट्यूनिंग.

अधिक तपशीलवार सूचनांसह तुमचे प्रॉम्प्ट्स सुधारा आणि मॉडेलला अद्ययावत माहिती देण्यासाठी RAG वापरा. प्रॉम्प्ट आणि रिट्रीव्हलमधील सुधारणांनी अपेक्षित परिणाम मिळत नसेल, तेव्हाच फाइन-ट्यूनिंग वापरा.

चांगले प्रॉम्प्ट्स फाइन-ट्यूनिंगपेक्षा केव्हा सरस ठरतात आणि केव्हा ते पुरेसे नसतात

प्रॉम्प्टिंग हा सर्वात जलद आणि सर्वात स्वस्त उपाय आहे. अनेक प्रकरणांमध्ये, अधिक अचूक आणि तपशीलवार प्रॉम्प्ट्सद्वारे वर्तनात अपेक्षित बदल साध्य होतात.

पण लांब प्रॉम्प्ट्समुळे काम मंदावते आणि अधिक खर्चिक होते, आणि ते मॉडेलच्या विद्यमान मर्यादांवर मात करू शकत नाहीत.

प्रॉम्प्टिंग त्याच्या मर्यादेपर्यंत पोहोचले असल्याची लक्षणे:

• नवीन एज केसेस आउटपुट सतत बिघडवत राहतात: उदाहरणार्थ, तुम्हाला JSON हवे असताना मॉडेल साधा गद्य मजकूर देते किंवा टोनपासून भरकटते, आणि प्रत्येक नवीन प्रकरणासाठी तुम्ही प्रॉम्प्टमध्ये ठिगळे लावत राहता.
• सिस्टम प्रॉम्प्ट वाढतच जातो: प्रॉम्प्ट शेकडो किंवा हजारो ओळींचा होतो आणि तो सांभाळणे कठीण होते.
• प्रत्येक कॉलवर तुम्हाला त्याची किंमत मोजावी लागते: प्रत्येक विनंतीवर प्रॉम्प्ट पुन्हा पाठवला जातो आणि पुन्हा प्रोसेस केला जातो, त्यामुळे टोकनचा खर्च आणि लेटन्सी वाढते.
• बदलांचा काहीच परिणाम होत नाही: नवीन सूचनांमुळे आउटपुटमध्ये सुधारणा होत नाही.

तरीही, आधी प्रॉम्प्ट-स्तरावरील स्वस्त उपाय वापरून पाहा. मॉडेलला पॅटर्न (इनपुट/आउटपुट जोड्या) दाखवण्यासाठी फ्यू-शॉट उदाहरणे, कठीण कामांचे लहान टप्प्यांत विभाजन करण्यासाठी प्रॉम्प्ट चेनिंग, किंवा अचूक लुकअप किंवा गणना दुसरीकडे सोपवण्यासाठी फंक्शन-कॉलिंग हुक्स वापरा.

मॉडेल फाइन-ट्यून करण्यापेक्षा RAG केव्हा अधिक योग्य ठरते

RAG मुळे LLM ला काय माहीत आहे ते बदलते, तर LLM फाइन-ट्यूनिंगमुळे ते कसे वागते ते बदलते. जर उणीव ज्ञानाची असेल, विशेषतः वारंवार बदलणाऱ्या किंवा तुमच्या स्वतःच्या दस्तऐवजांमध्ये असलेल्या ज्ञानाची, तर RAG हेच उत्तर आहे. जर उणीव वर्तनाची असेल, तर फाइन-ट्यून करा.

फाइन-ट्यूनिंगमुळे मॉडेलच्या ज्ञानातही बदल होतो, पण ते आत्मसात करत असलेली कोणतीही तथ्ये प्रशिक्षणाच्या वेळीच गोठतात आणि वेगाने बदलणाऱ्या क्षेत्रांमध्ये लवकरच कालबाह्य होतात. शिवाय, ही माहिती मॉडेलच्या वेट्समध्ये रुजते, त्यामुळे त्यांच्यात तिच्या स्रोताची कोणतीही नोंद राहत नाही.

रिट्रीव्हल लेयर वापरत असलेले स्रोत दस्तऐवज अपडेट करणे अधिक जलद आणि स्वस्त असते, आणि हा लेयर त्याने वापरलेल्या नेमक्या स्रोतांचा संदर्भही देऊ शकतो. त्यामुळे जेव्हा तुम्हाला समर्थनीय, अद्ययावत माहिती हवी असते, तेव्हा हा अधिक चांगला पर्याय ठरतो.

RAG ची उणीव कोणती? हा तयार करून सांभाळावा लागणारा एक अतिरिक्त लेयर आहे, आणि त्यामुळे लेटन्सी वाढते.

प्रत्यक्षात, तुम्हाला अनेकदा दोन्हींची गरज भासेल. प्रोडक्शन सिस्टम्स फाइन-ट्यून केलेल्या मॉडेल्सची RAG शी जोड घालतात: एक सुसंगत वर्तनासाठी आणि दुसरे सद्य तथ्यांसाठी.

फाइन-ट्यूनिंगमधील सामान्य त्रुटी, जोखीम आणि आव्हाने

फाइन-ट्यूनिंग योग्य साधन असले तरीही, त्यात खर्च आणि जोखीम असतात:

• खर्च आणि वेळ: स्वच्छ, प्रातिनिधिक प्रशिक्षण डेटा गोळा करणे आणि प्रशिक्षणासाठी लागणारी कम्प्युट क्षमता, दोन्ही महाग असतात.
• कॅटॅस्ट्रॉफिक फॉरगेटिंग (आपत्तीजनक विस्मरण): संकुचित व्याप्तीच्या डेटासेटवर प्रशिक्षित केल्यास, मॉडेल सामान्य कौशल्ये गमावू शकते आणि अपयशाचे नवीन प्रकार आत्मसात करू शकते, ज्यामुळे बेस मॉडेलने न केलेल्या चुका होतात.
• ओव्हरफिटिंग: डेटा खूप कमी किंवा खूप पुनरावृत्तीचा असल्यास, मॉडेल पॅटर्न शिकण्याऐवजी तुमची प्रशिक्षण उदाहरणे पाठ करते, त्यामुळे ते प्रशिक्षण नमुन्यांवर चांगली कामगिरी करते, पण प्रत्यक्ष इनपुटवर खराब कामगिरी करते.
• कालबाह्यता: वेट्समध्ये रुजलेले ज्ञान लवकर जुने होते, त्यामुळे तुम्हाला नवीन डेटावर पुन्हा प्रशिक्षण द्यावे लागते.
• अप्रचलितता: अधिक सक्षम मॉडेल उपलब्ध झाल्यावर ते अनेकदा कोणत्याही बदलाशिवायच तुमच्या फाइन-ट्यून केलेल्या मॉडेलपेक्षा सरस ठरते, आणि तुम्हाला ते काम पुन्हा करावे लागते.
• मूल्यमापन आणि पुनरुत्पादनातील आव्हाने: फाइन-ट्यून केलेले मॉडेल बेस मॉडेलपेक्षा अधिक चांगली कामगिरी करते हे सिद्ध करणे कठीण असते. तसेच, समान सेटिंग्जसह केलेल्या दोन GPU प्रशिक्षण रनमधूनही थोडी वेगवेगळी मॉडेल्स तयार होऊ शकतात.
• डेटा गव्हर्नन्स: मालकीच्या किंवा संवेदनशील डेटावर प्रशिक्षण दिल्याने गोपनीयता आणि परवान्यांविषयी प्रश्न निर्माण होतात; मॉडेल नंतर ज्या डेटावर त्याला प्रशिक्षित केले होते त्याचे अंश उघड करू शकते.

फाइन-ट्यूनिंगच्या मुख्य पद्धती

LLM फाइन-ट्यूनिंगचे मुख्य प्रकार मॉडेलचा किती भाग बदलतात यानुसार वेगळे ठरतात: फुल फाइन-ट्यूनिंग संपूर्ण मॉडेलला पुन्हा प्रशिक्षित करते, तर LoRA आणि QLoRA सारख्या पॅरामीटर-एफिशियंट फाइन-ट्यूनिंग (PEFT) पद्धती केवळ काही वेट्स अपडेट करतात. PEFT पद्धतींना फुल फाइन-ट्यूनिंगच्या तुलनेत अगदी अल्प मेमरी लागते आणि योग्य सेटिंग्जसह त्या तितकेच परिणाम देऊ शकतात.

फुल फाइन-ट्यूनिंग मॉडेलचा प्रत्येक वेट अपडेट करते. ही सर्वात खर्चिक पद्धत आहे आणि यात कॅटॅस्ट्रॉफिक फॉरगेटिंगचा धोका सर्वाधिक असतो. वर्तनात मोठा बदल हवा असेल आणि त्यासाठी आवश्यक डेटा व कम्प्युट क्षमता तुमच्याकडे असेल, तेव्हाच ती वापरा.

याला पर्याय म्हणजे पॅरामीटर-एफिशियंट फाइन-ट्यूनिंग, किंवा PEFT. मॉडेलचा बहुतांश भाग गोठवून केवळ पॅरामीटर्सच्या लहान संचाला प्रशिक्षित करणाऱ्या पद्धतींसाठी वापरली जाणारी ही एक व्यापक संज्ञा आहे. बेस मॉडेल अबाधित राहत असल्याने, यात खूपच कमी मेमरी लागते आणि विसरण्याची शक्यताही कमी असते.

कमी रँकवर, PEFT फुल फाइन-ट्यूनपेक्षा कमी शिकते, पण रँक वाढवून आणि लर्निंग रेट ट्यून करून इन्स्ट्रक्शन-ट्यूनिंग कार्यांमधील बहुतांश तफावत भरून काढता येते.

PEFT पद्धतींमध्ये यांचा समावेश होतो:

• LoRA (Low-Rank Adaptation): सहसा सुरुवात याच पद्धतीने केली जाते. ही मूळ वेट्स गोठवते आणि जोडलेल्या ॲडॅप्टर पॅरामीटर्सच्या लहान संचाला प्रशिक्षित करते, जे बहुतेकदा एकूण पॅरामीटर्सच्या 1% पेक्षा कमी असतात, त्यामुळे ती एकाच कंझ्युमर GPU वर चालते.
• QLoRA (Quantized Low-Rank Adaptation): ही पद्धत 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 चे सर्वोत्तम रेट्स फुल फाइन-ट्यूनिंगच्या रेट्सपेक्षा साधारण दहा पट जास्त होते, म्हणजे सामान्यतः 1e-5 ते 5e-5 च्या तुलनेत 5e-5 ते 5e-4. हा अभ्यास 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: प्रशिक्षण द्या आणि लॉसचे निरीक्षण करा

प्रशिक्षण सुरू असताना, ते योग्यरीत्या काम करत आहे का हे पाहण्यासाठी ट्रेनिंग आणि व्हॅलिडेशन लॉस कर्व्हवर लक्ष ठेवा.

लॉस हे मोजते की मॉडेलचे आउटपुट तुमच्या उदाहरणांपासून किती दूर आहेत, आणि रन जसजसा पुढे जातो तसतसा तो सुरळीतपणे कमी व्हायला हवा. ट्रेनिंग लॉस हा मॉडेल ज्या डेटामधून शिकते त्या डेटावर मोजला जातो. व्हॅलिडेशन लॉस हा बाजूला ठेवलेल्या (held-out) उदाहरणांवर मोजला जातो.

जर ट्रेनिंग लॉस आणि व्हॅलिडेशन लॉस एकत्र कमी होत असतील, तर मॉडेल सामान्यीकरण करायला शिकत आहे. जर ट्रेनिंग लॉस कमी होत राहिला पण व्हॅलिडेशन लॉस स्थिरावला किंवा वाढू लागला, तर मॉडेल पॅटर्न शिकण्याऐवजी ट्रेनिंग सेट पाठ करत आहे (ओव्हरफिटिंग).

विस्तृत करा

पायरी 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 मॉडेल एका तासापेक्षा थोड्या अधिक वेळात पूर्णपणे फाइन-ट्यून केले.

मोठी मॉडेल्स किंवा हजारो उदाहरणे असल्यास हा वेळ एक दिवस किंवा त्याहून अधिक होऊ शकतो: 7B मॉडेलवरील Emburse चे LoRA रन एकाच 40GB GPU वर 5,000 उदाहरणांसाठी 8 तास आणि 50,000 उदाहरणांसाठी सुमारे 30 तास चालले.

तुमचा डेटा बदलत असताना फाइन-ट्यून केलेले मॉडेल अपडेट करत राहता येते का?

तुम्ही नवीन डेटावर पुन्हा फाइन-ट्यून करू शकता, पण प्रत्येक फेरीसाठी कम्प्युट खर्च होतो आणि कॅटॅस्ट्रॉफिक फरगेटिंगचा (आधी शिकलेले विसरण्याचा) धोका असतो. वारंवार बदलणाऱ्या ज्ञानासाठी, RAG हा सहसा अधिक चांगला उपाय असतो, कारण त्यात पुन्हा प्रशिक्षण देण्याऐवजी तुम्ही फक्त स्रोत दस्तऐवज अपडेट करता.