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

बेसिक जज मॉडल की मदद से, विषय के हिसाब से आकलन पाएं.

Maud Nalpas

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

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

अपना पहला जज मॉडल बनाना

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

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

ज़्यादातर फ़ाउंडेशन मॉडल, सामान्य मॉडल होते हैं. जज मॉडल, डोमेन स्पेशलिस्ट के तौर पर काम करता है.

जज मॉडल बनाने के मुख्य विकल्पों में ये शामिल हैं:

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

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

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

जज के लिए मॉडल चुनते समय, यह देखें कि उसमें तर्क देने की क्षमता अच्छी हो. क्योंकि CI/CD पाइपलाइन में आकलन किए जाते हैं, इसलिए स्पीड और लागत भी अहम होती है.

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

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

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

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

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

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

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

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

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

• सिस्टम के निर्देश सेट करें: जज को विशेषज्ञ के तौर पर काम करने के लिए निर्देश दें.
• तापमान या सोचने का लेवल सेट करना: जज को एक जैसा जवाब देना चाहिए. अगर आपको Gemini Flash जैसे तर्क देने वाले मॉडल का इस्तेमाल करना है, तो टेंपरेचर को डिफ़ॉल्ट पर रखें. हालांकि, thinking_level को HIGH पर सेट करें. ऐसा इसलिए, क्योंकि तर्क देने वाले मॉडल को एक लॉजिकल स्टेप से दूसरे पर जाने के लिए, थोड़ी रैंडमनेस की ज़रूरत होती है. अगर किसी दूसरे मॉडल का इस्तेमाल किया जा रहा है, तो temperature को 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 (such as 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}"`;
}

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

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