जज मॉडल का बेसिक वर्शन सेट अप करना (पहला हिस्सा)

बेसिक जज मॉडल की मदद से, अपने विषय के हिसाब से आकलन शुरू करें.

Maud Nalpas

नियमों पर आधारित आकलन, तय किए गए जवाबों की जांच कर सकते हैं. व्यक्तिपरक क्वालिटी का आकलन करने के लिए, एलएलएम को जज के तौर पर इस्तेमाल करने की तकनीक का इस्तेमाल करें.

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

अपना पहला जज मॉडल बनाने का तरीका

1. मॉडल को पसंद के मुताबिक बनाने का कोई तरीका चुनें. फ़ाइन-ट्यून करने या प्रॉम्प्ट इंजीनियरिंग का फ़ैसला लें.
2. कोई मॉडल चुनें. यह कोई फ़ाउंडेशन मॉडल या डोमेन के बारे में जानकारी न रखने वाला कोई अन्य एलएलएम हो सकता है.
3. स्कोरिंग का कोई तरीका चुनें. यह तय करना कि ThemeBuilder से जनरेट की गई थीम को स्कोर करने के लिए, जज को बाइनरी या न्यूमेरिक स्केल का इस्तेमाल करना चाहिए.
4. जज को कॉन्फ़िगर करें. मॉडल की सेटिंग में बदलाव करें. जैसे, तापमान और स्ट्रक्चर्ड आउटपुट. इससे मॉडल को जजमेंट टास्क के लिए बेहतर बनाया जा सकता है.
5. पहला प्रॉम्प्ट लिखें. जज करने वाले सिस्टम के निर्देशों और प्रॉम्प्ट का पहला वर्शन डिज़ाइन करें. इसमें स्कोरिंग रूब्रिक और उदाहरण शामिल हों.
6. अलाइनमेंट डेटासेट बनाएं. ThemeBuilder के अच्छे और बुरे आउटपुट का अलग-अलग और अच्छी क्वालिटी वाला सेट बनाएं. साथ ही, उन्हें लेबल करें. जैसे, अच्छा आदर्श वाक्य, आपत्तिजनक आदर्श वाक्य, और ब्रैंड से बाहर का कलर पैलेट.
7. जज को अलाइन करें और टेस्ट करें. जज के प्रॉम्प्ट (सिस्टम के निर्देश और मुख्य प्रॉम्प्ट) को बार-बार बेहतर बनाने के लिए, अलाइनमेंट डेटासेट का इस्तेमाल करें. इस प्रोसेस को तब तक दोहराएं, जब तक जज के फ़ैसले, इंसानों के फ़ैसलों से लगातार मेल न खाने लगें. आखिर में, जज की जांच करें. इससे यह पुष्टि की जा सकेगी कि वह भरोसेमंद है और नए इनपुट के लिए, अपने तरीके को सामान्य बना सकता है.

पसंद के मुताबिक बनाने का तरीका चुनना

ज़्यादातर फ़ाउंडेशन मॉडल, सामान्य मॉडल होते हैं. जज मॉडल को डोमेन विशेषज्ञ की तरह सोचना चाहिए.

जज मॉडल बनाने के लिए, आपके पास ये मुख्य विकल्प हैं:

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

इस कोर्स में ThemeBuilder की परफ़ॉर्मेंस का आकलन करने के लिए, हमारा सुझाव है कि आप प्रॉम्प्ट इंजीनियरिंग का इस्तेमाल करें. प्रॉम्प्ट इंजीनियरिंग से, अन्य विकल्पों की तुलना में कम समय में बेहतर नतीजे मिल सकते हैं.

कोई मॉडल चुनें

जज के तौर पर इस्तेमाल करने के लिए कोई मॉडल चुनते समय, तर्क करने की बेहतर क्षमता वाले मॉडल को चुनें. आपको सीआई/सीडी पाइपलाइन में आकलन करने होंगे. इसलिए, स्पीड और लागत भी अहम हैं.

सबसे सही मॉडल ढूंढने के लिए, अलग-अलग मॉडल और तकनीकों का इस्तेमाल करें.

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

इस कोर्स में, Gemini 3 Flash का इस्तेमाल जज मॉडल के तौर पर किया गया है. Gemini 3 Flash, ThemeBuilder के आउटपुट का आकलन करने के उदाहरण के लिए, ज़रूरी तेज़ी और सूझ-बूझ के साथ काम करता है. हालांकि, इस कोर्स में बताए गए पैटर्न को, अपनी पसंद के किसी भी मॉडल पर लागू किया जा सकता है.

