प्रॉम्प्ट चेनिंग ट्यूटोरियल: प्रॉम्प्ट चेनिंग क्या है और इसका उपयोग कैसे करें?

क्या आपने कभी बिना निर्देश पढ़े कोई फर्नीचर जोड़ा है? किस्मत अच्छी हो तो कुछ हिस्से जुड़ भी जाएँ, लेकिन बिना चरण-दर-चरण मार्गदर्शन के नतीजा अक्सर उलझा हुआ होता है। यही चुनौती बड़े भाषा मॉडल (LLMs) को जटिल समस्याओं पर काम करते समय आती है। इन मॉडलों में अपार क्षमता है, पर जब किसी कार्य में विस्तृत, बहु-चरणीय तर्क की ज़रूरत होती है, तो वे अक्सर लक्ष्य से चूक जाते हैं।

एक ही प्रॉम्प्ट देने पर LLMs कई बार बहुत व्यापक, उथले या महत्वपूर्ण विवरणों से रहित उत्तर दे देते हैं। यह सीमा इसलिए आती है क्योंकि एक ही प्रॉम्प्ट में सारी आवश्यक संदर्भ-सूचना और पर्याप्त मार्गदर्शन समेटना मुश्किल होता है।

इसका समाधान है प्रॉम्प्ट चेनिंग।

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

यह ट्यूटोरियल मेरी “प्रॉम्प्ट इंजीनियरिंग: ज़ीरो से हीरो तक” ब्लॉग श्रृंखला का हिस्सा है:

1. सभी के लिए प्रॉम्प्ट इंजीनियरिंग
2. ज़ीरो-शॉट प्रॉम्प्टिंग
3. फ्यू-शॉट प्रॉम्प्टिंग
4. प्रॉम्प्ट चेनिंग

प्रॉम्प्ट चेनिंग क्या है?

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

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

आइए प्रॉम्प्ट चेनिंग के कुछ लाभ देखें:

प्रॉम्प्ट चेनिंग कैसे लागू करें

प्रॉम्प्ट चेनिंग लागू करने में किसी जटिल कार्य को तोड़ने और LLM को सुव्यवस्थित चरणों की श्रृंखला से ले जाने का एक व्यवस्थित तरीका शामिल है। 

देखते हैं आप प्रभावी ढंग से प्रॉम्प्ट चेन कैसे बना और चला सकते हैं।

उप-कार्यों की पहचान करें

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

उदाहरण के लिए, मान लीजिए आप LLM से जलवायु परिवर्तन पर एक व्यापक रिपोर्ट लिखवाना चाहते हैं। उप-कार्य कुछ इस प्रकार हो सकते हैं:

• ऐतिहासिक जलवायु डेटा का शोध
• वैज्ञानिक साहित्य से मुख्य निष्कर्षों का सार
• विभिन्न पारिस्थितिक तंत्रों पर जलवायु परिवर्तन के प्रभाव का विश्लेषण
• संभावित समाधान और शमन रणनीतियों का प्रस्ताव

प्रॉम्प्ट्स डिज़ाइन करें

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

ऊपर बताए उप-कार्यों के लिए हम ये प्रॉम्प्ट बना सकते हैं:

• उप-कार्य 1 प्रॉम्प्ट: "पिछली सदी में वैश्विक तापमान परिवर्तनों के प्रमुख रुझानों का सारांश दीजिए।"
• उप-कार्य 2 प्रॉम्प्ट: "पहचाने गए रुझानों के आधार पर, इन परिवर्तनों के कारणों पर चर्चा करने वाले प्रमुख वैज्ञानिक अध्ययनों की सूची बनाइए।"
• उप-कार्य 3 प्रॉम्प्ट: "सूचीबद्ध अध्ययनों के निष्कर्षों का सार बताइए, विशेषकर समुद्री पारिस्थितिक तंत्रों पर जलवायु परिवर्तन के प्रभाव पर।"
• उप-कार्य 4 प्रॉम्प्ट: "सारांशित निष्कर्षों के आधार पर समुद्री पारिस्थितिक तंत्रों पर जलवायु परिवर्तन के प्रभाव को कम करने के लिए तीन रणनीतियाँ सुझाइए।"

चेन निष्पादन

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

हमारे उदाहरण में, उप-कार्यों के आउटपुट कुछ यूँ दिखेंगे:

