दूसरे मॉडलों के आउटपुट को आँकने के लिए किसी बड़े भाषा मॉडल का इस्तेमाल मूल्यांकन में अब डिफ़ॉल्ट तरीका बन चुका है। आप एक रूब्रिक लिखते हैं, GPT-4o या Claude से एक हज़ार जवाबों को स्कोर करवाते हैं, और एक एक्यूरेसी का आँकड़ा पढ़ लेते हैं। यह तेज़ है, सस्ता है, और किसी भी इंसानी टीम के हाथ से लेबल करने की क्षमता से कहीं आगे तक स्केल करता है।

लेकिन यह चुपके से ठीक उसी चीज़ को मान बैठता है जिसकी आपको सबसे ज़्यादा जाँच करनी होती है: कि जज इंसानों से सहमत है। एक ऐसा जज के रूप में LLM (LLM-as-a-judge) जो पूरे आत्मविश्वास के साथ गलत होता है, एक ऐसी साफ़-सुथरी दिखने वाली लीडरबोर्ड बना देता है जो रेत पर खड़ी है। किसी जज के फ़ैसलों पर भरोसा करने से पहले आपको यह मापना होगा कि वे इंसानी निर्णय का कितना अच्छे से पीछा करते हैं। यह मापने का कदम ही कैलिब्रेशन है, और Potato 2.6 इसके लिए एक वर्कफ़्लो जोड़ता है।

यह पोस्ट Judge Calibration (जज कैलिब्रेशन) को कवर करती है: यह मॉडलों से सैंपल कैसे लेती है, इंसानी पास को ईमानदार कैसे रखती है, और रिपोर्ट असल में आपको क्या बताती है। रेफ़रेंस डॉक्स में विकल्पों की पूरी सूची है।

एक LLM जज का फ़ैसला एक इंसानी एनोटेशन के बगल में दिखाया गया है, साथ में लाइव चलता हुआ kappa Potato में इनलाइन जज कैलिब्रेशन

समस्या का स्वरूप

एक जज दो अलग-अलग तरीकों से नाकाम हो सकता है, और आप दोनों को पकड़ना चाहते हैं।

पहला है असहमति: जज उन चीज़ों को "सही" कहता है जिन्हें एक सावधान इंसान "गलत" कहेगा। एक्यूरेसी और सहमति के मापदंड यही मापते हैं।

दूसरा है गलत आत्मविश्वास: जज कहता है कि वह 95% पक्का है और सही 60% बार होता है। एक जज की एक्यूरेसी ठीक-ठाक हो सकती है और फिर भी वह बुरी तरह मिस-कैलिब्रेटेड हो सकता है, और यह उसी क्षण मायने रखने लगता है जब आप उसके आत्मविश्वास का इस्तेमाल काम को रूट करने या थ्रेशोल्ड तय करने में करते हैं। कैलिब्रेशन त्रुटि यही मापती है।

Potato का कैलिब्रेशन पास इन दोनों को एक साथ सामने लाने के लिए बनाया गया है।

यह कैसे काम करता है

वर्कफ़्लो एक छोटी स्टेट मशीन की तरह चलता है:

text

SETUP → GENERATING → HUMAN_CALIBRATION → REPORT → COMPLETED

जेनरेटिंग (Generating)। हर मॉडल से प्रति आइटम k बार पूछा जाता है। उन k सैंपलों में सबसे बार-बार आने वाला लेबल मॉडल की भविष्यवाणी है, और उससे सहमत सैंपलों का अनुपात मॉडल का आत्मविश्वास है। एक बार के बजाय k बार सैंपल लेना ही वह चीज़ है जो आपको एक अनुभवजन्य आत्मविश्वास संकेत देती है, न कि कोई ऐसा आँकड़ा जो मॉडल ने अपने बारे में खुद गढ़ लिया हो। ये नतीजे एक समर्पित स्टोर में जाते हैं और कभी भी एनोटेशन डेटा में नहीं लिखे जाते।

ह्यूमन कैलिब्रेशन (Human calibration)। Potato आइटमों का एक रैंडम या स्तरीकृत (stratified) सैंपल निकालता है और उसे एक या ज़्यादा इंसानों के पास भेजता है, जो उन्हें सामान्य एनोटेशन इंटरफ़ेस के ज़रिए लेबल करते हैं, और मॉडल के जवाब कभी नहीं देखते।

