Gemma 4 में प्रॉम्प्ट फ़ॉर्मैट करने का तरीका

Gemma 4 से, हम नए कंट्रोल टोकन पेश कर रहे हैं. Gemma 3 और इससे पहले के वर्शन के लिए, पिछला दस्तावेज़ देखें.

यहां दिए गए सेक्शन में, Gemma 4 के इस्तेमाल किए गए कंट्रोल टोकन और उनके इस्तेमाल के उदाहरणों के बारे में बताया गया है. ध्यान दें कि कंट्रोल टोकन, हमारे टोकनाइज़र में रिज़र्व किए जाते हैं और खास तौर पर उसी के लिए होते हैं.

• सिस्टम के निर्देश के लिए टोकन: system
• उपयोगकर्ता के टर्न को दिखाने वाला टोकन: user
• मॉडल के जवाब को दिखाने वाला टोकन: model
• डायलॉग टर्न की शुरुआत दिखाने वाला टोकन: <|turn>
• डायलॉग टर्न के खत्म होने का टोकन: <turn|>

यहां बातचीत का एक उदाहरण दिया गया है:

<|turn>system
You are a helpful assistant.<turn|>
<|turn>user
Hello.<turn|>

कई तरह के डेटा का इस्तेमाल

हम दो खास प्लेसहोल्डर टोकन (<|image|> और <|audio|>) का इस्तेमाल करते हैं. इससे यह तय किया जाता है कि इमेज और ऑडियो टोकन कहां डाले जाने चाहिए. टोकनाइज़ेशन के बाद, इन टोकन को मॉडल में मौजूद असल सॉफ्ट एम्बेडिंग से बदल दिया जाता है.

यहां बातचीत का एक उदाहरण दिया गया है:

prompt = """<|turn>user
Describe this image: <|image|>

And translate these audio:

a. <|audio|>
b. <|audio|><turn|>
<|turn>model"""

ऑडियो

ऑडियो प्रोसेसिंग के लिए, प्रॉम्प्ट के इन स्ट्रक्चर का इस्तेमाल करें:

• ऑडियो से बोली की पहचान करने की सुविधा (एएसआर)

Transcribe the following speech segment in {LANGUAGE} into {LANGUAGE} text.

Follow these specific instructions for formatting the answer:
*   Only output the transcription, with no newlines.
*   When transcribing numbers, write the digits, i.e. write 1.7 and not one point seven, and write 3 instead of three.

• अपने-आप होने वाला बातचीत का अनुवाद (एएसटी)

Transcribe the following speech segment in {SOURCE_LANGUAGE}, then translate it into {TARGET_LANGUAGE}.
When formatting the answer, first output the transcription in {SOURCE_LANGUAGE}, then one newline, then output the string '{TARGET_LANGUAGE}: ', then the translation in {TARGET_LANGUAGE}.

एजेंटिक और रीज़निंग कंट्रोल टोकन

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

फ़ंक्शन कॉलिंग

Gemma 4 को छह खास टोकन पर ट्रेन किया गया है, ताकि "टूल इस्तेमाल करने" के लाइफ़साइकल को मैनेज किया जा सके.

स्ट्रिंग वैल्यू के लिए सीमांकक: <|"|>

स्ट्रक्चर्ड डेटा ब्लॉक में, सभी स्ट्रिंग वैल्यू के लिए, <|"|> टोकन का इस्तेमाल डेलिमिटर के तौर पर किया जाता है.

• मकसद: यह टोकन यह पक्का करता है कि स्ट्रिंग में मौजूद किसी भी खास वर्ण (जैसे कि {, }, , या कोटेशन) को लिटरल टेक्स्ट के तौर पर माना जाए. इन्हें डेटा स्ट्रक्चर के सिंटैक्स के हिस्से के तौर पर न माना जाए.
• इस्तेमाल: आपके फ़ंक्शन के एलान, कॉल, और जवाबों में मौजूद सभी स्ट्रिंग लिटरल को इस टोकन (जैसे, key:<|"|>string value<|"|>) का इस्तेमाल करके बंद किया जाना चाहिए.

