RAG बनाम फाइन-ट्यूनिंग: व्यावहारिक उदाहरणों सहित एक व्यापक ट्यूटोरियल

अधिकांश बड़े भाषा मॉडल (LLMs) जैसे GPT-4 सामान्यीकृत, और अक्सर पुराने डेटासेट पर प्रशिक्षित होते हैं। ये सामान्य सवालों के जवाब देने में उत्कृष्ट होते हैं, लेकिन ताज़ा खबरों, नवीनतम विकास, और डोमेन-विशिष्ट विषयों पर ये संघर्ष करते हैं। ऐसे मामलों में, ये मतिभ्रम कर सकते हैं या गलत उत्तर दे सकते हैं। 

Claude 3.5 Sonnet जैसे बेहतर प्रदर्शन करने वाले मॉडल आने के बावजूद, हमें अब भी या तो मॉडल को कस्टम उत्तरों के लिए फाइन-ट्यून करना पड़ता है या बेस मॉडल को अतिरिक्त संदर्भ देने के लिए Retrieval-Augmented Generation (RAG) सिस्टम का उपयोग करना पड़ता है।

इस ट्यूटोरियल में, हम RAG और फाइन-ट्यूनिंग—LLM के उत्तरों को बेहतर बनाने के लिए उपयोग की जाने वाली दो अलग तकनीकों—का अन्वेषण करेंगे। हम उनके अंतर की जाँच करेंगे और परिणामों का मूल्यांकन करके सिद्धांत को व्यवहार में उतारेंगे। 

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

RAG और फाइन-ट्यूनिंग का अवलोकन

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

रिट्रीवल-ऑगमेंटेड जेनरेशन (RAG)

रिट्रीवल-ऑगमेंटेड जेनरेशन एक ऐसी प्रक्रिया है जिसमें GPT-4o जैसे बड़े भाषा मॉडल बाहरी डेटा स्रोतों का उपयोग करके संदर्भ-सचेत बनते हैं। यह एक रिट्रीवर और एक जेनरेटर का संयोजन है। रिट्रीवर इंटरनेट या वेक्टर डेटाबेस से डेटा लाता है और उसे मूल उपयोगकर्ता के प्रश्न के साथ जेनरेटर को प्रदान करता है। जेनरेटर अतिरिक्त संदर्भ का उपयोग करके अत्यधिक सटीक और प्रासंगिक उत्तर उत्पन्न करता है।  

अधिक जानने के लिए हमारा लेख पढ़ें,  Retrieval Augmented Generation (RAG) क्या है? बुनियादी बातों की एक गाइड और RAG एप्लिकेशन की अंदरूनी कार्यप्रणाली और विभिन्न उपयोग मामलों को समझें। 

फाइन-ट्यूनिंग

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

उदाहरण के लिए, कोई प्री-ट्रेंड मॉडल सामान्य बातचीत में तो दक्ष हो सकता है, लेकिन जटिल चिकित्सा प्रक्रियाओं या कानूनी नज़ीरों के बारे में पूछे जाने पर गलत उत्तर दे सकता है। 

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

दृश्य मार्गदर्शिकाओं के साथ प्री-ट्रेंड मॉडल को कस्टमाइज करना सीखने के लिए An Introductory Guide to Fine-Tuning LLMs ट्यूटोरियल का अनुसरण करें। 

RAG बनाम फाइन-ट्यूनिंग

हमने LLM के उत्तर निर्माण को सुधारने की प्रत्येक कार्य-पद्धति के बारे में सीखा। आइए उन्हें बेहतर समझने के लिए उनके अंतर की जाँच करें। 

1. लर्निंग शैली

RAG गतिशील लर्निंग शैली का उपयोग करता है, जो भाषा मॉडलों को डेटाबेस, इंटरनेट, या यहाँ तक कि APIs से नवीनतम और सबसे सटीक डेटा तक पहुँचने और उसका उपयोग करने की अनुमति देता है। यह तरीका सुनिश्चित करता है कि उत्पन्न उत्तर हमेशा अद्यतन और प्रासंगिक हों।

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

