आरएजी क्या है?

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

आरएजी बनाम फाइन-ट्यूनिंग

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

एक आरएजी एजेंट का निर्माण

आवश्यकताएँ स्थापित करना

ओलामा स्थापित करें

ओलामा स्थानीय स्तर पर एलएलएएमए को चलाने के लिए आवश्यक बैकएंड बुनियादी ढांचा प्रदान करता है। आरंभ करने के लिए, ओलामा की वेबसाइट पर जाएं और एप्लिकेशन डाउनलोड करें। इसे अपनी स्थानीय मशीन पर स्थापित करने के लिए निर्देशों का पालन करें।

लैंगचेन आवश्यकताएँ स्थापित करें

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

pip install langchain

RAG एजेंट को कोडिंग

एक एपीआई फ़ंक्शन बनाएं

सबसे पहले, आपको अपने स्थानीय LLaMA इंस्टेंस के साथ इंटरैक्ट करने के लिए एक फ़ंक्शन की आवश्यकता होगी। यहां बताया गया है कि आप इसे कैसे सेट कर सकते हैं:

from requests import post as rpost

def call_llama(prompt):
    headers = {"Content-Type": "application/json"}
    payload = {
        "model": "llama3.1",
        "prompt": prompt,
        "stream": False,
    }

    response = rpost(
        "http://localhost:11434/api/generate",
        headers=headers,
        json=payload
    )
    return response.json()["response"]

एक लैंगचेन एलएलएम बनाएं

इसके बाद, इस फ़ंक्शन को लैंगचेन के भीतर एक कस्टम एलएलएम क्लास में एकीकृत करें:

from langchain_core.language_models.llms import LLM

class LLaMa(LLM):
    def _call(self, prompt, **kwargs):
        return call_llama(prompt)

    @property
    def _llm_type(self):
        return "llama-3.1-8b"

आरएजी एजेंट को एकीकृत करना

रिट्रीवर की स्थापना

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

from langchain.vectorstores import FAISS
from langchain_huggingface import HuggingFaceEmbeddings

documents = [
    {"content": "What is your return policy? ..."},
    {"content": "How long does shipping take? ..."},
    # Add more documents as needed
]

texts = [doc["content"] for doc in documents]

retriever = FAISS.from_texts(
    texts,
    HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
).as_retriever(k=5)

प्रॉम्प्ट टेम्प्लेट बनाएं

उस प्रॉम्प्ट टेम्पलेट को परिभाषित करें जिसका उपयोग RAG एजेंट पुनर्प्राप्त दस्तावेज़ों के आधार पर प्रतिक्रियाएँ उत्पन्न करने के लिए करेगा:

from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder

faq_template = """
You are a chat agent for my E-Commerce Company. As a chat agent, it is your duty to help the human with their inquiry and make them a happy customer.

Help them, using the following context:

{context}

"""

faq_prompt = ChatPromptTemplate.from_messages([
    ("system", faq_template),
    MessagesPlaceholder("messages")
])

दस्तावेज़ और रिट्रीवर चेन बनाएं

दस्तावेज़ पुनर्प्राप्ति और LLaMA पीढ़ी को एक सामंजस्यपूर्ण श्रृंखला में संयोजित करें:

from langchain.chains.combine_documents import create_stuff_documents_chain

document_chain = create_stuff_documents_chain(LLaMa(), faq_prompt)

def parse_retriever_input(params):
    return params["messages"][-1].content

retrieval_chain = RunnablePassthrough.assign(
    context=parse_retriever_input | retriever
).assign(answer=document_chain)

अपना ओलामा सर्वर प्रारंभ करें

अपना RAG एजेंट चलाने से पहले, सुनिश्चित करें कि ओलामा सर्वर चालू है और चल रहा है। निम्न आदेश के साथ सर्वर प्रारंभ करें:

ollama serve

अपने आरएजी एजेंट को संकेत दें

अब, आप एक प्रश्न भेजकर अपने RAG एजेंट का परीक्षण कर सकते हैं:

from langchain.schema import HumanMessage

response = retrieval_chain.invoke({
    "messages": [
        HumanMessage("I received a damaged item. I want my money back.")
    ]
})

print(response)

प्रतिक्रिया:
"मुझे यह सुनकर बहुत दुख हुआ कि आपको एक क्षतिग्रस्त वस्तु मिली है। हमारी नीति के अनुसार, यदि आपको कोई क्षतिग्रस्त वस्तु मिलती है, तो कृपया क्षति की तस्वीरों के साथ तुरंत हमारी ग्राहक सेवा टीम से संपर्क करें। हम आपके लिए प्रतिस्थापन या धनवापसी की व्यवस्था करेंगे। क्या आप चाहते हैं कि मैं रिफंड प्राप्त करने में आपकी सहायता करूं? मुझे आपसे कुछ जानकारी चाहिए, जैसे आपका ऑर्डर नंबर और क्षतिग्रस्त वस्तु के बारे में विवरण। क्या आप कृपया वह प्रदान कर सकते हैं ताकि मैं आपके अनुरोध को संसाधित करने में सहायता कर सकूं?"

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