• उप-कार्य 1 का आउटपुट: "पिछली सदी में वैश्विक तापमान लगभग 1.2 डिग्री सेल्सियस बढ़ा है, और पिछले 20 वर्षों में उल्लेखनीय वृद्धि देखी गई है।"
• उप-कार्य 2 के लिए इनपुट: "चूँकि पिछली सदी में वैश्विक तापमान 1.2 डिग्री सेल्सियस बढ़ा है, इन परिवर्तनों के कारणों पर चर्चा करने वाले प्रमुख वैज्ञानिक अध्ययनों की सूची बनाइए।"
• उप-कार्य 2 का आउटपुट: "प्रमुख अध्ययनों में शामिल हैं: 'The Role of Greenhouse Gases in Global Warming' by Dr. Smith, 'Deforestation and Climate Change' by Dr. Jones, और 'Oceanic Changes and Climate Patterns' by Dr. Lee."
• उप-कार्य 3 के लिए इनपुट: "'The Role of Greenhouse Gases in Global Warming' by Dr. Smith, 'Deforestation and Climate Change' by Dr. Jones, और 'Oceanic Changes and Climate Patterns' by Dr. Lee के निष्कर्षों का सार बताइए, विशेषकर समुद्री पारिस्थितिक तंत्रों पर जलवायु परिवर्तन के प्रभाव पर।"

एरर हैंडलिंग

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

• एरर चेक 1: हर आउटपुट के बाद जाँचें कि सूचना प्रासंगिक और पूरी है या नहीं। यदि वैश्विक तापमान रुझानों का सार अधूरा है, तो LLM से अतिरिक्त विवरण देने को कहें।
• फॉलबैक प्रॉम्प्ट: यदि LLM प्रासंगिक वैज्ञानिक अध्ययन सूचीबद्ध करने में विफल रहे, तो अधिक विशिष्ट प्रॉम्प्ट दें जैसे "पिछले दशक के पाँच सहकर्मी-समीक्षित अध्ययन सूचीबद्ध करें जो वैश्विक तापमान वृद्धि के कारणों पर चर्चा करते हैं।"

इम्प्लीमेंटेशन

आइए देखें इसे Python में कैसे लागू करें!

चरण 1: परिवेश सेटअप

पहले आवश्यक लाइब्रेरी इम्पोर्ट करें। हम openai पैकेज से OpenAI क्लास और परिवेश वेरिएबल्स संभालने के लिए os का उपयोग करेंगे।

import openai
import os

API की-ज़ैसी संवेदनशील जानकारी को सुरक्षित रखना बेहद ज़रूरी है। एक तरीका है API की को परिवेश वेरिएबल के रूप में सेट करना। आप इसे OpenAI API की का उपयोग करके कर सकते हैं।

os.environ['OPENAI_API_KEY'] = 'your-api-key-here'

सुनिश्चित करें कि 'your-api-key-here' को अपनी वास्तविक OpenAI API की से बदलें।

API की सेट होने के बाद, आप OpenAI क्लाइंट को इनिशियलाइज़ कर सकते हैं। यही क्लाइंट OpenAI की सेवाओं को API कॉल करने में काम आएगा।

Client = OpenAI ()

चरण 2: OpenAI के चैट कंप्लीशंस API से संवाद हेतु फ़ंक्शन परिभाषित करना

अब हम OpenAI के चैट कंप्लीशंस API से संवाद करने के लिए एक Python फ़ंक्शन बनाएँगे। यह फ़ंक्शन API को प्रॉम्प्ट करेगा और जनरेटेड प्रतिक्रिया लौटाएगा।

def get_completion(prompt, model="gpt-3.5-turbo"):
    try:
        response = client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "user", "content": prompt}
            ],
            temperature=0,
        )
        return response.choices[0].message.content
    except Exception as e:
        print(f"An error occurred: {e}")
        return None

आइए इस फ़ंक्शन को समझें—यह:

• एक प्रॉम्प्ट और वैकल्पिक मॉडल पैरामीटर लेता है।
• चैट कंप्लीशंस एंडपॉइंट का उपयोग करते हुए OpenAI को API कॉल करता है।
• सिस्टम संदेश और यूज़र संदेश (प्रॉम्प्ट) के साथ वार्तालाप सेट करता है।
• अधिक निर्धारक आउटपुट के लिए टेम्परेचर 0 रखता है (रचनात्मक आउटपुट के लिए टेम्परेचर बढ़ाएँ)।
• रिस्पॉन्स की सामग्री लौटाता है या एरर होने पर None देता है।

