एलएलएम एजेंटों को आरएजी के लिए स्क्रैच से बनाना और उसके बाद: एक व्यापक गाइड

एलएलएम जैसे जीपीटी-3, जीपीटी-4, और उनके ओपन-सोर्स समकक्ष अक्सर अप-टू-डेट जानकारी पुनर्प्राप्ति के साथ संघर्ष करते हैं और कभी-कभी हॉलुसिनेशन या गलत जानकारी उत्पन्न कर सकते हैं।

रिट्रीवल-ऑगमेंटेड जेनरेशन (आरएजी) एक तकनीक है जो एलएलएम की शक्ति को बाहरी ज्ञान पुनर्प्राप्ति के साथ जोड़ती है। आरएजी हमें एलएलएम प्रतिक्रियाओं को तथ्यात्मक, अप-टू-डेट जानकारी में आधारित करने की अनुमति देता है, जिससे एआई-उत्पन्न सामग्री की सटीकता और विश्वसनीयता में काफी सुधार होता है।

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

आरएजी क्या है और यह क्यों महत्वपूर्ण है, यह समझने से पहले हम अपने एलएलएम एजेंट को बनाने में गहराई से जाने से पहले आरएजी की मूल बातों को समझना आवश्यक है।

आरएजी, या रिट्रीवल-ऑगमेंटेड जेनरेशन, एक हाइब्रिड दृष्टिकोण है जो जानकारी पुनर्प्राप्ति को पाठ जेनरेशन के साथ जोड़ता है। एक आरएजी प्रणाली में:

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

यह दृष्टिकोण कुछ फायदे हैं:

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

एलएलएम एजेंटों को समझना

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

वे विस्तृत डेटा विश्लेषण, रणनीतिक योजना, डेटा पुनर्प्राप्ति और पिछले कार्यों से सीखने की क्षमता को जोड़ते हैं ताकि जटिल मुद्दों का समाधान किया जा सके।

एलएलएम एजेंट क्या हैं?

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

एक कानूनी क्षेत्र में एक प्रश्न के बारे में विचार करें जैसे: “कैलिफोर्निया में एक विशिष्ट प्रकार के अनुबंध उल्लंघन के संभावित कानूनी परिणाम क्या हैं?” एक मूल एलएलएम एक आरएजी प्रणाली के साथ आवश्यक जानकारी को कानूनी डेटाबेस से पुनर्प्राप्त कर सकता है।

एक अधिक विस्तृत परिदृश्य के लिए: “नई डेटा गोपनीयता कानूनों के प्रकाश में, कंपनियों को कौन से सामान्य कानूनी चुनौतियों का सामना करना पड़ता है, और अदालतों ने इन मुद्दों को कैसे संबोधित किया है?” यह प्रश्न केवल तथ्यों की खोज से परे है। यह नियमों को समझने, विभिन्न कंपनियों पर उनके प्रभाव और अदालत की प्रतिक्रियाओं के बारे में है। एक एलएलएम एजेंट इस कार्य को उप-कार्यों में तोड़ देगा, जैसे कि नवीनतम कानून पुनर्प्राप्त करना, ऐतिहासिक मामलों का विश्लेषण करना, कानूनी दस्तावेजों को सारांशित करना और पैटर्न के आधार पर रुझानों की भविष्यवाणी करना।

एलएलएम एजेंटों के घटक

एलएलएम एजेंट आमतौर पर चार घटकों से बने होते हैं:

1. **एजेंट/ब्रेन**: भाषा मॉडल जो भाषा को संसाधित और समझता है।
2. **योजना**: तर्क, कार्यों को तोड़ने और विशिष्ट योजनाओं को विकसित करने की क्षमता।
3. **स्मृति**: पिछली बातचीत के रिकॉर्ड को बनाए रखने और उनसे सीखने की क्षमता।
4. **उपकरण का उपयोग**: विभिन्न संसाधनों को कार्यों को करने के लिए एकीकृत करने की क्षमता।

एजेंट/ब्रेन

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

स्मृति

स्मृति घटक जटिल कार्यों को संभालने में एलएलएम एजेंटों की मदद करता है bằng पिछली क्रियाओं का रिकॉर्ड बनाए रखने। दो मुख्य प्रकार की स्मृति होती है:

* **लघु स्मृति**: एक नोटपैड की तरह काम करती है, जो चल रही चर्चाओं को ट्रैक करती है।
* **दीर्घ स्मृति**: एक डायरी की तरह काम करती है, जो पिछली बातचीत से जानकारी संग्रहीत करती है ताकि पैटर्न सीखे जा सकें और बेहतर निर्णय लिए जा सकें।

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

योजना