रिपोर्ट (Report)। मापदंड मॉडलों के लेबल किए गए और इंसानों के लेबल किए गए के बीच के ओवरलैप पर परिकलित किए जाते हैं, फिर डिस्क पर लिखे जाते हैं।

यहाँ ब्लाइंडनेस अहम हिस्सा है। चूँकि मॉडल के लेबल एक अलग स्टोर में रहते हैं और कभी भी UI में इंजेक्ट नहीं किए जाते, इंसान उनसे गलती से भी एंकर नहीं हो सकता। ब्लाइंडनेस संरचनात्मक है, यह एनोटेटरों से नज़र हटाने को कहने का मामला नहीं है।

कैलिब्रेशन पाइपलाइन: k-सैंपल मॉडल वोटिंग, एक ब्लाइंड इंसानी पास, और एक तुलना रिपोर्ट Potato कैसे एक जज को ब्लाइंड इंसानी लेबलों के मुकाबले कैलिब्रेट करता है

कॉन्फ़िगरेशन

एक जज कैलिब्रेशन एक ही कॉन्फ़िग ब्लॉक है। आप जज का प्रॉम्प्ट लिखते हैं, मॉडलों की सूची देते हैं, और तय करते हैं कि हर एक से कितनी बार सैंपल लेना है:

yaml

judge_calibration:
  enabled: true
  prompt: |                       # supports {text}, {labels}, {description}
    You are an impartial expert annotator. Classify the sentiment as exactly
    one of: positive, negative, neutral.
  models:
    - endpoint_type: openai        # openai | anthropic | ollama | vllm | gemini | ...
      model: gpt-4o-mini
      api_key: ${OPENAI_API_KEY}
      temperature: 0.7             # must be > 0 so the k samples vary
    - endpoint_type: ollama
      model: llama3.1:8b
      base_url: http://localhost:11434
      temperature: 0.7
  k_samples: 5                     # samples per model per item
  max_items: 1000                  # cap on items the LLMs label (null = all)
  sampling:
    strategy: stratified           # random | stratified | all
    sample_size: 200               # how many items humans blind-label
    seed: 42
  human:
    num_raters: 1                  # 1 = solo researcher; N adds human-human IAA
    gold: single                   # single | majority
  schemas: [sentiment]
  output:
    dir: judge_calibration_output

Warning: temperature > 0 सेट करें। k_samples > 1 और तापमान 0 के साथ, सैंपल एक जैसे होते हैं, आत्मविश्वास 1.0 पर अटक जाता है, और कैलिब्रेशन रिपोर्ट निरर्थक हो जाती है। जब Potato यह संयोजन देखता है तो स्टार्टअप पर एक चेतावनी देता है।

आप एक से ज़्यादा मॉडल सूचीबद्ध कर सकते हैं और उन्हें साथ-साथ कैलिब्रेट कर सकते हैं, जो एक सस्ते लोकल जज और एक महँगे होस्टेड जज के बीच चुनाव करने का स्वाभाविक तरीका है।

API कुंजी के बिना इसे आज़माना

साथ दिया गया उदाहरण एक लोकल Ollama मॉडल का इस्तेमाल करता है, इसलिए आप पूरे लूप को ऑफ़लाइन चला सकते हैं। Ollama शुरू करें, मॉडल खींचें (pull करें), और लॉन्च करें:

bash

ollama pull llama3.2:3b
python potato/flask_server.py start examples/ai-assisted/judge-calibration/config.yaml -p 8000 --debug

कॉन्फ़िगर और रन करने के लिए http://localhost:8000/judge_calibration/admin खोलें, /annotate पर सैंपल को ब्लाइंड-लेबल करें, फिर रिपोर्ट बनाएँ और उसे /judge_calibration/report पर पढ़ें।

रिपोर्ट आपको क्या बताती है

रिपोर्ट "क्या मुझे इस जज पर भरोसा करना चाहिए?" का जवाब ऐसे आँकड़ों से देने के लिए बनी है जिन्हें आप मेथड्स सेक्शन में डाल सकें:

