ऑप्टिमाइज़ LLM के साथ DSPy: AI सिस्टम बनाने, अनुकूलित करने और मूल्यांकन करने के लिए एक कदम-दर-कदम गाइड

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

DSPy के साथ प्रवेश करें, एक क्रांतिकारी फ्रेमवर्क जो LLM द्वारा संचालित AI सिस्टम के विकास को सुव्यवस्थित करने के लिए डिज़ाइन किया गया है। DSPy LLM प्रोम्प्ट और वजन को अनुकूलित करने के लिए एक व्यवस्थित दृष्टिकोण पेश करता है, जिससे डेवलपर्स न्यूनतम मैनुअल प्रयास के साथ जटिल अनुप्रयोग बना सकते हैं।

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

DSPy क्या है, और आपको इसकी आवश्यकता क्यों है?

DSPy एक फ्रेमवर्क है जो आपके कार्यक्रम के प्रवाह (मॉड्यूल) को प्रत्येक चरण के पैरामीटर (LM प्रोम्प्ट और वजन) से अलग करता है। यह अलगाव LLM प्रोम्प्ट और वजन के व्यवस्थित अनुकूलन की अनुमति देता है, जिससे आप डोमेन-विशिष्ट प्रतिबंधों और आवश्यकताओं का पालन करते हुए जटिल AI सिस्टम का निर्माण कर सकते हैं।

पारंपरिक रूप से, LLM के साथ AI सिस्टम विकसित करने में समस्या को चरणों में तोड़ने, प्रत्येक चरण के लिए जटिल प्रोम्प्ट बनाने, फ़ाइन-ट्यूनिंग के लिए सिंथेटिक उदाहरणों को जनरेट करने और विशिष्ट प्रतिबंधों का पालन करने के लिए LMs को मैनुअल रूप से मार्गदर्शन करने की एक श्रमसाध्य प्रक्रिया शामिल थी। यह दृष्टिकोण न केवल समय लेने वाला था, बल्कि त्रुटि-प्रवण भी था, क्योंकि पाइपलाइन, LM या डेटा में даже छोटे बदलाव प्रोम्प्ट और फ़ाइन-ट्यूनिंग चरणों के व्यापक पुनर्कार्य की आवश्यकता हो सकती है।

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

DSPy की मॉड्यूलर वास्तुकला

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

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

DSPy के साथ अनुकूलन

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

DSPy में उपलब्ध कुछ प्रमुख ऑप्टिमाइज़र में शामिल हैं:

1. BootstrapFewShot: यह ऑप्टिमाइज़र सिग्नेचर को विस्तारित करता है और प्रोम्प्ट में ऑप्टिमाइज़ किए गए उदाहरणों को स्वचालित रूप से जेनरेट और शामिल करता है, फ़ेव-शॉट लर्निंग को लागू करता है।
2. BootstrapFewShotWithRandomSearch: यह BootstrapFewShot को कई बार लागू करता है और जेनरेट किए गए प्रदर्शनों पर रैंडम सर्च के साथ, अनुकूलन पर सर्वश्रेष्ठ कार्यक्रम का चयन करता है।
3. MIPRO: यह निर्देश और फ़ेव-शॉट उदाहरणों को प्रत्येक चरण में जेनरेट करता है, जिसमें निर्देश जेनरेशन डेटा-अवेयर और डेमोन्स्ट्रेशन-अवेयर होता है। यह बेयसियन ऑप्टिमाइजेशन का उपयोग करके आपके मॉड्यूल के पारस्थितिकी और प्रदर्शनों के स्थान में प्रभावी ढंग से खोज करता है।
4. BootstrapFinetune: यह एक प्रोम्प्ट-आधारित DSPy कार्यक्रम को छोटे एलएम के लिए वजन अद्यतन में परिष्कृत करता है, आपको एलएम को फ़ाइन-ट्यून करने और कुशलता बढ़ाने की अनुमति देता है।

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

DSPy के साथ शुरुआत करना

DSPy की शक्ति को प्रदर्शित करने के लिए, आइए एक व्यावहारिक उदाहरण के माध्यम से प्रश्न-उत्तर (RAG) सिस्टम का निर्माण करें।

चरण 1: भाषा मॉडल और रिट्रीवल मॉडल की स्थापना

पहला चरण एलएम और आरएम को DSPy के भीतर कॉन्फ़िगर करना शामिल है।