योजना एलएलएम एजेंटों को तर्क करने, कार्यों को छोटे हिस्सों में तोड़ने और योजनाओं को विकसित करने की अनुमति देती है। योजना में दो मुख्य चरण होते हैं:

* **योजना निर्माण**: एक कार्य को छोटे उप-कार्यों में तोड़ना।
* **योजना प्रतिबिंब**: योजना की प्रभावशीलता की समीक्षा करना और प्रतिक्रिया को शामिल करना ताकि रणनीतियों को परिष्कृत किया जा सके।

चेन ऑफ थॉट (सीओटी) और ट्री ऑफ थॉट (टीओटी) जैसी विधियां इस विभाजन प्रक्रिया में मदद करती हैं, जिससे एजेंट समस्या का समाधान करने के लिए विभिन्न मार्गों का अन्वेषण कर सकता है।

आरएजी एजेंटों की वर्तमान क्षमताओं और संभावनाओं के बारे में अधिक जानने के लिए, “ऑटो-जीपीटी और जीपीटी-इंजीनियर: आज के अग्रणी एआई एजेंटों के लिए एक गहन मार्गदर्शिका” पढ़ें।

पर्यावरण सेट अप करना

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

* **लैंगचेन**: हमारे एलएलएम और पुनर्प्राप्ति घटकों को समन्वयित करने के लिए।
* **क्रोमा**: हमारे दस्तावेज़ एम्बेडिंग के लिए एक वेक्टर स्टोर के रूप में।
* **ओपनएआई के जीपीटी मॉडल**: हमारे आधार एलएलएम के रूप में (आप एक ओपन-सोर्स मॉडल के साथ इसकी जगह ले सकते हैं)।
* **फास्टएपीआई**: हमारे एजेंट के साथ बातचीत करने के लिए एक सरल एपीआई बनाने के लिए।

आइए शुरू करें:

“`python
# एक नया वर्चुअल एनवायरनमेंट बनाएं
python -m venv rag_agent_env
source rag_agent_env/bin/activate # विंडोज़ पर, `rag_agent_env\Scripts\activate` का उपयोग करें
“`

“`python
# आवश्यक पैकेज स्थापित करें
pip install langchain chromadb openai fastapi uvicorn
“`

अब, एक नया पाइथन फ़ाइल `rag_agent.py` बनाएं और आवश्यक लाइब्रेरी आयात करें:

“`python
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader
import os
“`

“`python
# अपनी ओपनएआई एपीआई कुंजी सेट करें
os.environ[“OPENAI_API_KEY”] = “your-api-key-here”
“`

एक सरल आरएजी सिस्टम बनाना

अब हमारे पर्यावरण सेट अप होने के बाद, आइए एक बुनियादी आरएजी सिस्टम बनाएं। हम एक ज्ञान आधार से एक सेट ऑफ दस्तावेज़ बनाकर शुरू करेंगे, फिर इसका उपयोग प्रश्नों का उत्तर देने के लिए करेंगे।

चरण 1: दस्तावेज़ तैयार करना

सबसे पहले, हमें अपने दस्तावेज़ लोड और तैयार करने होंगे। इस उदाहरण के लिए, मान लें कि हमारे पास एक पाठ फ़ाइल `knowledge_base.txt` है जिसमें कुछ एआई और मशीन लर्निंग के बारे में जानकारी है।

“`python
# दस्तावेज़ लोड करें
loader = TextLoader(“knowledge_base.txt”)
documents = loader.load()

# दस्तावेज़ों को छोटे हिस्सों में विभाजित करें
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# एम्बेडिंग बनाएं
embeddings = OpenAIEmbeddings()

# एक वेक्टर स्टोर बनाएं
vectorstore = Chroma.from_documents(texts, embeddings)
“`

चरण 2: एक पुनर्प्राप्ति-आधारित प्रश्नोत्तर श्रृंखला बनाना

अब हमारे पास वेक्टर स्टोर होने के बाद, हम एक पुनर्प्राप्ति-आधारित प्रश्नोत्तर श्रृंखला बना सकते हैं:

“`python
# एक पुनर्प्राप्ति-आधारित प्रश्नोत्तर श्रृंखला बनाएं
qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type=”stuff”, retriever=vectorstore.as_retriever())
“`

चरण 3: सिस्टम को प्रश्न पूछना

अब हम अपने आरएजी सिस्टम से प्रश्न पूछ सकते हैं:

“`python
query = “मशीन लर्निंग के मुख्य अनुप्रयोग क्या हैं?”
result = qa.run(query)
print(result)
“`

चरण 4: एक एलएलएम एजेंट बनाना