सोचने का मोड

थिंकिंग मोड को चालू करने के लिए, सिस्टम के निर्देश में <|think|> कंट्रोल टोकन शामिल करें.

यहां बातचीत का एक उदाहरण दिया गया है:

<|turn>system
<|think|><turn|>
<|turn>user
What is the water formula?<turn|>
<|turn>model
<|channel>thought
...
<channel|>The most common interpretation of "the water formula" refers...<turn|>

सोचने वाले मोड को बातचीत के लेवल पर चालू करने के लिए डिज़ाइन किया गया है. इसे अन्य सिस्टम निर्देशों के साथ एक ही सिस्टम टर्न में शामिल किया जाना चाहिए. जैसे, टूल की परिभाषाएं.

वजह बताने और फ़ंक्शन कॉल करने का उदाहरण

एजेंटिक टर्न में, मॉडल किसी फ़ंक्शन को कॉल करने का फ़ैसला लेने से पहले, निजी तौर पर "सोच" सकता है. लाइफ़साइकल इस क्रम में होता है:

1. उपयोगकर्ता की पूछताछ: उपयोगकर्ता कोई सवाल पूछता है.
2. तर्क: मॉडल, थॉट चैनल में निजी तौर पर सोचता है.
3. टूल का अनुरोध: मॉडल, टूल कॉल का अनुरोध करने के लिए जनरेट करने की प्रोसेस को रोकता है.
4. कार्रवाई और जवाब जोड़ना: ऐप्लिकेशन, टूल को लागू करता है और जवाब जोड़ता है.
5. फ़ाइनल जवाब: मॉडल, जवाब को पढ़ता है और फ़ाइनल जवाब जनरेट करता है.

यहां दिए गए उदाहरण में, मौसम की जानकारी देने वाले टूल का इस्तेमाल करने वाला मॉडल दिखाया गया है:

<|turn>system
<|think|>You are a helpful assistant.<|tool>declaration:get_current_temperature{...}<tool|><turn|>
<|turn>user
What's the temperature in London?<turn|>
<|turn>model
<|channel>thought
...
<channel|><|tool_call>call:get_current_temperature{location:<|"|>London<|"|>}<tool_call|><|tool_response>

आपके ऐप्लिकेशन को मॉडल के जवाब को पार्स करना चाहिए, ताकि फ़ंक्शन का नाम और आर्ग्युमेंट निकाले जा सकें. इसके बाद, फ़ंक्शन को लागू करना चाहिए. इसके बाद, assistant भूमिका के तहत चैट के इतिहास में tool_calls और tool_responses जोड़ना चाहिए.

<|turn>model
<|tool_call>call:get_current_weather{location:<|"|>London<|"|>}<tool_call|><|tool_response>response:get_current_weather{temperature:15,weather:<|"|>sunny<|"|>}<tool_response|>

आखिर में, Gemma टूल के जवाब को पढ़ता है और उपयोगकर्ता को जवाब देता है.

The temperature in London is 15 degrees and it is sunny.<turn|>

इस उदाहरण के लिए, चैट के पूरे इतिहास का JSON यहां दिया गया है:

[
  {
    "role": "system",
    "content": "You are a helpful assistant."
  },
  {
    "role": "user",
    "content": "What's the temperature in London?"
  },
  {
    "role": "assistant",
    "tool_calls": [
      {
        "function": {
          "name": "get_current_weather",
          "arguments": {
            "location": "London"
          }
        }
      }
    ],
    "tool_responses": [
      {
        "name": "get_current_weather",
        "response": {
          "temperature": 15,
          "weather": "sunny"
        }
      }
    ],
    "content": "The temperature in London is 15 degrees and it is sunny."
  }
]

बातचीत के दौरान, पिछली बातचीत से जुड़े डेटा को मैनेज करना

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