स्कोरिंग का तरीका चुनना

विषय के हिसाब से दिए गए जवाबों को, बाइनरी PASS और FAIL लेबल या संख्या वाले स्कोर से स्कोर किया जा सकता है. उदाहरण के लिए, "एक से पांच के स्केल पर, यह नारा ब्रैंड के हिसाब से कितना सही है?".

हमारा सुझाव है कि बाइनरी लेबल का इस्तेमाल करें.

हालांकि, संख्यात्मक स्कोर (1 से 10) से आसानी से समझ आ जाता है, लेकिन रिसर्च से पता चला है कि एलएलएम (और इंसान) अपने स्कोर को बीच में रखते हैं या विनम्रता दिखाने के लिए स्कोर को बढ़ा-चढ़ाकर बताते हैं. कैटेगरी या बाइनरी लेबल, जैसे कि PASS और FAIL से अक्सर बेहतर नतीजे मिलते हैं. ऐसा इसलिए होता है, क्योंकि ये मॉडल को साफ़ तौर पर फ़ैसला लेने के लिए मजबूर करते हैं. इंसानों के लिए, इसे रेटर इफ़ेक्ट कहा जाता है.

जज को कॉन्फ़िगर करना

पैरामीटर और निर्देशों का इस्तेमाल करके, जज को एक जैसे और स्ट्रक्चर्ड आउटपुट बनाने में मदद करें.

• सिस्टम के निर्देश सेट करें: अपने जज को विशेषज्ञ का पर्सोना दें.
• तापमान या सोचने का लेवल सेट करें: जज को एक जैसा जवाब देना चाहिए. अगर आपको Gemini Flash जैसे तर्क देने वाले मॉडल का इस्तेमाल करना है, तो टेंपरेचर को डिफ़ॉल्ट पर रखें. हालांकि, thinking_level को HIGH पर सेट करें. ऐसा इसलिए, क्योंकि तर्क देने वाले मॉडल को लॉजिकल चरणों के बीच स्विच करने के लिए, थोड़ी रैंडमनेस की ज़रूरत होती है. अगर किसी दूसरे मॉडल का इस्तेमाल किया जा रहा है, तो टेम्परेचर को 0 या इसके आस-पास सेट करें.0 किसी भी मामले में, चेन ऑफ़ थॉट (सोच की प्रक्रिया) वाली तकनीक का इस्तेमाल करें, ताकि मॉडल फ़ैसला लेने से पहले सोच-विचार कर सके.
• जज के आउटपुट को स्ट्रक्चर करें: अनुमान लगाया जा सकने वाला JSON ऑब्जेक्ट, आपके बाकी कोडबेस में फिर से इस्तेमाल करना ज़्यादा आसान होता है. ऐसी EvalResult स्कीमा का इस्तेमाल करें जिसके लिए label (PASS या FAIL) और rationale स्ट्रिंग की ज़रूरत होती है.

ThemeBuilder के उदाहरण में:

// LLM judge config
const response = await client.models.generateContent({
  model: modelVersion,
  config: {
      systemInstruction: "You are a senior brand strategist, brand identity
      specialist, and expert color psychologist. You also act as a strict
      content moderator for a brand safety tool. Be rigorous regarding brand
      alignment. Always formulate your rationale before assigning the final
      PASS or FAIL label to ensure thorough consideration of the criteria.",
      temperature: 0,
      thinkingConfig: {
          thinkingLevel: ThinkingLevel.HIGH,
      },
      responseJsonSchema: schemaConfig.responseSchema
  },
  contents: [{ role: "user", parts: [{ text: prompt }] }]
});

const schemaConfig = {
  responseMimeType: "application/json",
  responseSchema: {
      type: "OBJECT",
      properties: {
          label: { type: "STRING", enum: [EvalLabel.PASS, EvalLabel.FAIL] },
          rationale: { type: "STRING" }
      },
      required: ["label", "rationale"],
      propertyOrdering: ["rationale", "label"]
  }
};

// Classification label for an evaluation (PASS/FAIL is the judge's verdict)
export enum EvalLabel {
    PASS = "PASS",
    FAIL = "FAIL"
}

पूरे कोड का उदाहरण देखें.

शुरुआती प्रॉम्प्ट लिखना

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

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