चरण 3: कई प्रॉम्प्ट्स को चेन करना

अब हम एक Python फ़ंक्शन बनाएँगे जो कई प्रॉम्प्ट्स को चेन करता है—एक का आउटपुट अगले के इनपुट के रूप में देता है।

def prompt_chain(initial_prompt, follow_up_prompts):
    result = get_completion(initial_prompt)
    if result is None:
        return "Initial prompt failed."
    print(f"Initial output: {result}\n")
    for i, prompt in enumerate(follow_up_prompts, 1):
        full_prompt = f"{prompt}\n\nPrevious output: {result}"
        result = get_completion(full_prompt)
        if result is None:
            return f"Prompt {i} failed."
        print(f"Step {i} output: {result}\n")
    return result

prompt_chain फ़ंक्शन प्रॉम्प्ट चेनिंग लागू करता है। यह:

• आरंभिक प्रॉम्प्ट से शुरू करता है और उसका कंप्लीशन लेता है।
• फॉलो-अप प्रॉम्प्ट्स की सूची पर इटररेट करता है।
• हर फॉलो-अप प्रॉम्प्ट के लिए, उसे पिछले आउटपुट के साथ जोड़ता है, उसका कंप्लीशन लेता है और परिणाम अपडेट करता है।
• किसी भी चरण में विफलता पर एरर संदेश लौटाता है।
• हर चरण का आउटपुट दृश्यता के लिए प्रिंट होता है।

चरण 4: उदाहरण उपयोग

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

initial_prompt = "Summarize the key trends in global temperature changes over the past century."
follow_up_prompts = [
    "Based on the trends identified, list the major scientific studies that discuss the causes of these changes.",
    "Summarize the findings of the listed studies, focusing on the impact of climate change on marine ecosystems.",
    "Propose three strategies to mitigate the impact of climate change on marine ecosystems based on the summarized findings."
]
final_result = prompt_chain(initial_prompt, follow_up_prompts)
print("Final result:", final_result)

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

यह सब साथ में कैसे काम करता है

आइए प्रक्रिया का सार देखें:

1. आरंभिक प्रॉम्प्ट तापमान रुझानों का सार देता है।
2. पहला फॉलो-अप इसी सार का उपयोग कर प्रासंगिक अध्ययन ढूँढता है।
3. दूसरा फॉलो-अप इन अध्ययनों के समुद्री पारिस्थितिक तंत्र से जुड़े निष्कर्षों का सार देता है।
4. अंतिम प्रॉम्प्ट इन सब सूचनाओं का उपयोग शमन रणनीतियाँ प्रस्तावित करने में करता है।

यह चेनिंग जटिल प्रश्नों के लिए चरणबद्ध तरीका देती है, जहाँ हर चरण पिछले से प्राप्त सूचना पर आधारित होता है।

प्रॉम्प्ट चेनिंग तकनीकें

प्रॉम्प्ट चेनिंग को विभिन्न प्रकार के कार्यों और आवश्यकताओं के अनुसार कई तरीकों से लागू किया जा सकता है। यहाँ हम तीन प्रमुख तकनीकों को देखते हैं: क्रमिक (Sequential) चेनिंग, सशर्त (Conditional) चेनिंग, और लूपिंग चेनिंग।

क्रमिक चेनिंग

क्रमिक चेनिंग में प्रॉम्प्ट्स को एक सीधी, रैखिक श्रृंखला में जोड़ा जाता है। हर प्रॉम्प्ट पिछले के आउटपुट पर निर्भर करता है, जिससे जानकारी और कार्यों का चरण-दर-चरण प्रवाह बनता है। यह तकनीक उन कार्यों के लिए आदर्श है जिन्हें एक तार्किक प्रगति चाहिए, जैसे:

• पाठ संक्षेपण: लंबे दस्तावेज़ को खंडों में बाँटकर हर खंड का सार बनाना, फिर उन सारों को जोड़कर एक सुसंगत समग्र सार बनाना।
• कोड जनरेशन: कोड स्निपेट्स को चरणों में बनाना—पहले फ़ंक्शन परिभाषाएँ, फिर उनका इम्प्लीमेंटेशन, और अंत में टेस्ट केस लिखना।

पिछले सेक्शन का कोड स्निपेट क्रमिक चेनिंग का एक उदाहरण है।

सशर्त चेनिंग

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