DSPy स्थापित करने के लिए चलाएं:

pip install dspy-ai

DSPy कई एलएम और आरएम एपीआई के साथ-साथ स्थानीय मॉडल होस्टिंग का समर्थन करता है, जिससे अपने पसंदीदा मॉडल को एकीकृत करना आसान हो जाता है।

import dspy

# एलएम और आरएम कॉन्फ़िगर करें
turbo = dspy.OpenAI(model='gpt-3.5-turbo')
colbertv2_wiki17_abstracts = dspy.ColBERTv2(url='http://20.102.90.50:2017/wiki17_abstracts')

dspy.settings.configure(lm=turbo, rm=colbertv2_wiki17_abstracts)

चरण 2: डेटासेट लोड करना

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

from dspy.datasets import HotPotQA

# डेटासेट लोड करें
dataset = HotPotQA(train_seed=1, train_size=20, eval_seed=2023, dev_size=50, test_size=0)

# 'प्रश्न' फ़ील्ड को इनपुट के रूप में निर्दिष्ट करें
trainset = [x.with_inputs('question') for x in dataset.train]
devset = [x.with_inputs('question') for x in dataset.dev]

चरण 3: हस्ताक्षर बनाना

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

class GenerateAnswer(dspy.Signature):
"""छोटे तथ्यात्मक उत्तरों के साथ प्रश्नों का उत्तर दें।"""

context = dspy.InputField(desc="संबंधित तथ्य हो सकते हैं")
question = dspy.InputField()
answer = dspy.OutputField(desc="आमतौर पर 1 और 5 शब्दों के बीच होता है")

चरण 4: पाइपलाइन बनाना

हम अपनी RAG पाइपलाइन को एक DSPy मॉड्यूल के रूप में बनाएंगे, जिसमें एक प्रारंभिक विधि (__init__) शामिल है जो उप-मॉड्यूल (dspy.Retrieve और dspy.ChainOfThought) की घोषणा करती है और एक आगे की विधि (forward) जो प्रश्न का उत्तर देने के लिए इन मॉड्यूल के नियंत्रण प्रवाह का वर्णन करती है।

class RAG(dspy.Module):
def __init__(self, num_passages=3):
super().__init__()

self.retrieve = dspy.Retrieve(k=num_passages)
self.generate_answer = dspy.ChainOfThought(GenerateAnswer)

def forward(self, question):
context = self.retrieve(question).passages
prediction = self.generate_answer(context=context, question=question)
return dspy.Prediction(context=context, answer=prediction.answer)

चरण 5: पाइपलाइन को अनुकूलित करना

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

from dspy.teleprompt import BootstrapFewShot

# मूल्यांकन मीट्रिक
def validate_context_and_answer(example, pred, trace=None):
answer_EM = dspy.evaluate.answer_exact_match(example, pred)
answer_PM = dspy.evaluate.answer_passage_match(example, pred)
return answer_EM and answer_PM

# ऑप्टिमाइज़र सेट अप करें
teleprompter = BootstrapFewShot(metric=validate_context_and_answer)

# कार्यक्रम को संकलित करें
compiled_rag = teleprompter.compile(RAG(), trainset=trainset)

चरण 6: पाइपलाइन का मूल्यांकन

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

from dspy.evaluate import Evaluate

# मूल्यांकनकर्ता सेट अप करें
evaluate = Evaluate(devset=devset, metric=validate_context_and_answer, num_threads=4, display_progress=True, display_table=0)

# संकलित RAG कार्यक्रम का मूल्यांकन करें
evaluation_result = evaluate(compiled_rag)

print(f"मूल्यांकन परिणाम: {evaluation_result}")

चरण 7: मॉडल इतिहास का निरीक्षण

मॉडल के इंटरैक्शन की गहरी समझ के लिए, आप मॉडल के इतिहास की समीक्षा कर सकते हैं।

# मॉडल के इतिहास का निरीक्षण करें
turbo.inspect_history(n=1)

चरण 8: भविष्यवाणी करना

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

# उदाहरण प्रश्न
question = "गैरी ज़ुकाव की पहली पुस्तक को कौन सा पुरस्कार मिला?"

# संकलित RAG कार्यक्रम का उपयोग करके भविष्यवाणी करें
prediction = compiled_rag(question)

print(f"प्रश्न: {question}")
print(f"उत्तर: {prediction.answer}")
print(f"पुनर्प्राप्त संदर्भ: {prediction.context}")