• अपने रूब्रिक को तय करें: जज को स्कोरिंग के बारे में ज़्यादा जानकारी वाले दिशा-निर्देश दें. सबसे सही जवाब के लिए, टोन कैसी होनी चाहिए? एलएलएम से रूब्रिक लिखने में मदद मांगी जा सकती है.
• फ़्यू-शॉट प्रॉम्प्टिंग का इस्तेमाल करें: PASS और FAIL उदाहरण शामिल करें.
• चेन-ऑफ़-थॉट प्रॉम्प्टिंग का इस्तेमाल करें: मॉडल को निर्देश दें कि वह लेबल असाइन करने से पहले, अपने तर्क के बारे में बताए. इससे जवाब ज़्यादा सटीक हो सकता है. HIGH के थिंकिंग मोड में, यह इतना ज़रूरी नहीं है. हालाँकि, यह अब भी एक अच्छा तरीका है.

अपने तीन खास मानदंडों के लिए, ग्रेडिंग के तीन अलग-अलग प्रॉम्प्ट लिखें:

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

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

आपको पूरे प्रॉम्प्ट, कोड रिपॉज़िटरी में मिल जाएंगे. उदाहरण के लिए, ब्रैंड के हिसाब से नारे का आकलन करने वाला प्रॉम्प्ट ऐसा दिखता है:

export function getMottoBrandFitJudgePrompt(companyName: string, description: string, audience: string, tone: string | string[], motto: string) {
  return `Evaluate the following generated motto for a company.

${companyName ? `Company name: ${companyName}\n` : ""}${description ? `Description: ${description}\n` : ""}${audience ? `Target audience: ${audience}\n` : ""}${Array.isArray(tone) ? (tone.length > 0 ? `Desired tone: ${tone.join(", ")}\n` : "") : (tone ? `Desired tone: ${tone}\n` : "")}

Generated motto: "${motto}"

Does this motto effectively match the company description, appeal to the target audience, and embody the desired tone?

CRITICAL INSTRUCTIONS: 
1. **Brand fit vs. toxicity**: You are evaluating ONLY brand fit. Another system will evaluate toxicity separately. DO NOT evaluate toxicity, ethics, profanity, or offensiveness. A motto can be a GREAT brand fit for an edgy or aggressive brand. If the brand requests an "offensive" or "aggressive" tone, you MUST pass it for brand fit, regardless of how inappropriate it is.
1. **Primary tone and literal relevance**: Do not over-penalize a motto if it perfectly captures the primary literal vibe just because it might loosely conflict with a secondary adjective.
1. **Core promises and professionalism**: For B2B/Enterprise, the motto MUST NOT violate core promises.
1. **Resilience to input messiness**: The Company Name, Description, Target Audience, or Tone may contain typos, slang, or mixed-language. You must decipher the *intended* meaning and judge the output against that intent, rather than penalizing the output for not matching the literal typo or slang.

Criteria:
1. **Relevance**: Does the motto relate to the company's core business and value proposition? Does it uphold core brand promises?
1. **Audience appeal**: Is the language engaging for the target audience without alienating them (e.g. through forced or inappropriate slang)?
1. **Tone consistency**: Does the motto reflect the general desired emotional tone perfectly, without imposing moral judgments?

Examples:

Input:
Company Name: "Summit Bank"
Description: "Secure, reliable banking for families"
Tone: "Trustworthy, serious"
Motto: "YOLO with your money!"
Result:
  "rationale": "The motto 'YOLO with your money!' is too casual and risky, contradicting the 'trustworthy, serious' tone required for a family bank.",
  "label": "${EvalLabel.FAIL}"
}

Input:
Company Name: "GymTiger"
Description: "Gym for heavy lifters."
Tone: "Aggressive, high-performance, technical"
Motto: "Lift big or be a loser."
Result:
  "rationale": "The motto matches the required 'aggressive' tone and appeals directly to the hardcore bodybuilding audience. While calling the audience a 'loser' is toxic and insulting, it successfully fulfills the brand fit and tone criteria requested.",
  "label": "${EvalLabel.PASS}"
}

Return a JSON object with:
- "rationale": A brief explanation of why it passes or fails based on the description, audience, and tone.
- "label": "${EvalLabel.PASS}" or "${EvalLabel.FAIL}"`;
}

अलाइन करें और टेस्ट करें

अलाइनमेंट और टेस्टिंग की मदद से जज बनाने की प्रोसेस पूरी करने के लिए, बुनियादी जज सेट अप करना, दूसरा हिस्सा लेख पढ़ें.