जबकि हमारा सरल आरएजी सिस्टम उपयोगी है, यह बहुत सीमित है। आइए इसे एक एलएलएम एजेंट बनाकर बढ़ाएं जो अधिक जटिल कार्य कर सकता है और तर्क कर सकता है।

एक एलएलएम एजेंट एक एआई प्रणाली है जो उपकरणों का उपयोग कर सकती है और क्रियाओं के बारे में निर्णय ले सकती है। हम एक एजेंट बनाएंगे जो न केवल प्रश्नों का उत्तर दे सकता है, बल्कि वेब खोज और बुनियादी गणनाएं भी कर सकता है।

“`python
from langchain.agents import Tool
from langchain.tools import DuckDuckGoSearchRun
from langchain.tools import BaseTool
from langchain.agents import initialize_agent
from langchain.agents import AgentType

# एक कैलकुलेटर उपकरण परिभाषित करें
class CalculatorTool(BaseTool):
name = “Calculator”
description = “गणितीय अभिव्यक्तियों का मूल्यांकन करने के लिए उपयोगी”

def _run(self, query: str) -> str:
try:
return str(eval(query))
except:
return “मैं उसे गणना नहीं कर सका। कृपया सुनिश्चित करें कि आपका इनपुट एक वैध गणितीय अभिव्यक्ति है।”

# उपकरण उदाहरण बनाएं
search = DuckDuckGoSearchRun()
calculator = CalculatorTool()

# उपकरण परिभाषित करें
tools = [
Tool(name=”Search”, func=search.run, description=”वर्तमान घटनाओं के बारे में प्रश्नों का उत्तर देने के लिए उपयोगी”),
Tool(name=”RAG-QA”, func=qa.run, description=”एआई और मशीन लर्निंग के बारे में प्रश्नों का उत्तर देने के लिए उपयोगी”),
Tool(name=”Calculator”, func=calculator._run, description=”गणितीय गणनाओं के लिए उपयोगी”),
]

# एजेंट को आरंभ करें
agent = initialize_agent(tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

“`

अब हमारे पास एक एजेंट है जो हमारे आरएजी सिस्टम, वेब खोज और गणना कर सकता है। आइए इसे परीक्षण करें:

“`python
result = agent.run(“मशीन लर्निंग और सुपरवाइज्ड लर्निंग के बीच क्या अंतर है? 80 का 15% क्या है?”)
print(result)
“`

यह एजेंट एलएलएम एजेंटों का एक प्रमुख लाभ प्रदर्शित करता है: वे कई उपकरणों और तर्क चरणों को जोड़कर जटिल प्रश्नों का उत्तर दे सकते हैं।

एजेंट को उन्नत आरएजी तकनीकों से बढ़ाना

जबकि हमारा वर्तमान आरएजी सिस्टम अच्छा काम करता है, हम इसके प्रदर्शन को कई उन्नत तकनीकों के साथ बढ़ा सकते हैं:

ए) घने पासेज पुनर्प्राप्ति (डीपीआर) के साथ सेमेंटिक खोज

इसके बजाय कि हम सरल एम्बेडिंग-आधारित पुनर्प्राप्ति का उपयोग करें, हम डीपीआर को अधिक सटीक सेमेंटिक खोज के लिए लागू कर सकते हैं:

“`python
from transformers import DPRQuestionEncoder, DPRContextEncoder

question_encoder = DPRQuestionEncoder.from_pretrained(“facebook/dpr-question_encoder-single-nq-base”)
context_encoder = DPRContextEncoder.from_pretrained(“facebook/dpr-ctx_encoder-single-nq-base”)

# पासेज को एनकोड करने के लिए एक फ़ंक्शन
def encode_passages(passages):
return context_encoder(passages, max_length=512, return_tensors=”pt”).pooler_output

# प्रश्न को एनकोड करने के लिए एक फ़ंक्शन
def encode_query(query):
return question_encoder(query, max_length=512, return_tensors=”pt”).pooler_output
“`

बी) प्रश्न विस्तार

हम प्रश्न विस्तार का उपयोग पुनर्प्राप्ति प्रदर्शन में सुधार करने के लिए कर सकते हैं:

“`python
from transformers import T5ForConditionalGeneration, T5Tokenizer

model = T5ForConditionalGeneration.from_pretrained(“t5-small”)
tokenizer = T5Tokenizer.from_pretrained(“t5-small”)

def expand_query(query):
input_text = f”expand query: {query}”
input_ids = tokenizer.encode(input_text, return_tensors=”pt”)
outputs = model.generate(input_ids, max_length=50, num_return_sequences=3)
expanded_queries = [tokenizer.decode(output, skip_special_tokens=True) for output in outputs]
return expanded_queries
“`