न्यूनतम कार्य उदाहरण DSPy के साथ

अब, आइए एक और न्यूनतम कार्य उदाहरण के माध्यम से जाएं जो GSM8K डेटासेट और ओपनएआई जीपीटी-3.5-टर्बो मॉडल का उपयोग करता है ताकि DSPy के भीतर प्रोम्प्टिंग कार्यों का अनुकरण किया जा सके।

सेटअप

सुनिश्चित करें कि आपका वातावरण ठीक से कॉन्फ़िगर किया गया है:

import dspy
from dspy.datasets.gsm8k import GSM8K, gsm8k_metric

# एलएम सेट अप करें
turbo = dspy.OpenAI(model='gpt-3.5-turbo-instruct', max_tokens=250)
dspy.settings.configure(lm=turbo)

# जीएसएम8के डेटासेट से गणित प्रश्न लोड करें
gsm8k = GSM8K()
gsm8k_trainset, gsm8k_devset = gsm8k.train[:10], gsm8k.dev[:10]

print(gsm8k_trainset)

ग्स्म8के_ट्रेनसेट और ग्स्म8के_डेवसेट डेटासेट में प्रत्येक उदाहरण के लिए एक प्रश्न और उत्तर फ़ील्ड के साथ एक सूची शामिल है।

मॉड्यूल परिभाषित करें

इसके बाद, एक कस्टम कार्यक्रम परिभाषित करें जो चरण-दर-चरण तर्क के लिए ChainOfThought मॉड्यूल का उपयोग करता है:

class CoT(dspy.Module):
def __init__(self):
super().__init__()
self.prog = dspy.ChainOfThought("question -> answer")

def forward(self, question):
return self.prog(question=question)

मॉडल को संकलित और मूल्यांकन करें

अब इसे BootstrapFewShot टेलीप्रॉम्प्टर के साथ संकलित करें:

from dspy.teleprompt import BootstrapFewShot

# ऑप्टिमाइज़र सेट अप करें
config = dict(max_bootstrapped_demos=4, max_labeled_demos=4)

# ग्स्म8के_मीट्रिक का उपयोग करके अनुकूलित करें
teleprompter = BootstrapFewShot(metric=gsm8k_metric, **config)
optimized_cot = teleprompter.compile(CoT(), trainset=gsm8k_trainset)

# मूल्यांकनकर्ता सेट अप करें
from dspy.evaluate import Evaluate

evaluate = Evaluate(devset=gsm8k_devset, metric=gsm8k_metric, num_threads=4, display_progress=True, display_table=0)
evaluate(optimized_cot)

# मॉडल के इतिहास का निरीक्षण करें
turbo.inspect_history(n=1)

यह उदाहरण दिखाता है कि कैसे आप अपने वातावरण को सेट अप करें, एक कस्टम मॉड्यूल परिभाषित करें, एक मॉडल को संकलित और मूल्यांकन करें, और फिर DSPy टेलीप्रॉम्प्टर कॉन्फ़िगरेशन का उपयोग करके इसके प्रदर्शन का मूल्यांकन करें।

डेटा प्रबंधन DSPy में

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

उदाहरण वस्तुओं का निर्माण

DSPy में उदाहरण वस्तुएं पाइथन शब्दकोशों के समान होती हैं लेकिन उपयोगी उपयोगिताओं के साथ आती हैं:

qa_pair = dspy.Example(question="यह एक प्रश्न है?", answer="यह एक उत्तर है।")

print(qa_pair)
print(qa_pair.question)
print(qa_pair.answer)

आउटपुट:

Example({'question': 'यह एक प्रश्न है?', 'answer': 'यह एक उत्तर है।'}) (input_keys=None)
यह एक प्रश्न है?
यह एक उत्तर है।

इनपुट कुंजी निर्दिष्ट करना

DSPy में, Example वस्तुओं में एक with_inputs() विधि होती है जो विशिष्ट फ़ील्ड को इनपुट के रूप में चिह्नित करने के लिए:

print(qa_pair.with_inputs("question"))
print(qa_pair.with_inputs("question", "answer"))

मान डॉट ऑपरेटर का उपयोग करके एक्सेस किए जा सकते हैं, और inputs() और labels() जैसे तरीके केवल इनपुट या गैर-इनपुट कुंजियों वाली नई Example वस्तुओं को लौटाते हैं।