इंसानी गोल्ड लेबल के मुकाबले हर मॉडल के लिए एक्यूरेसी, प्रिसिज़न, रिकॉल, F1।
Cohen का κ इंसान↔मॉडल, मॉडल↔मॉडल, और इंसान↔इंसान जोड़ों में विभाजित, ताकि आप देख सकें कि जज इंसानों से उतना सहमत है या नहीं जितना इंसान आपस में सहमत हैं।
सभी रेटरों पर Fleiss का κ और Krippendorff का α।
अपेक्षित कैलिब्रेशन त्रुटि (ECE), रिलायबिलिटी बिन, और एक Brier स्कोर: गलत आत्मविश्वास वाले विफलता मोड का जवाब।
प्रति मॉडल एक कन्फ़्यूज़न मैट्रिक्स, जो आमतौर पर असली कहानी बताती है: एक जज जो आसान वर्गों पर ठीक रहता है और किसी एक मुश्किल भेद पर बिखर जाता है।

सब कुछ ओवरलैप पर परिकलित होता है: वे आइटम जिन्हें मॉडलों और इंसानों दोनों ने लेबल किया, और जो कैलिब्रेशन सैंपल तक सीमित हैं। आउटपुट output.dir के नीचे llm_labels.jsonl, report.json, और एक पठनीय report.html के रूप में आता है।

यह क्या संभालता है

कैलिब्रेशन उन कैटेगोरिकल स्कीमों पर पूरी तरह समर्थित है जिनका इस्तेमाल ज़्यादातर जज करते हैं, और कठिन प्रकारों तक भी पहुँचता है:

प्रकार	स्थिति	मापदंड
`radio` / `select`	समर्थित	एक्यूरेसी, P/R/F1, Cohen/Fleiss κ, Krippendorff α, ECE, कन्फ़्यूज़न
`likert`	समर्थित	उपरोक्त के साथ MAE और ऑर्डिनल Krippendorff α
`multiselect`	समर्थित	प्रति-लेबल P/R/F1, माध्य Jaccard, एग्ज़ैक्ट-मैच एक्यूरेसी, कैलिब्रेशन
`span`	प्रायोगिक	IoU-मैच किए गए P/R/F1, माध्य IoU, span-F1, span-स्तर कैलिब्रेशन

स्पैन कैलिब्रेशन जज के कैरेक्टर-ऑफ़सेट स्पैनों को k सैंपलों पर क्लस्टर करता है और उन्हें इंटरसेक्शन-ओवर-यूनियन (intersection-over-union) द्वारा गोल्ड से मैच करता है; इसके आँकड़ों को सटीक के बजाय दिशासूचक मानें।

कैलिब्रेशन बनाम अलाइनमेंट

Potato एक दूसरा, संबंधित वर्कफ़्लो भी देता है जिसे इससे आसानी से भ्रमित किया जा सकता है। Judge Alignment (जज अलाइनमेंट) एक अकेले जज को एक मौजूदा इंसानी गोल्ड सेट के मुकाबले कैलिब्रेट करता है, एनोटेशन के दौरान उसका फ़ैसला इनलाइन दिखाता है, और इस इर्द-गिर्द बना है कि सहमति बढ़ने तक रूब्रिक पर बार-बार सुधार किया जाए।

मोटे तौर पर नियम: जब आप उम्मीदवार जजों की जाँच कर रहे हों और एक ब्लाइंड, अनुभवजन्य आत्मविश्वास का आँकड़ा चाहते हों तो कैलिब्रेशन चुनें; जब आप एक जज पर ठहर चुके हों और किसी तय गोल्ड सेट के मुकाबले उसकी रूब्रिक को ट्यून कर रहे हों तो अलाइनमेंट चुनें। दोनों को लूप बंद करना (Closing the Loop) में एक साथ कवर किया गया है।

LLM जज कहीं नहीं जा रहे; मूल्यांकन के लिए बहुत कुछ है और हाथ से करने वाले लोग बहुत कम। कैलिब्रेशन का मकसद जज को इंसानों से बदलना नहीं है, बल्कि एक आँकड़े के साथ ठीक-ठीक जानना है कि किसी इंसान को देखने की ज़रूरत पड़ने से पहले जज पर कितनी दूर तक भरोसा किया जा सकता है।

Judge Calibration डॉक्स हर विकल्प को कवर करते हैं, और इंटर-एनोटेटर एग्रीमेंट गाइड kappa और alpha मापदंडों को विस्तार से समझाती है।