प्रॉम्प्ट इंजीनियरिंग

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

अच्छे से लिखे गए प्रॉम्प्ट में ये चीज़ें शामिल होती हैं:

  • इससे पता चलता है कि एलएलएम को अपना जवाब कैसे तैयार करना चाहिए.
  • इसमें कई कॉम्पोनेंट होते हैं. इनके वर्शन बनाए जा सकते हैं, इनकी जांच की जा सकती है, और समय के साथ इन्हें बेहतर बनाया जा सकता है.
  • यह अलग-अलग टीमों के साथ मिलकर काम करने के लिए, शेयर किए गए आर्टफ़ैक्ट के तौर पर काम कर सकता है.

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

इस पूरे मॉड्यूल में, हम एक उदाहरण का इस्तेमाल करेंगे: BlogBuddy, एक एआई की मदद से काम करने वाला राइटिंग असिस्टेंट है. यह CyberAgent के Prompt API के इस्तेमाल से प्रेरित है.

BlogBuddy सिस्टम ब्लूप्रिंट के लिए, जनरेटिव एआई मॉड्यूल पर वापस जाएं.

प्रॉम्प्ट कॉम्पोनेंट

हर प्रॉम्प्ट कॉम्पोनेंट, मॉडल के व्यवहार को तय करने में खास भूमिका निभाता है.

  • संदर्भ: इससे मॉडल की भूमिका और डोमेन तय होता है, ताकि उसे पता चल सके कि उसे कैसे काम करना है.
  • निर्देश: इससे मॉडल को कोई टास्क असाइन किया जाता है.
  • इनपुट वैरिएबल: ये किसी खास स्थिति के हिसाब से कॉन्टेक्स्ट होते हैं. इन्हें आपका ऐप्लिकेशन रीयल-टाइम में उपलब्ध कराता है.
  • आउटपुट फ़ॉर्मैट: इससे यह तय होता है कि आउटपुट का स्ट्रक्चर कैसा होना चाहिए. उदाहरण के लिए, आपको JSON फ़ॉर्मैट में आउटपुट चाहिए.
  • उदाहरण: दिखाएं कि एक या उससे ज़्यादा अन्य इनपुट के लिए, टास्क को कैसे पूरा किया जाना चाहिए.
  • सीमाएं: जवाब को एक जैसा, सुरक्षित, और ब्रैंड के मुताबिक रखने के लिए, सीमाएं तय करें.

आपके प्रॉम्प्ट में इनमें से कुछ या सभी कॉम्पोनेंट शामिल हो सकते हैं. यहां दिए गए उदाहरण में, BlogBuddy की लेखन में मदद करने वाली सुविधा के लिए इन कॉम्पोनेंट को दिखाया गया है.

### Context

You are a writing assistant for blog authors.
Your job is to generate helpful, concise, and engaging content.

### Instruction

Generate 3 alternative titles for the user's blog post with a given style.

### Input variables

Here is the content of the blog post:
${blogPostContent}

Here is the desired style:
${titleStyle}

### Output format

Return valid JSON ONLY, in the following exact structure:
{
  "titles": ["Title option 1", "Title option 2", "Title option 3"]
}

### Examples

Example input:
{
  "blogPostContent": "I finally visited the small neighborhood café I've been eyeing for months...",
  "titleStyle": "friendly"
}

Example output:
{
  "titles": [
    "A First Visit to the Neighborhood Café",
    "Trying the Café I've Wanted to Visit for Months",
    "My Experience at a Long-Awaited Local Spot"
  ]
}
### Constraints

- Each title must be under 128 characters.
- Titles must be original, not copied verbatim from the draft.
- Keep the tone natural and human. Avoid emojis unless explicitly requested.
- Avoid sensationalism or clickbait.
- If the draft includes multiple topics, choose the most prominent topic.

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

सिस्टम प्रॉम्प्ट बनाम उपयोगकर्ता के प्रॉम्प्ट