ऑप्टिमाइज़र DSPy में

एक DSPy ऑप्टिमाइज़र एक DSPy कार्यक्रम (अर्थात प्रोम्प्ट और/या एलएम वजन) के पैरामीटर को विशिष्ट मीट्रिक को अधिकतम करने के लिए ट्यून करता है। DSPy विभिन्न निर्मित ऑप्टिमाइज़र प्रदान करता है, प्रत्येक एक अलग रणनीति का उपयोग करता है।

उपलब्ध ऑप्टिमाइज़र

• BootstrapFewShot: फ़ेव-शॉट उदाहरणों को प्रदान किए गए लेबल्ड इनपुट और आउटपुट डेटा बिंदुओं का उपयोग करके जेनरेट करता है।
• BootstrapFewShotWithRandomSearch: BootstrapFewShot को कई बार लागू करता है और जेनरेट किए गए प्रदर्शनों पर रैंडम सर्च के साथ।
• COPRO: प्रत्येक चरण के लिए नए निर्देश और फ़ेव-शॉट उदाहरणों को जेनरेट और रिफ़ाइन करता है, उन्हें समन्वय आसेंट के साथ अनुकूलित करता है।
• MIPRO: बेयसियन ऑप्टिमाइजेशन का उपयोग करके निर्देश और फ़ेव-शॉट उदाहरणों को अनुकूलित करता है।

एक ऑप्टिमाइज़र चुनना

यदि आप सुनिश्चित नहीं हैं कि कहां से शुरू करें, तो BootstrapFewShotWithRandomSearch का उपयोग करें:

थोड़े से डेटा (10 उदाहरण) के लिए, BootstrapFewShot का उपयोग करें।
थोड़े अधिक डेटा (50 उदाहरण) के लिए, BootstrapFewShotWithRandomSearch का उपयोग करें।
बड़े डेटासेट (300+ उदाहरण) के लिए, MIPRO का उपयोग करें।
यहां BootstrapFewShotWithRandomSearch का उपयोग करने का तरीका दिया गया है:

from dspy.teleprompt import BootstrapFewShotWithRandomSearch

config = dict(max_bootstrapped_demos=4, max_labeled_demos=4, num_candidate_programs=10, num_threads=4)
teleprompter = BootstrapFewShotWithRandomSearch(metric=YOUR_METRIC_HERE, **config)
optimized_program = teleprompter.compile(YOUR_PROGRAM_HERE, trainset=YOUR_TRAINSET_HERE)

अनुकूलित कार्यक्रमों को सहेजना और लोड करना

एक बार जब आप एक कार्यक्रम को एक ऑप्टिमाइज़र के माध्यम से चला देते हैं, तो आप इसे भविष्य के उपयोग के लिए सहेज सकते हैं:

optimized_program.save(YOUR_SAVE_PATH)

एक सहेजे गए कार्यक्रम को लोड करें:

loaded_program = YOUR_PROGRAM_CLASS()
loaded_program.load(path=YOUR_SAVE_PATH)

उन्नत सुविधाएं: DSPy असर्ट

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

असर्ट का उपयोग करना

मॉडल पीढ़ी के बाद मान्यकरण कार्यों और असर्ट की घोषणा करें:

dspy.Suggest(
len(query) <= 100,
"प्रश्न छोटा और 100 अक्षरों से कम होना चाहिए",
)

dspy.Suggest(
validate_query_distinction_local(prev_queries, query),
"प्रश्न विशिष्ट होना चाहिए: " + "; ".join(f"{i+1}) {q}" for i, q in enumerate(prev_queries)),
)

असर्ट के साथ कार्यक्रमों को परिवर्तित करना

from dspy.primitives.assertions import assert_transform_module, backtrack_handler

baleen_with_assertions = assert_transform_module(SimplifiedBaleenAssertions(), backtrack_handler)

वैकल्पिक रूप से, कार्यक्रम पर सीधे असर्ट को सक्रिय करें:

baleen_with_assertions = SimplifiedBaleenAssertions().activate_assertions()

असर्ट-निर्देशित अनुकूलन

DSPy असर्ट DSPy अनुकूलन के साथ काम करते हैं, विशेष रूप से BootstrapFewShotWithRandomSearch के साथ, जिसमें सेटिंग्स जैसे शामिल हैं:

• असर्ट के साथ संकलन
• असर्ट के साथ संकलन + अनुमान

निष्कर्ष

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

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