2. अनुकूलन क्षमता

RAG सामान्यीकरण के लिए सर्वोत्तम है। यह विभिन्न डेटा स्रोतों से जानकारी खींचने के लिए रिट्रीवल प्रक्रिया का उपयोग करता है। RAG मॉडल के उत्तर को नहीं बदलता; यह केवल मॉडल का मार्गदर्शन करने के लिए अतिरिक्त जानकारी प्रदान करता है। 

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

3. संसाधन तीव्रता

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

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

4. लागत

RAG को बेहतर उत्तर निर्माण के लिए उच्च-स्तरीय एंबेडिंग मॉडल और LLMs की आवश्यकता होती है। इसे एक तेज़ वेक्टर डेटाबेस भी चाहिए। API और संचालन लागत तेजी से बढ़ सकती है।

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

कुल मिलाकर, औसतन, यदि सब कुछ जोड़ा जाए तो फाइन-ट्यूनिंग की लागत RAG से अधिक होती है। 

5. कार्यान्वयन की जटिलता

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

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

व्यावहारिक उदाहरणों के साथ सिद्धांत की परख

आइए एक ही प्रॉम्प्ट को फाइन-ट्यून किए गए मॉडल, RAG एप्लिकेशन, और हाइब्रिड दृष्टिकोण को देकर परिणामों का मूल्यांकन करें। हाइब्रिड दृष्टिकोण में फाइन-ट्यून किए गए मॉडल को RAG एप्लिकेशन के साथ जोड़ा जाएगा। इस उदाहरण के लिए, हम Hugging Face के ruslanmv/ai-medical-chatbot डेटासेट का उपयोग करेंगे, जिसमें विभिन्न स्वास्थ्य स्थितियों पर रोगियों और डॉक्टरों के बीच बातचीत शामिल है।

Llama 3 का उपयोग करके RAG एप्लिकेशन बनाना

हम Llama 3 और LangChain इकोसिस्टम का उपयोग करके RAG एप्लिकेशन बनाकर शुरू करेंगे। 

आप LlamaIndex का उपयोग करके RAG एप्लिकेशन बनाना भी सीख सकते हैं, इस कोड-अलॉन्ग का अनुसरण करें, Retrieval Augmented Generation with LlamaIndex.

1. सभी आवश्यक Python पैकेज इंस्टॉल करें।

%%capture
%pip install -U langchain langchainhub langchain_community langchain-huggingface faiss-gpu transformers accelerateसंचालित द्वारा

2. LangChain और Transformers लाइब्रेरी से आवश्यक फ़ंक्शंस लोड करें।

from langchain.document_loaders import HuggingFaceDatasetLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
from transformers import AutoTokenizer, AutoModelForCausalLM,pipeline
from langchain_huggingface import HuggingFacePipeline
from langchain.chains import RetrievalQAसंचालित द्वारा

3. प्रतिबंधित मॉडल और डेटासेट तक पहुँच के लिए, Hugging Face हब में API कुंजी से लॉग इन करने की सिफारिश की जाती है।

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)संचालित द्वारा

4. डेटासेट का नाम और कॉलम नाम HuggingFaceDatasetLoader को देकर डेटासेट लोड करें। “Doctor” कॉलम हमारा मुख्य दस्तावेज़ होगा, और बाकी कॉलम मेटाडेटा होंगे। 

5. हमारे डेटासेट को पहले 1000 पंक्तियों तक सीमित करें। डेटासेट घटाने से वेक्टर डेटाबेस में डेटा स्टोरेज समय कम करने में मदद मिलेगी। 

# Specify the dataset name
dataset_name = "ruslanmv/ai-medical-chatbot"


# Create a loader instance using dataset columns
loader_doctor = HuggingFaceDatasetLoader(dataset_name,"Doctor")