प्रॉम्प्ट के कुछ कॉम्पोनेंट हार्ड-कोड किए जाते हैं, जबकि अन्य कॉम्पोनेंट को उपयोगकर्ता सप्लाई कर सकता है:

  • सिस्टम प्रॉम्प्ट, ऐप्लिकेशन डेवलपर देते हैं. इससे मॉडल के पूरे व्यवहार के बारे में पता चलता है. यह मॉडल की भूमिका, जवाब देने का तरीका, आउटपुट फ़ॉर्मैट (जैसे कि स्ट्रिक्ट JSON स्कीमा) और कोई भी ग्लोबल कंस्ट्रेंट सेट कर सकता है. सिस्टम प्रॉम्प्ट में, सुरक्षा और ज़िम्मेदारी से जुड़ी ज़रूरी शर्तों को भी कोड किया जाता है. यह सभी अनुरोधों के लिए एक जैसा होता है. साथ ही, मॉडल के व्यवहार के लिए एक मज़बूत आधार उपलब्ध कराता है.

  • उपयोगकर्ता के प्रॉम्प्ट में, ऐसा अनुरोध शामिल होता है जिससे आउटपुट मिलता है. उपयोगकर्ता किसी खास टास्क का अनुरोध करता है. इसमें कुछ वैरिएबल शामिल हो सकते हैं. उदाहरण के लिए, "इस पोस्ट के लिए तीन टाइटल दिखाओ", "इस पैराग्राफ़ को जारी रखो" या "इस कॉपी को ज़्यादा फ़ॉर्मल बनाओ."

ज़्यादातर जनरेटिव एआई एपीआई, आपको प्रॉम्प्ट को मैसेज के ऐरे के तौर पर स्ट्रक्चर करने की सुविधा देते हैं. हर मैसेज में एक भूमिका (सिस्टम या उपयोगकर्ता) और कॉन्टेंट होता है. इससे, हर अनुरोध के हिसाब से मिलने वाले इनपुट से, स्थिर और सामान्य निर्देशों को अलग करना आसान हो जाता है.

यह कैसे तय किया जाता है कि सिस्टम प्रॉम्प्ट में कौनसे कॉम्पोनेंट शामिल किए जाएं और उपयोगकर्ता को कौनसे कॉम्पोनेंट तय करने के लिए छोड़ दिए जाएं? जवाब इस बात पर निर्भर करता है कि उपयोगकर्ता अनुभव कितना बेहतर है और आपका मॉडल कितना बेहतर है.

इस्तेमाल के सीमित उदाहरण

इस्तेमाल के खास उदाहरणों के लिए, ज़्यादातर प्रॉम्प्ट को सिस्टम प्रॉम्प्ट में पहले से तय किया जा सकता है. उदाहरण के लिए, BlogBuddy में उपयोगकर्ता टाइटल दिखाएं पर क्लिक करके, अपने ड्राफ़्ट के लिए जनरेट किए गए टाइटल के सुझावों की सूची देख सकते हैं.

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

Prompt API की मदद से इसे बनाने के लिए, हम पूरे सेशन के लिए सिस्टम-लेवल के व्यवहार को तय करने के लिए initialPrompts का इस्तेमाल करेंगे:

// Defines stable behavior for the entire session
const session = await LanguageModel.create({
  initialPrompts: [
    {
      role: "system",
      content: `You are a blog-writing assistant.
      Your task is to generate high-quality titles for blog posts.
      Always respond in concise, friendly language.
      Return exactly 3 alternative titles.
      Produce valid JSON with a "titles" array of strings.`
    }
  ]
});

जब उपयोगकर्ता टाइटल दिखाएं पर क्लिक करता है, तो मौजूदा कॉन्टेंट के लिए प्रॉम्प्ट दिखता है:

// The only variable input is the blog content
const result = await session.prompt(blogContent);

समय के साथ, उपयोगकर्ता ज़्यादा सुविधाओं और कंट्रोल की मांग कर सकते हैं. इस मामले में, इंटरफ़ेस कंट्रोल की मदद से कुछ कॉम्पोनेंट को उपयोगकर्ता के प्रॉम्प्ट में ले जाया जा सकता है. उदाहरण के लिए, स्टाइल या टोन के स्पेसिफ़िकेशन का ड्रॉप-डाउन मेन्यू.

