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"""

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

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" निर्देश, सिद्धांत का प्रमाण है.
• कस्टमाइज़ेशन: हम डेवलपर को अपने कस्टम सिस्टम इंस्ट्रक्शन के साथ एक्सपेरिमेंट करने के लिए प्रोत्साहित करते हैं. अपने इस्तेमाल के उदाहरणों के लिए, मॉडल की सोचने की प्रोसेस की गहराई, लंबाई, और स्टाइल को बेहतर बनाया जा सकता है. इससे लेटेन्सी, लागत, और आउटपुट क्वालिटी को पूरी तरह से बैलेंस किया जा सकता है.