देखते हैं कि सेंटिमेंट विश्लेषण करने के लिए सशर्त चेनिंग कैसे लागू कर सकते हैं।

def analyze_sentiment(text):
    prompt = f"Analyze the sentiment of the following text and respond with only one word - 'positive', 'negative', or 'neutral': {text}"
    sentiment = get_completion(prompt)
    return sentiment.strip().lower()

def conditional_prompt_chain(initial_prompt):
    result = get_completion(initial_prompt)
    if result is None:
        return "Initial prompt failed."
    print(f"Initial output: {result}\n")
    sentiment = analyze_sentiment(result)
    print(f"Sentiment: {sentiment}\n")
    if sentiment == 'positive':
        follow_up = "Given this positive outlook, what are three potential opportunities we can explore?"
    elif sentiment == 'negative':
        follow_up = "Considering these challenges, what are three possible solutions we can implement?"
    else:  # neutral
        follow_up = "Based on this balanced view, what are three key areas we should focus on for a comprehensive approach?"
    final_result = get_completion(f"{follow_up}\n\nContext: {result}")
    return final_result

# Example usage
initial_prompt = "Analyze the current state of renewable energy adoption globally."
final_result = conditional_prompt_chain(initial_prompt)
print("Final result:", final_result)

पहले हम नया फ़ंक्शन analyze_sentiment() परिभाषित करते हैं जो दिए गए पाठ का सेंटिमेंट निर्धारित करता है। फिर conditional_prompt_chain() में हम अक्षय ऊर्जा अपनाने पर आरंभिक प्रॉम्प्ट से शुरू करते हैं। आरंभिक उत्तर मिलने के बाद, उसका सेंटिमेंट विश्लेषण करते हैं। सेंटिमेंट के आधार पर अलग फॉलो-अप प्रॉम्प्ट चुनते हैं:

• सकारात्मक सेंटिमेंट पर अवसरों के बारे में पूछते हैं।
• नकारात्मक सेंटिमेंट पर समाधानों के बारे में पूछते हैं।
• तटस्थ सेंटिमेंट पर प्रमुख फोकस क्षेत्रों के बारे में पूछते हैं।

चुना गया फॉलो-अप प्रॉम्प्ट आरंभिक उत्तर के संदर्भ के साथ मॉडल को भेजा जाता है। अंतिम परिणाम इसी सशर्त फॉलो-अप प्रॉम्प्ट का उत्तर होता है।

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

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

लूपिंग चेनिंग

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

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

आइए पाठ की पूर्णता जाँचने के लिए लूपिंग चेनिंग कैसे लागू होगी, देखें:

def check_completeness(text):
    prompt = f"Analyze the following text and respond with only 'complete' if it covers all necessary aspects, or 'incomplete' if more information is needed:\n\n{text}"
    response = get_completion(prompt)
    return response.strip().lower() == 'complete'

def looping_prompt_chain(initial_prompt, max_iterations=5):
    current_response = get_completion(initial_prompt)
    if current_response is None:
        return "Initial prompt failed."
    print(f"Initial output: {current_response}\n")
    iteration = 0
    while iteration < max_iterations:
        if check_completeness(current_response):
            print(f"Complete response achieved after {iteration + 1} iterations.")
            return current_response
        print(f"Iteration {iteration + 1}: Response incomplete. Expanding...")
        expand_prompt = f"The following response is incomplete. Please expand on it to make it more comprehensive:\n\n{current_response}"
        new_response = get_completion(expand_prompt)
        if new_response is None:
            return f"Expansion failed at iteration {iteration + 1}."
        current_response = new_response
        print(f"Expanded response: {current_response}\n")
        iteration += 1
    print(f"Maximum iterations ({max_iterations}) reached without achieving completeness.")
    return current_response

# Example usage
initial_prompt = "Explain the process of photosynthesis."
final_result = looping_prompt_chain(initial_prompt)
print("Final result:", final_result)

पहले हम check_completeness() नामक फ़ंक्शन परिभाषित करते हैं जो यह निर्धारित करता है कि दिया गया उत्तर पूर्ण है या और जानकारी चाहिए।

इसके बाद looping_prompt_chain() में हम प्रकाश संश्लेषण पर आरंभिक प्रॉम्प्ट से शुरू करते हैं। आरंभिक उत्तर मिलने के बाद हम एक लूप में प्रवेश करते हैं:

• हम check_completeness() से जाँचते हैं कि वर्तमान उत्तर पूर्ण है या नहीं।
• यदि पूर्ण है, तो लूप से निकलकर परिणाम लौटाते हैं।
• यदि अधूरा है, तो पिछले उत्तर को विस्तार देने हेतु नया प्रॉम्प्ट बनाते हैं।
• फिर इसी विस्तार प्रॉम्प्ट के आधार पर नया उत्तर लेते हैं।

यह प्रक्रिया तब तक चलती है जब तक उत्तर पूर्ण न माना जाए या अधिकतम इटरेशंस (डिफ़ॉल्ट 5) न हो जाएँ।

लूप सुनिश्चित करता है कि हम उत्तर को निरंतर परिष्कृत और विस्तृत करते रहें—या तो पूर्णता पर पहुँचें, या इटरेशन सीमा पर।

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

प्रॉम्प्ट चेनिंग के व्यावहारिक उपयोग

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

दस्तावेज़ों पर प्रश्नोत्तर

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

इसे कैसे लागू करें, देखें:

def split_document(document, max_length=1000):
    """Split the document into sections of approximately max_length characters."""
    words = document.split()
    sections = []
    current_section = []
    current_length = 0
    for word in words:
        if current_length + len(word) + 1 > max_length and current_section:
            sections.append(' '.join(current_section))
            current_section = []
            current_length = 0
        current_section.append(word)
        current_length += len(word) + 1
    if current_section:
        sections.append(' '.join(current_section))
    return sections

def summarize_section(section):
    prompt = f"Summarize the following text in a concise manner:\n\n{section}"
    return get_completion(prompt)

def answer_question(summaries, question):
    context = "\n\n".join(summaries)
    prompt = f"Given the following context, answer the question:\n\nContext:\n{context}\n\nQuestion: {question}"
    return get_completion(prompt)

def document_qa(document, questions):
    # Step 1: Split the document
    sections = split_document(document)
    print(f"Document split into {len(sections)} sections.")
    # Step 2: Summarize each section
    summaries = []
    for i, section in enumerate(sections):
        summary = summarize_section(section)
        summaries.append(summary)
        print(f"Section {i+1} summarized.")
    # Step 3: Answer questions
    answers = []
    for question in questions:
        answer = answer_question(summaries, question)
        answers.append((question, answer))
    return answers

# Example usage
long_document = """
[Insert a long document here. For brevity, we are using a placeholder. 
In a real scenario, this would be a much longer text, maybe several 
paragraphs or pages about a specific topic.]
This is a long document about climate change. It discusses various aspects 
including causes, effects, and potential solutions. The document covers 
topics such as greenhouse gas emissions, rising global temperatures, 
melting ice caps, sea level rise, extreme weather events, impact on 
biodiversity, and strategies for mitigation and adaptation.
The document also explores the economic implications of climate change, 
international agreements like the Paris Agreement, renewable energy 
technologies, and the role of individual actions in combating climate change.
[Continue with more detailed information about climate change...]
"""
questions = [
    "What are the main causes of climate change mentioned in the document?",
    "What are some of the effects of climate change discussed?",
    "What solutions or strategies are proposed to address climate change?"
]
results = document_qa(long_document, questions)
for question, answer in results:
    print(f"\nQ: {question}")
    print(f"A: {answer}")

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

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

तथ्य-पुष्टि के साथ पाठ जनरेशन

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

def generate_text(topic):
    prompt = f"Write a short paragraph about {topic}."
    return get_completion(prompt)

def extract_facts(text):
    prompt = f"Extract the key factual claims from the following text, listing each claim on a new line:\n\n{text}"
    return get_completion(prompt)

def verify_facts(facts):
    verified_facts = []
    for fact in facts.split('\n'):
        if fact.strip():
            prompt = f"Verify the following statement and respond with 'True' if it's factually correct, 'False' if it's incorrect, or 'Uncertain' if it can't be verified without additional research: '{fact}'"
            verification = get_completion(prompt)
            verified_facts.append((fact, verification.strip()))
    return verified_facts

def revise_text(original_text, verified_facts):
    context = "Original text:\n" + original_text + "\n\nVerified facts:\n"
    for fact, verification in verified_facts:
        context += f"- {fact}: {verification}\n"
    
    prompt = f"{context}\n\nRewrite the original text, keeping the verified facts, removing or correcting any false information, and indicating any uncertain claims as 'It is claimed that...' or similar phrasing."
    return get_completion(prompt)