हालांकि, बहुत ज़्यादा स्ट्रक्चर्ड कार्रवाइयों से उपयोगकर्ता अनुभव खराब हो सकता है. ऐसा होने पर, आपको ज़्यादा ओपन-एंडेड डिज़ाइन पर स्विच करना चाहिए. इससे उपयोगकर्ताओं को ज़्यादातर प्रॉम्प्ट खुद तय करने की अनुमति मिलती है. इस डिज़ाइन को ऑप्टिमाइज़ करने के बारे में ज़्यादा जानने के लिए, यूज़र एक्सपीरियंस पैटर्न मॉड्यूल देखें.

ज़्यादा जानकारी वाले उपयोगकर्ता के प्रॉम्प्ट पर आधारित टास्क

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

फ़्लेक्सिबल टास्क के लिए, उपयोगकर्ता को ज़्यादा जानकारी देनी होती है, क्योंकि विकल्पों की संभावित रेंज बहुत ज़्यादा होती है. सिस्टम प्रॉम्प्ट, अब भी पूरे व्यवहार को कंट्रोल करता है.

सबसे सही तरीके ये हैं:

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

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

प्रॉम्प्ट देने की सामान्य तकनीकें

आम तौर पर, डेवलपर कई तरह की प्रॉम्प्टिंग तकनीकों का इस्तेमाल करते हैं. इससे उन्हें यह पता चलता है कि उनके इस्तेमाल के उदाहरण और मॉडल के लिए सबसे सही तकनीक कौनसी है.

बिना उदाहरण वाला प्रॉम्प्ट

मॉडल को टास्क के बारे में बताया जाता है और सबसे अच्छे नतीजे मिलने की उम्मीद की जाती है. उदाहरण के लिए:

"What is the capital of France?"

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

उदाहरण के साथ डाले गए प्रॉम्प्ट

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

You classify user messages into one of the following categories:
- "positive"
- "negative"
- "neutral"
Here are examples to guide your classifications:
Input: "I love this product! It works perfectly."
Output: { "label": "positive" }

Input: "This is terrible. I want a refund."
Output: { "label": "negative" }

इस तरह के छद्म-अनुमान वाले टास्क के लिए, फ़्यू-शॉट प्रॉम्प्ट (उदाहरण के साथ डाले गए प्रॉम्प्ट) का इस्तेमाल करना फ़ायदेमंद होता है. इसे ऐसे टास्क पर भी लागू किया जा सकता है जिनमें एक जैसा स्ट्रक्चर होता है. जैसे, पहली इमेज में टाइटल जनरेट करना.

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

चेन-ऑफ़-थॉट प्रॉम्प्टिंग

इससे मॉडल को जवाब देने से पहले, हर चरण के बारे में सोचने के लिए बढ़ावा मिलता है. इन चरणों के बारे में साफ़ तौर पर बताया जा सकता है या इन्हें मॉडल के हिसाब से तय किया जा सकता है. उदाहरण के लिए:

"Think step-by-step to identify the main idea of this paragraph. Then produce a
short heading under 60 characters."

चेन ऑफ़ थॉट, ऐसे टास्क के लिए बहुत अच्छा काम करता है जिनमें कई चरणों में तर्क देने और उन्हें लागू करने की ज़रूरत होती है. जैसे, किसी ब्लॉग पोस्ट की रूपरेखा तैयार करना या मुश्किल फ़ैसलों में मदद करना. यह तथाकथित रीज़निंग मॉडल के पीछे की मुख्य तकनीक है.

यह महंगा हो सकता है. जवाब देने के लिए, सिलसिलेवार तरीके से तर्क के बारे में जानकारी जनरेट करने से, कंप्यूटिंग, लागत, और इंतज़ार के समय में बढ़ोतरी होती है. इसका इस्तेमाल सिर्फ़ तब करें, जब आपके इस्तेमाल के उदाहरण में जटिल तर्क और प्लानिंग की ज़रूरत हो.

खुद के बारे में सोचने के लिए प्रॉम्प्ट करना