# Load the data
doctor_data = loader_doctor.load()

# Select the first 1000 entries
doctor_data = doctor_data[:1000]

doctor_data[:2]संचालित द्वारा

जैसा कि हम देख सकते हैं, “Doctor” कॉलम पेज सामग्री है, और बाकी को मेटाडेटा माना जाता है। 

6. GPU त्वरण सक्षम करने जैसे विशिष्ट पैरामीटरों के साथ Hugging Face से एंबेडिंग मॉडल लोड करें।

7. नमूना पाठ देकर एंबेडिंग मॉडल का परीक्षण करें।

# Define the path to the embedding model
modelPath = "sentence-transformers/all-MiniLM-L12-v2"

# GPU acceleration
model_kwargs = {'device':'cuda'}

# Create a dictionary with encoding options
encode_kwargs = {'normalize_embeddings': False}

# Initialize an instance of HuggingFaceEmbeddings with the specified parameters
embeddings = HuggingFaceEmbeddings(
    model_name=modelPath,     
    model_kwargs=model_kwargs, 
    encode_kwargs=encode_kwargs
)
text = "Why are you a doctor?"
query_result = embeddings.embed_query(text)
query_result[:3]संचालित द्वारा

[-0.059351932257413864, 0.08008933067321777, 0.040729623287916183]संचालित द्वारा

8. डेटा को एंबेडिंग्स में बदलें और उन्हें वेक्टर डेटाबेस में सहेजें।

9. वेक्टर डेटाबेस को लोकल डायरेक्टरी में सहेजें।

10. नमूना प्रॉम्प्ट का उपयोग करके समानता खोज (similarity search) करें।

vector_db = FAISS.from_documents(doctor_data, embeddings)
vector_db.save_local("/kaggle/working/faiss_doctor_index")
question = "Hi Doctor, I have a headache, help me."
searchDocs = vector_db.similarity_search(question)
print(searchDocs[0].page_content)संचालित द्वारा

11. वेक्टर डेटाबेस इंस्टेंस को रिट्रीवर में कनवर्ट करें। यह हमें RAG चेन बनाने में मदद करेगा।

retriever = vector_db.as_retriever()संचालित द्वारा

12. Llama 3 8B Chat मॉडल का उपयोग करके टोकनाइज़र और मॉडल लोड करें।

13. इन्हें टेस्ट जेनरेशन पाइपलाइन बनाने के लिए उपयोग करें।

14. पाइपलाइन को LangChain LLM क्लाइंट में बदलें।

import torch
base_model = "/kaggle/input/llama-3/transformers/8b-chat-hf/1"

tokenizer = AutoTokenizer.from_pretrained(base_model)

model = AutoModelForCausalLM.from_pretrained(
        base_model,
        return_dict=True,
        low_cpu_mem_usage=True,
        torch_dtype=torch.float16,
        device_map="auto",
        trust_remote_code=True,
)

pipe = pipeline(
    "text-generation", 
    model=model, 
    tokenizer=tokenizer,
    max_new_tokens=120
)

llm = HuggingFacePipeline(pipeline=pipe)संचालित द्वारा

15. रिट्रीवर, उपयोगकर्ता क्वेरी, RAG प्रॉम्प्ट, और LLM का उपयोग करके प्रश्नोत्तर (Q&A) चेन बनाएं।

from langchain import hub
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough


rag_prompt = hub.pull("rlm/rag-prompt")




qa_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)संचालित द्वारा

16. डॉक्टर से प्रश्न पूछकर Q&A चेन का परीक्षण करें।

question = "Hi Doctor, I have a headache, help me."
result = qa_chain.invoke(question)
print(result.split("Answer: ")[1])संचालित द्वारा

यह डेटासेट से काफी मिलता-जुलता है, लेकिन यह शैली नहीं उठाता। इसने संदर्भ को समझा और उसे अपनी शैली में उत्तर लिखने के लिए उपयोग किया है। 