def text_generation_with_verification(topic):
    print(f"Generating text about: {topic}")
    # Step 1: Generate initial text
    initial_text = generate_text(topic)
    print("\nInitial Text:")
    print(initial_text)
    # Step 2: Extract facts
    extracted_facts = extract_facts(initial_text)
    print("\nExtracted Facts:")
    print(extracted_facts)
    # Step 3: Verify facts
    verified_facts = verify_facts(extracted_facts)
    print("\nVerified Facts:")
    for fact, verification in verified_facts:
        print(f"- {fact}: {verification}")
    # Step 4: Revise text
    revised_text = revise_text(initial_text, verified_facts)
    print("\nRevised Text:")
    print(revised_text)
    return revised_text

# Example usage
topic = "the effects of climate change on polar bears"
final_text = text_generation_with_verification(topic)

text_generation_with_verification() फ़ंक्शन संपूर्ण प्रक्रिया संभालता है। यह पहले generate_text() से विषय पर एक अनुच्छेद जनरेट करता है। फिर extract_facts() इस पाठ से प्रमुख दावों को निकालता है। verify_facts() इन दावों की जाँच करता है और उन्हें True, False या Uncertain के रूप में लेबल करता है। अंत में revise_text() मूल पाठ को दोबारा लिखता है, गलतियों को सुधारता है और अनिश्चित जानकारी को रेखांकित करता है। इससे अंतिम पाठ सूचनाप्रद और सटीक बनता है।

प्रॉम्प्ट चेनिंग कई चरणों में घटित होती है: आरंभिक टेक्स्ट जनरेशन, उससे तथ्य निकालना, हर तथ्य का सत्यापन, और सत्यापित तथ्यों के आधार पर पाठ का पुनर्लेखन।

जब आप इस कोड को "the effects of climate change on polar bears" जैसे विषय के साथ चलाते हैं, तो यह विषय पर प्रारंभिक पाठ बनाएगा, उससे तथ्य निकालेगा, हर तथ्य का सत्यापन करेगा, और सत्यापित तथ्यों के आधार पर पाठ को संशोधित करेगा, ताकि अंतिम आउटपुट अधिक सटीक हो। आप अपना मनचाहा विषय भी दे सकते हैं!

डिबगिंग के साथ कोड जनरेशन

प्रॉम्प्ट चेनिंग से कोड लिखना और फिर उसे जाँचना विकास को तेज़ कर सकता है। यह तरीका सुनिश्चित करता है कि कोड अपेक्षित रूप से कार्य करे—सिर्फ़ रन होने से आगे बढ़कर।

def generate_code(task):
    prompt = f"Write a Python function to {task}. Include comments explaining the code."
    return get_completion(prompt)

def generate_test_cases(code):
    prompt = f"Given the following Python code, generate 3 test cases to verify its functionality. Include both input and expected output for each test case:\n\n{code}"
    return get_completion(prompt)

def run_tests(code, test_cases):
    prompt = f"""
    Given the following Python code and test cases, run the tests and report the results. 
    If any tests fail, explain why and suggest fixes.
    Code:
    {code}
    Test Cases:
    {test_cases}
    For each test case, respond with:
    1. "PASS" if the test passes
    2. "FAIL" if the test fails, along with an explanation of why it failed and a suggested fix
    """
    return get_completion(prompt)

def debug_code(code, test_results):
    prompt = f"""
    Given the following Python code and test results, debug the code to fix any issues.
    Provide the corrected code along with explanations of the changes made.
    Original Code:
    {code}
    Test Results:
    {test_results}
    """
    return get_completion(prompt)

def code_generation_with_debugging(task):
    print(f"Generating code for task: {task}")
    # Step 1: Generate initial code
    initial_code = generate_code(task)
    print("\nInitial Code:")
    print(initial_code)
    # Step 2: Generate test cases
    test_cases = generate_test_cases(initial_code)
    print("\nGenerated Test Cases:")
    print(test_cases)
    # Step 3: Run tests
    test_results = run_tests(initial_code, test_cases)
    print("\nTest Results:")
    print(test_results)
    # Step 4: Debug code if necessary
    if "FAIL" in test_results:
        print("\nDebugging code...")
        debugged_code = debug_code(initial_code, test_results)
        print("\nDebugged Code:")
        print(debugged_code)    
        # Optionally, you can run tests again on the debugged code
        print("\nRe-running tests on debugged code...")
        final_test_results = run_tests(debugged_code, test_cases)
        print("\nFinal Test Results:")
        print(final_test_results)    
        return debugged_code
    else:
        print("\nAll tests passed. No debugging necessary.")
        return initial_code