शुरुआती जनरेशन के बाद, मॉडल से उसके आउटपुट की समीक्षा करने और उसे बेहतर बनाने का अनुरोध करें. उदाहरण के लिए:

"Review your previous output.
Identify unclear phrasing and rewrite it more concisely."

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

आपके लिए अहम जानकारी

इस मॉड्यूल में, आपने सीखा कि स्ट्रक्चर्ड कॉम्पोनेंट से प्रॉम्प्ट कैसे बनाए जाते हैं. असल में, प्रॉम्प्ट इंजीनियरिंग एक एक्सपेरिमेंटल प्रोसेस है. कई बार बेहतर बनाने के बाद ही, जवाब साफ़ तौर पर और भरोसेमंद तरीके से मिलता है.

अगले मॉड्यूल में, हम आकलन के आधार पर प्रॉम्प्ट तैयार करने के बारे में जानेंगे. इस तरीके से, आपको प्रॉम्प्ट को बेहतर बनाने और यह तय करने में मदद मिलती है कि आपके प्रॉडक्ट और उपयोगकर्ताओं के लिए सबसे सही क्या है.

संसाधन

इनमें से हर तकनीक के अलग-अलग वैरिएंट और सबसे सही तरीके होते हैं. ज़्यादा जानकारी के लिए, कई बाहरी संसाधन उपलब्ध हैं. उदाहरण के लिए:

चुने गए मॉडल का दस्तावेज़ देखें. ऐसा इसलिए, क्योंकि बेहतर नतीजे पाने के लिए, आपको कुछ खास सलाह मिल सकती है.

देखें कि आपको कितना समझ आया

सिस्टम प्रॉम्प्ट में किस तरह के नियम तय किए जा सकते हैं?

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

अगर आपको मॉडल से जवाब देने से पहले, हर चरण के बारे में जानकारी चाहिए, तो आपको कौनसी तकनीक का इस्तेमाल करना चाहिए?

बिना उदाहरण वाला प्रॉम्प्ट
गलत जवाब.
उदाहरण के साथ डाले गए प्रॉम्प्ट
गलत जवाब.
चेन-ऑफ़-थॉट प्रॉम्प्टिंग
बहुत बढ़िया, यह सही है!
खुद के बारे में सोचने के लिए प्रॉम्प्ट करना
गलत जवाब.

फ़्यू-शॉट प्रॉम्प्ट (उदाहरण के साथ डाले गए प्रॉम्प्ट) का इस्तेमाल कब सबसे ज़्यादा फ़ायदेमंद होता है?

जब मॉडल को बिना किसी कॉन्टेक्स्ट के कोई टास्क पूरा करने के लिए कहा जाता है.
गलत जवाब.
जब टास्क में कोई जाना-पहचाना स्ट्रक्चर फ़ॉलो किया जाता है, जैसे कि टाइटल जनरेट करना या किसी खास फ़ॉर्मैटिंग की ज़रूरत होती है.
बहुत बढ़िया, यह सही है!
जब आउटपुट स्पेस बहुत बड़ा हो, जैसे कि क्रिएटिव राइटिंग.
गलत जवाब.
जब आपको मॉडल से उसके काम की आलोचना करवानी हो.
गलत जवाब.

सेल्फ़-रिफ़्लेक्शन प्रॉम्प्टिंग तकनीक क्या है?

मॉडल को अपने जवाब की समीक्षा करने और उसमें बदलाव करने के लिए कहना, ताकि जवाब को ज़्यादा साफ़ तौर पर बताया जा सके या उसकी क्वालिटी को बेहतर बनाया जा सके.
बहुत बढ़िया, यह सही है!
प्रॉम्प्ट को कई बार चलाना और नतीजों का औसत निकालना.
गलत जवाब.
अगर जवाब सही नहीं है, तो उपयोगकर्ता से प्रॉम्प्ट को फिर से लिखने के लिए कहा जाता है.
गलत जवाब.
इसकी मदद से, मॉडल को सिस्टम प्रॉम्प्ट को डाइनैमिक तरीके से बदलने की अनुमति मिलती है.
गलत जवाब.