आइए एक और प्रश्न के साथ फिर से प्रयास करें। 

question = "Hello doctor, I have bad acne. How do I get rid of it?"
result = qa_chain.invoke(question)
print(result.split("Answer: ")[1])संचालित द्वारा

यह बहुत सीधा जवाब है। शायद डॉक्टर और मरीज चैटबॉट के लिए RAG दृष्टिकोण की बजाय हमें मॉडल को फाइन-ट्यून करना चाहिए। 

यदि आपको कोड चलाने में कठिनाई हो रही है, तो कृपया Kaggle नोटबुक देखें: Building RAG Application using Llama 3.

Chunking, Reranking, और Query Transformations जैसी तकनीकों से RAG सिस्टम का प्रदर्शन कैसे सुधारें, यह जानने के लिए How to Improve RAG Performance: 5 Key Techniques with Examples ट्यूटोरियल का पालन करें।

चिकित्सीय डेटा पर Llama 3 की फाइन-ट्यूनिंग

हम डॉक्टर और मरीज डेटासेट पर मॉडल को फाइन-ट्यून नहीं करेंगे क्योंकि हम यह पहले ही एक पिछले ट्यूटोरियल में कर चुके हैं: Fine-Tuning Llama 3 and Using It Locally: A Step-by-Step Guide। हम जो करने जा रहे हैं, वह है फाइन-ट्यून किए गए मॉडल को लोड करना और वही प्रश्न देकर परिणामों का आकलन करना। फाइन-ट्यून किया गया मॉडल Hugging Face और Kaggle पर उपलब्ध है।

यदि आप OpenAI API का उपयोग करके GPT-4 मॉडल को फाइन-ट्यून करने में रुचि रखते हैं, तो आप आसान DataCamp ट्यूटोरियल देखें Fine-Tuning OpenAI's GPT-4: A Step-by-Step Guide।

स्रोत: kingabzpro/llama-3-8b-chat-doctor

1. ट्रांसफॉर्मर्स लाइब्रेरी का उपयोग करके टोकनाइज़र और मॉडल लोड करें।

2. सुनिश्चित करें कि Kaggle GPU T4 x2 वातावरण में मॉडल लोड करने के लिए आप सही पैरामीटर का उपयोग कर रहे हैं।

from transformers import AutoTokenizer,AutoModelForCausalLM,pipeline
import torch

base_model = "/kaggle/input/fine-tuned-adapter-to-full-model/llama-3-8b-chat-doctor/"

tokenizer = AutoTokenizer.from_pretrained(base_model)

model = AutoModelForCausalLM.from_pretrained(
        base_model,
        return_dict=True,
        low_cpu_mem_usage=True,
        torch_dtype=torch.float16,
        device_map="auto",
        trust_remote_code=True,
)संचालित द्वारा

3. संदेशों पर चैट टेम्पलेट लागू करें।

4. मॉडल और टोकनाइज़र का उपयोग करके टेक्स्ट जेनरेशन पाइपलाइन बनाएं।

5. पाइपलाइन ऑब्जेक्ट को एक प्रॉम्प्ट दें और उत्तर उत्पन्न करें।

messages = [{"role": "user", "content": "Hi Doctor, I have a headache, help me."}]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)

outputs = pipe(prompt, max_new_tokens=120, do_sample=True)
print(outputs[0]["generated_text"])संचालित द्वारा

उत्तर डेटासेट से काफी मिलता-जुलता है। शैली वही है, लेकिन सीधा उत्तर देने के बजाय यह मरीज को आगे की जाँच कराने का सुझाव देता है।

6. आइए दूसरा प्रश्न पूछें।

messages = [{"role": "user", "content": "Hello doctor, I have bad acne. How do I get rid of it?"}]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
outputs = pipe(prompt, max_new_tokens=120, do_sample=True)
print(outputs[0]["generated_text"])संचालित द्वारा