• स्टैंडर्ड मल्टी-टर्न बातचीत: आपको मॉडल के जनरेट किए गए विचारों को पिछले टर्न से हटाना होगा. इसके बाद, बातचीत के इतिहास को मॉडल को वापस भेजना होगा, ताकि वह अगले टर्न में जवाब दे सके. अगर आपको बातचीत के बीच में सोचने के तरीके को बंद करना है, तो पिछली सोच को हटाते समय <|think|> टोकन हटाया जा सकता है.
• फ़ंक्शन कॉलिंग (अपवाद): अगर किसी मॉडल टर्न में फ़ंक्शन या टूल कॉल शामिल हैं, तो फ़ंक्शन कॉल के बीच के थॉट को नहीं हटाया जाना चाहिए.

एजेंटिक वर्कफ़्लो और लंबे समय तक चलने वाले टास्क

स्टैंडर्ड टर्न के बीच में, रॉ थॉट हटा दिए जाते हैं. इसलिए, लंबे समय तक काम करने वाले एजेंट बनाने वाले डेवलपर, तर्क के कॉन्टेक्स्ट को बनाए रखना चाहें, ताकि मॉडल को बार-बार तर्क करने से रोका जा सके.

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

इंटिग्रेशन के बारे में नोट

• इंटरनल स्टेट: आम तौर पर, <|channel> और <channel|> टोकन का इस्तेमाल चेन-ऑफ़-थॉट (सीओटी) प्रोसेसिंग के लिए किया जाता है. आम तौर पर, लोगों के लिए उपलब्ध स्टैंडर्ड ऐप्लिकेशन में, इस कॉन्टेंट को असली उपयोगकर्ता से छिपाया जाता है.
• टूल लूप: tool_call और tool_response टोकन, आपके ऐप्लिकेशन एनवायरमेंट और मॉडल के बीच "हैंडशेक" की सुविधा देते हैं. ऐप्लिकेशन, tool_call को इंटरसेप्ट करता है, उसके कोड को लागू करता है, और नतीजे को tool_response टोकन में मॉडल को वापस भेजता है.
• मॉडल का व्यवहार: बड़े मॉडल (जैसे, gemma-4-26B-A4B-it, gemma-4-31B-it) कभी-कभी थॉट चैनल जनरेट कर सकते हैं. ऐसा तब भी हो सकता है, जब सोचने के मोड को साफ़ तौर पर बंद कर दिया गया हो. इन खास मामलों में मॉडल के व्यवहार को बेहतर बनाने के लिए, प्रॉम्प्ट में एक खाली थिंकिंग टोकन जोड़ें.

अहम जानकारी: नो-थिंकिंग डेटासेट की मदद से बड़े मॉडल को फ़ाइन-ट्यून करना

अगर आपको ऐसे डेटासेट के साथ बड़े Gemma मॉडल को फ़ाइन-ट्यून करना है जिसमें सोचने की क्षमता शामिल नहीं है, तो ट्रेनिंग के लिए इस्तेमाल किए जाने वाले प्रॉम्प्ट में खाली चैनल जोड़कर बेहतर नतीजे पाए जा सकते हैं:

<|turn>model
<|channel>thought
<channel|>

सलाह: सिस्टम के निर्देशों का इस्तेमाल करके, अडैप्टिव थॉट एफिशिएंसी

Gemma 4 में "सोचने" की सुविधा को आधिकारिक तौर पर चालू या बंद किया जा सकता है. हालांकि, मॉडल में निर्देशों का पालन करने की क्षमता बहुत ज़्यादा होती है. इससे आपको मॉडल के सोचने के तरीके को डाइनैमिक तरीके से बदलने की सुविधा मिलती है.

"ज़्यादा" या "कम" सूझ-बूझ के लिए, हार्डकोड किए गए फ़्रेमवर्क पैरामीटर पर भरोसा करने के बजाय, सिस्टम के निर्देशों (एसआई) का इस्तेमाल किया जा सकता है. इससे मॉडल को कम सूझ-बूझ वाले मोड में ले जाया जा सकता है. मॉडल को कम समय में या कम गहराई से सोचने का निर्देश देकर (इस कॉन्सेप्ट को हम "LOW" थिंकिंग इंस्ट्रक्शन कहते हैं), कम समय में बेहतर नतीजे पाए जा सकते हैं.

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