# Example usage
task = "calculate the factorial of a number"
final_code = code_generation_with_debugging(task)

code_generation_with_debugging() संपूर्ण प्रक्रिया का प्रबंधन करता है। पहले generate_code() दिए गए कार्य के लिए Python कोड लिखता है। फिर generate_test_cases() इस कोड के लिए टेस्ट केस बनाता है। run_tests() जाँचता है कि कोड ये टेस्ट पास करता है या नहीं। अगर कोई टेस्ट फेल होता है, तो debug_code() समस्याएँ ठीक करने की कोशिश करता है।

ध्यान दें कि हर चरण पिछले पर आधारित है—कोड लिखना, टेस्ट बनाना, उन्हें चलाना और समस्याएँ सुधारना। इससे कोडिंग कार्य छोटे, आसान चरणों में बँट जाता है। यह तरीका दिखाता है कि प्रॉम्प्ट चेनिंग कोडिंग जैसे जटिल कार्यों को कैसे सँभाल सकती है—बिलकुल वैसे ही जैसे प्रोग्रामर काम करते हैं: कोड लिखना, टेस्ट करना और समस्याएँ ठीक करना।

जब आप इसे "calculate the factorial of a number" जैसे कार्य के साथ चलाते हैं, तो यह फैक्टोरियल निकालने के लिए आरंभिक Python कोड बनाएगा, उसके टेस्ट केस तैयार करेगा, टेस्ट चलाकर रिपोर्ट देगा, और यदि कोई टेस्ट फेल हो, तो डिबग कर दोबारा टेस्ट चलाएगा।

बहु-चरणीय तर्क वाले कार्य

प्रॉम्प्ट चेनिंग ऐसे जटिल समस्याओं को हल कर सकती है जिनमें कई तर्क-चरणों की ज़रूरत होती है, जैसे गणितीय कथ्य-प्रश्न या तार्किक पहेलियाँ। हर चरण पिछले पर आधारित होता है, जिससे संरचित और गहन दृष्टिकोण सुनिश्चित होता है।

def solve_step_by_step(problem):
    steps = []
    current_problem = problem
    while True:
        prompt = f"Solve the following problem step by step. Provide the next step only and explain it clearly:\n\n{current_problem}"
        step = get_completion(prompt)
        if step is None or "solution" in step.lower():
            break
        steps.append(step)
        current_problem = f"{current_problem}\n\n{step}"
        print(f"Step {len(steps)}: {step}\n")
    return steps

def combine_steps(steps):
    combined_steps = "\n".join(steps)
    prompt = f"Combine the following steps into a coherent solution for the problem:\n\n{combined_steps}"
    return get_completion(prompt)

def multi_step_reasoning(problem):
    print(f"Solving problem: {problem}")    
    # Step 1: Solve step by step
    steps = solve_step_by_step(problem)    
    # Step 2: Combine steps into a final solution
    final_solution = combine_steps(steps)
    print("\nFinal Solution:")
    print(final_solution)
    return final_solution

# Example usage
problem = "A car travels 60 miles per hour for 2 hours, then 40 miles per hour for 3 hours. What is the total distance traveled by the car?"
final_solution = multi_step_reasoning(problem)

पहले solve_step_by_step() समस्या को छोटे भागों में तोड़ता है—मॉडल से एक-एक कर अगले चरण माँगता है और हर चरण सहेजता है। फिर combine_steps() इन चरणों को लेकर एक स्पष्ट, सुसंगत समाधान में जोड़ता है। पूरे दौरान get_completion() OpenAI API से संवाद संभालता है।

इस उदाहरण में समस्या है: "एक कार 2 घंटे तक 60 मील प्रति घंटा और फिर 3 घंटे तक 40 मील प्रति घंटा की रफ्तार से चलती है। कुल दूरी कितनी हुई?"

यह कोड समस्या को छोटे तर्क-चरणों में तोड़ेगा, हर चरण एकत्र कर प्रिंट करेगा, और अंत में उन्हें जोड़कर अंतिम समाधान तैयार कर प्रिंट करेगा।

प्रॉम्प्ट चेनिंग के लिए सर्वोत्तम प्रथाएँ