सी) पुनरावृत्ति सुधार

हम एक पुनरावृत्ति प्रक्रिया को लागू कर सकते हैं जहां एजेंट प्रारंभिक पुनर्प्राप्ति के आधार पर अनुवर्ती प्रश्न पूछ सकता है:

“`python
def iterative_retrieval(initial_query, max_iterations=3):
query = initial_query
for _ in range(max_iterations):
result = qa.run(query)
clarification = agent.run(f”इस परिणाम के आधार पर: ‘{result}’, अधिक विशिष्ट जानकारी प्राप्त करने के लिए मुझे कौन सा अनुवर्ती प्रश्न पूछना चाहिए?”)
if clarification.lower().strip() == “none”:
break
query = clarification
return result
“`

एक बहु-एजेंट प्रणाली को लागू करना

जटिल कार्यों को संभालने के लिए, हम एक बहु-एजेंट प्रणाली को लागू कर सकते हैं जहां विभिन्न एजेंट विभिन्न क्षेत्रों में विशेषज्ञता रखते हैं। यहाँ एक सरल उदाहरण है:

“`python
class SpecialistAgent:
def __init__(self, name, tools):
self.name = name
self.agent = initialize_agent(tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

def run(self, query):
return self.agent.run(query)

# विशेषज्ञ एजेंट बनाएं
research_agent = SpecialistAgent(“Research”, [Tool(name=”RAG-QA”, func=qa.run, description=”एआई और एमएल के बारे में प्रश्नों का उत्तर देने के लिए उपयोगी”)])
math_agent = SpecialistAgent(“Math”, [Tool(name=”Calculator”, func=calculator._run, description=”गणितीय गणनाओं के लिए उपयोगी”)])
general_agent = SpecialistAgent(“General”, [Tool(name=”Search”, func=search.run, description=”सामान्य प्रश्नों का उत्तर देने के लिए उपयोगी”)])

class Coordinator:
def __init__(self, agents):
self.agents = agents

def run(self, query):
# यह तय करें कि कौन सा एजेंट उपयोग करना है
if “calculate” in query.lower() or any(op in query for op in [‘+’, ‘-‘, ‘*’, ‘/’]):
return self.agents[‘Math’].run(query)
elif any(term in query.lower() for term in [‘ai’, ‘machine learning’, ‘deep learning’]):
return self.agents[‘Research’].run(query)
else:
return self.agents[‘General’].run(query)

coordinator = Coordinator({‘Research’: research_agent, ‘Math’: math_agent, ‘General’: general_agent})

# बहु-एजेंट प्रणाली का परीक्षण करें
result = coordinator.run(“सीएनएन और आरएनएन के बीच क्या अंतर है? 120 का 25% क्या है?”)
print(result)
“`

यह बहु-एजेंट प्रणाली विशेषज्ञता और जटिल प्रश्नों को अधिक प्रभावी ढंग से संभालने की अनुमति देती है।

आरएजी एजेंटों का मूल्यांकन और अनुकूलन करना

हमारे आरएजी एजेंट का प्रदर्शन सुनिश्चित करने के लिए, हमें मूल्यांकन मेट्रिक्स और अनुकूलन तकनीकों को लागू करने की आवश्यकता है:

ए) प्रासंगिकता मूल्यांकन

हम प्रासंगिकता का मूल्यांकन करने के लिए मेट्रिक्स जैसे ब्लू, रोग और बेर्टस्कोर का उपयोग कर सकते हैं:

“`python
from bert_score import score

def evaluate_relevance(query, retrieved_doc, generated_answer):
P, R, F1 = score([generated_answer], [retrieved_doc], lang=”en”)
return F1.mean().item()
“`

बी) उत्तर गुणवत्ता मूल्यांकन

हम मानव मूल्यांकन या स्वचालित मेट्रिक्स का उपयोग उत्तर की गुणवत्ता का आकलन करने के लिए कर सकते हैं:

“`python
from nltk.translate.bleu_score import sentence_bleu

def evaluate_answer_quality(reference_answer, generated_answer):
return sentence_bleu([reference_answer.split()], generated_answer.split())
“`

भविष्य की दिशाएं और चुनौतियां

आरएजी एजेंटों के भविष्य को देखते हुए, कई रोमांचक दिशाएं और चुनौतियां सामने आती हैं:

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

निष्कर्ष

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

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

जटिल तर्क और कार्य निष्पादन के लिए सक्षम उन्नत एजेंटों को बनाने के लिए आरएजी तकनीकों का उपयोग कैसे करें, यह जानने के लिए।

XF\_TRANSLATION\_COMPLETE