शैली वही है, और उत्तर काफी सहानुभूतिपूर्ण और व्याख्यात्मक है। 

यदि आपको कोड चलाने में कठिनाई हो रही है, तो कृपया Kaggle नोटबुक देखें: Fine-tuned Llama 3 HF Inference।

हाइब्रिड दृष्टिकोण (RAG + फाइन-ट्यूनिंग)

अब हम फाइन-ट्यून किए गए मॉडल को अतिरिक्त संदर्भ प्रदान करेंगे ताकि उत्तर को और परिष्कृत किया जा सके और संतुलन पाया जा सके। 

सारा कोड फिर से लिखने के बजाय, हम Q&A चेन का उपयोग करके सीधे उत्तर निर्माण में उतरेंगे। यदि आप यह देखना चाहते हैं कि हमने फाइन-ट्यून किए गए मॉडल को RAG Q&A चेन के साथ कैसे जोड़ा, तो कृपया Hybrid Approach (RAG + Fine-tuning) Kaggle नोटबुक देखें। 

RAG और फाइन-ट्यून किए गए मॉडल से पूछे गए वही प्रश्न चेन को दें।

question = "Hi Doctor, I have a headache, help me."
result = qa_chain.invoke(question)
print(result.split("Answer: ")[1])संचालित द्वारा

उत्तर काफी सटीक है, और प्रतिक्रिया डॉक्टर की शैली में उत्पन्न हुई है। 

आइए दूसरा प्रश्न पूछें।

question = "Hello doctor, I have bad acne. How do I get rid of it?"
result = qa_chain.invoke(question)
print(result.split("Answer: ")[1])संचालित द्वारा

यह अजीब है। हमने यह अतिरिक्त संदर्भ कभी नहीं दिया कि मुँहासे पस से भरे हैं या नहीं। हो सकता है कि हाइब्रिड मॉडल कुछ क्वेरीज़ पर लागू न हो। 

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

हाइब्रिड दृष्टिकोण का आधिकारिक नाम RAFT (Retrieval Augmented Fine-Tuning) है। इसके बारे में अधिक जानने के लिए पढ़ें What is RAFT? Combining RAG and Fine-Tuning To Adapt LLMs To Specialized Domains ब्लॉग।

RAG बनाम फाइन-ट्यूनिंग बनाम RAFT में से कैसे चुनें

यह सब आपके उपयोग मामले और उपलब्ध संसाधनों पर निर्भर करता है। यदि आप सीमित संसाधनों वाला स्टार्टअप हैं, तो OpenAI API और LangChain फ्रेमवर्क का उपयोग करके RAG का एक प्रूफ़ ऑफ़ कॉन्सेप्ट बनाने का प्रयास करें। इसके लिए आपको सीमित संसाधन, विशेषज्ञता और डेटासेट की आवश्यकता होगी। 

यदि आप मध्यम स्तर की कंपनी हैं और उत्तर सटीकता में सुधार के लिए फाइन-ट्यूनिंग करना और ओपन-सोर्स मॉडल को क्लाउड पर परिनियोजित करना चाहते हैं, तो आपको डेटा वैज्ञानिकों और मशीन लर्निंग ऑपरेशंस इंजीनियरों जैसे विशेषज्ञों को नियुक्त करना होगा। फाइन-ट्यूनिंग के लिए उच्च-स्तरीय GPUs, बड़ी मेमोरी, स्वच्छ डेटासेट, और LLMs को समझने वाली तकनीकी टीम की आवश्यकता होती है। 

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

कृपया नीचे दी गई तालिका में RAG, फाइन-ट्यूनिंग, और RAFT समाधानों का अवलोकन देखें।

निष्कर्ष

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

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

LLMs की परिनियोजन और संबंधित विभिन्न तकनीकों के बारे में अधिक जानने के लिए, हमारा कोड-अलॉन्ग देखें RAG with LLaMAIndex और हमारा कोर्स deploying LLM applications with LangChain।