प्रॉम्प्ट चेनिंग की प्रभावशीलता अधिकतम करने के लिए कुछ सर्वोत्तम प्रथाओं का पालन ज़रूरी है। ये आपके चेन को मज़बूत, सटीक और कुशल बनाती हैं, जिससे बेहतर परिणाम और अधिक विश्वसनीय LLM अनुप्रयोग बनते हैं।

प्रॉम्प्ट डिज़ाइन

स्पष्ट और संक्षिप्त प्रॉम्प्ट्स का उपयोग LLM से सर्वश्रेष्ठ परिणाम पाने के लिए आवश्यक है। सीधे-सादे प्रॉम्प्ट्स से मॉडल आपकी आवश्यकता आसानी से समझ लेता है, भ्रम घटता है और उत्तरों की गुणवत्ता बढ़ती है।

कुछ सुझाव:

• सरल भाषा का प्रयोग करें: जटिल शब्दों और तकनीकी जार्गन से बचें।
• सीधे रहें: बिना अनावश्यक विवरण जोड़े स्पष्ट रूप से बताइए कि आपको क्या चाहिए।
• एक कार्य पर केंद्रित रहें: हर प्रॉम्प्ट एक ही कार्य या प्रश्न को संबोधित करे। 

उदाहरण:

• इसके बजाय: "क्या आप कृपया पिछली सदी के वैश्विक तापमान के ऐतिहासिक रुझानों के प्रमुख बिंदुओं का सार दे सकते हैं, खास बदलावों और उनके संभावित कारणों पर ध्यान देते हुए, साथ ही ऐसे उल्लेखनीय घटनाक्रम जो इन रुझानों को प्रभावित कर सकते थे?"
• उपयोग करें: "पिछली सदी में वैश्विक तापमान के ऐतिहासिक रुझानों के प्रमुख बिंदुओं का सार दीजिए।"

अच्छी संरचना वाले प्रॉम्प्ट्स भी आवश्यक हैं ताकि LLM कार्य के तार्किक प्रवाह का पालन कर सके। आपके प्रॉम्प्ट्स संगठित और सुसंगत होंगे तो मॉडल बेहतर समझेगा और उपयुक्त प्रतिक्रिया देगा।

कुछ सुझाव:

• जटिल कार्यों को तोड़ें: कार्य को छोटे, प्रबंधनीय चरणों में बाँटें।
• तार्किक प्रवाह सुनिश्चित करें: हर प्रॉम्प्ट पिछले पर बने और तर्कसंगत रूप से अगले तक ले जाए।

इस तरह की संरचना LLM को चरण-दर-चरण मार्गदर्शन देती है, जिससे बेहतर और अधिक सटीक उत्तर मिलते हैं। उदाहरण:

• चरण 1: "पिछली सदी में वैश्विक तापमान में हुए प्रमुख बदलावों की सूची बनाइए।"
• चरण 2: "हर प्रमुख बदलाव के संभावित कारणों की पहचान कीजिए।"

प्रयोग

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

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

दोहराए गए परिष्करण

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

• प्रारंभिक प्रॉम्प्ट: "जलवायु परिवर्तन के प्रभाव का वर्णन कीजिए।"
• परिष्कृत प्रॉम्प्ट: "पिछले दशक में तटीय पारिस्थितिक तंत्रों पर जलवायु परिवर्तन के प्रभाव का वर्णन कीजिए।"

चेन संरचना परिष्कृत करें

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

एरर हैंडलिंग

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

मॉनिटरिंग और लॉगिंग

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

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

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

निष्कर्ष

इस लेख में हमने प्रॉम्प्ट चेनिंग को समझा—एक ऐसी तकनीक जो जटिल कार्यों को छोटे, अधिक प्रबंधनीय प्रॉम्प्ट्स में बाँटकर LLMs के प्रदर्शन को बेहतर बनाती है। हमने विभिन्न चेनिंग विधियाँ, उनके उपयोग परिदृश्य, और सर्वोत्तम प्रथाएँ देखीं, ताकि आप विविध उपयोग मामलों में LLMs का प्रभावी लाभ उठा सकें।

यदि आप प्रॉम्प्ट इंजीनियरिंग के बारे में और सीखना चाहते हैं, तो ये लेख देखें:

• प्रॉम्प्ट कंप्रेशन: Python उदाहरणों के साथ एक गाइड
• बफ़र ऑफ़ थॉट्स (BoT)
• DSPy क्या है? यह कैसे काम करता है, उपयोग के मामले, और संसाधन
• प्रॉम्प्ट ट्यूनिंग समझना