BroadRouter

प्रोवाइडर बदलने से पहले LLM का मूल्यांकन कैसे करें

BroadNet Inference टीम · 5 मिनट में पढ़ें · प्रकाशित

ऐसे 50 से 200 असली प्रॉम्प्ट इकट्ठा करें जिनका सही नतीजा पता हो। दोनों मॉडल को पहले कोड चेक से स्कोर करें, और LLM जज सिर्फ़ वहाँ लगाएँ जहाँ कोड फ़ैसला न कर सके। पोज़िशन बायस हटाने के लिए जवाबों का क्रम बदलें, किसी तीसरे मॉडल परिवार का जज लें, उसे अपने लेबल से जाँचें, और चलाने से पहले पास होने का नियम तय करें, लागत और लेटेंसी समेत।

मॉडल बदलने से पहले LLM का मूल्यांकन करने के लिए दोनों मॉडल को ऐसे 50 से 200 असली प्रॉम्प्ट पर चलाएँ जिनका सही नतीजा पता हो। पहले कोड चेक से स्कोर करें, और पक्षपात हटाया हुआ LLM जज सिर्फ़ वहाँ लगाएँ जहाँ कोड फ़ैसला न कर सके; लागत और लेटेंसी लॉग करें, और पास होने का नियम पहले से तय करें।

कोड में बदलाव ख़ुद छोटा है: OpenAI-compatible API के साथ बस एक base URL और एक मॉडल ID बदलता है। वह हिस्सा माइग्रेशन चेकलिस्ट में है, और कीमत, सीमाएँ और प्राइवेसी प्रोवाइडर चेकलिस्ट में। मुश्किल हिस्सा यह जानना है कि नया मॉडल आपके कामों के लिए उतना ही अच्छा है या नहीं। पब्लिक लीडरबोर्ड इसका जवाब नहीं देते; Artificial Analysis और उसके विकल्प शॉर्टलिस्ट बनाने के लिए हैं। जवाब आपके अपने ट्रैफ़िक से बना एक छोटा eval सेट देता है, एक-दो दिन के काम में।

असली ट्रैफ़िक से eval सेट कैसे बनाएँ?

  1. अपने usage लॉग से 300 से 1,000 हाल के अनुरोध निकालें, संवेदनशील जानकारी हटाने के बाद।
  2. टास्क के प्रकार के हिसाब से बाँटें: एक्सट्रैक्शन, क्लासिफ़िकेशन, सारांश, चैट जवाब, कोड एडिट, टूल कॉल।
  3. हर प्रकार से 10 से 40 सैंपल लें, ज़्यादा वॉल्यूम या ज़्यादा जोखिम वाले प्रकारों से ज़्यादा। लंबे प्रॉम्प्ट, अंग्रेज़ी के अलावा दूसरी भाषाओं के इनपुट और वे केस शामिल करें जिनकी यूज़र ने शिकायत की थी।
  4. हर एक का अपेक्षित नतीजा लिखें: कोई सटीक मान, एक स्कीमा, एक टेस्ट जो पास होना चाहिए, या एक छोटा रूब्रिक (“रिफ़ंड की समय-सीमा का ज़िक्र है; कोई गढ़ी हुई नीति नहीं”)।
  5. ज़रूरी केस टैग करें। ग़लत इनवॉइस टोटल या लीक हुआ निर्देश, थोड़े ख़राब लहजे जैसा नहीं है।
  6. इसे वर्ज़न कंट्रोल में फ़्रीज़ करें। नई ग़लतियाँ मिलें तो केस जोड़ें; किसी मॉडल को बेहतर दिखाने के लिए उन्हें कभी न हटाएँ।

कौन-से चेक कोड से हों और कौन-से जज से?

हर केस के लिए सबसे सस्ता भरोसेमंद चेक इस्तेमाल करें:

टास्क चेक जज चाहिए?
JSON एक्सट्रैक्शन पार्स होता है, स्कीमा वैलिडेट होता है, फ़ील्ड अपेक्षित मान के बराबर नहीं
क्लासिफ़िकेशन लेबल अपेक्षित के बराबर नहीं
कोड एडिट टेस्ट पास होते हैं नहीं
टूल कॉल सही फ़ंक्शन, आर्ग्युमेंट वैलिडेट होते हैं नहीं
सारांश ज़रूरी तथ्य मौजूद; स्रोत से बाहर का कोई तथ्य नहीं कभी-कभी
चैट जवाब, लहजा, मददगार होना रूब्रिक हाँ

डिटर्मिनिस्टिक चेक मुफ़्त हैं, दोहराए जा सकते हैं और उन्हें चापलूसी से बहलाया नहीं जा सकता, इसलिए जितने हो सके उतने केस कोड चेक में डालें।

LLM-as-a-judge में क्या गड़बड़ होती है?

LLM-as-a-judge ऐसा मॉडल है जो दूसरे मॉडल के जवाबों को एक रूब्रिक के हिसाब से अंक देता है। MT-Bench स्टडी (Zheng et al.) में पाया गया कि मज़बूत जज 80% से ज़्यादा बार इंसानी पसंद से सहमत थे, लगभग उतनी ही बार जितना इंसान आपस में सहमत होते हैं। उसी पेपर ने उन पक्षपातों के नाम भी बताए जिनके हिसाब से आपको डिज़ाइन करना होगा:

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

व्यवहार से दो और नियम। जज को पिन करें: पूरी तुलना के लिए वही मॉडल वर्ज़न, वही प्रॉम्प्ट, temperature 0। और उसे कैलिब्रेट करें: 30 से 50 जोड़ियों को ख़ुद लेबल करें, उन पर जज चलाएँ, और उस पर तभी भरोसा करें जब वह ज़्यादातर बार आपसे सहमत हो। Arize का evaluator गाइड भी यही सलाह देता है (“Collect 20–100 examples”, अनुवाद: 20–100 उदाहरण इकट्ठा करें, इंसानी लेबल के साथ) और बड़े संख्यात्मक पैमानों की जगह pass/fail जैसे श्रेणी वाले लेबल की सिफ़ारिश करता है।

दोनों मॉडल की आमने-सामने तुलना कैसे चलाएँ?

हर केस पर दोनों उम्मीदवार चलाएँ, जज से पहचान छिपाएँ, क्रम बदलें, और लागत और समय लॉग करें:

import os, random, time, json
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
A, B = "broadnet/deepseek-v4.1-flash", "broadnet/qwen3.8-27b"
JUDGE = "broadnet/glm-5.3"  # a third family, pinned

def run(model, case):
    t0 = time.perf_counter()
    r = client.chat.completions.create(model=model, messages=case["messages"], max_tokens=4000, temperature=0)
    return {"text": r.choices[0].message.content or "", "usage": r.usage.model_dump(),
            "secs": time.perf_counter() - t0}

def judge(case, first, second):
    prompt = (f"Task:\n{case['task']}\n\nRubric:\n{case['rubric']}\n\n"
              f"Answer 1:\n{first}\n\nAnswer 2:\n{second}\n\n"
              'Reply with JSON only: {"winner": 1 or 2 or 0 for tie, "reason": "..."}')
    r = client.chat.completions.create(model=JUDGE, temperature=0, max_tokens=2000,
                                       response_format={"type": "json_object"},
                                       messages=[{"role": "user", "content": prompt}])
    return int(json.loads(r.choices[0].message.content or "{}").get("winner", 0))

def compare(case):
    a, b = run(A, case), run(B, case)
    if case.get("check"):                       # deterministic first
        return {"a_ok": case["check"](a["text"]), "b_ok": case["check"](b["text"]), "a": a, "b": b}
    w1 = judge(case, a["text"], b["text"])      # A shown first
    w2 = judge(case, b["text"], a["text"])      # B shown first
    winner = "A" if (w1, w2) == (1, 2) else "B" if (w1, w2) == (2, 1) else "tie"
    return {"winner": winner, "a": a, "b": b}

बदलाव वाले नियम का मतलब है कि कोई मॉडल तभी जीतता है जब जज उसे दोनों पोज़िशन में पसंद करे; कोई भी असहमति टाई गिनी जाती है। असहमतियों का हिस्सा अपने आप में काम का है: ऊँची दर का मतलब है कि जज या रूब्रिक बहुत अस्पष्ट है। max_tokens=4000 पर ध्यान दें: रीज़निंग मॉडल पर सोचने के टोकन भी सीमा में गिने जाते हैं, और कम सीमा से ख़ाली जवाब आते हैं जो फ़ेल जैसे दिखते हैं। देखें रीज़निंग मॉडल ख़ाली जवाब क्यों देते हैं।

कितना अंतर असली है?

eval स्कोर सैंपल होते हैं। n केस पर पास रेट p के लिए स्टैंडर्ड एरर √(p × (1 − p) ÷ n) है, और 95% मार्जिन उसका लगभग दोगुना।

केस पास रेट 95% मार्जिन
50 80% लगभग ±11 अंक
100 80% लगभग ±8 अंक
200 80% लगभग ±6 अंक
400 80% लगभग ±4 अंक

यानी 100 केस पर 79% के मुक़ाबले 82% लाने वाला मॉडल बेहतर साबित नहीं हुआ है। इसकी जगह हर केस के अंतर देखें: कौन-से केस पास से फ़ेल हो गए? वे टोटल से ज़्यादा बताते हैं, और ज़रूरी केस पर एक ही पलटाव स्विच का फ़ैसला कर सकता है।

फ़ैसले का नियम क्या होना चाहिए?

eval चलाने से पहले इसे लिख लें, ताकि नतीजा इसे मोड़ न सके। एक व्यावहारिक टेम्पलेट:

  1. ज़रूरी टैग वाले किसी भी केस पर कोई गिरावट नहीं।
  2. कुल पास रेट मौजूदा मॉडल से मार्जिन ऑफ़ एरर से ज़्यादा कम नहीं।
  3. p95 लेटेंसी आपके बजट के भीतर; इसे कैसे मापें, इसके लिए TTFT बनाम थ्रूपुट देखें।
  4. हर सफल केस की लागत कम हो, या सिर्फ़ उतनी ज़्यादा जितनी पर आप सहमत हैं कि क्वालिटी के लिए ठीक है। मासिक अंतर LLM API कॉस्ट कैलकुलेटर से निकालें।
  5. एक शैडो अवधि: लाइव ट्रैफ़िक का एक हिस्सा नए मॉडल पर भेजें, दोनों को लॉग करें, और पूरी तरह स्विच करने से पहले तुलना करें।

अगर आप कस्टम मॉडल पर विचार कर रहे हैं, तो शुरुआत भी इसी eval सेट से होती है: फ़ाइन-ट्यूनिंग से पहले बताता है कि कब प्रॉम्प्ट और रिट्रीवल काफ़ी हैं।

BroadNet Inference कहाँ आता है

BroadNet Inference एक ही OpenAI-compatible endpoint के पीछे कई मॉडल परिवार चलाता है, जिनमें DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B शामिल हैं, इसलिए उम्मीदवार और किसी दूसरे परिवार का जज एक ही क्लाइंट और key से चल सकते हैं। हर जवाब में लागत की तुलना के लिए टोकन usage होता है, और नए अकाउंट $5 के क्रेडिट से शुरू होते हैं; टॉप-अप के बिना यह क्रेडिट सिर्फ़ Gemma 4 VL 26B चलाता है, इसलिए बड़े मॉडल की तुलना के लिए छोटे टॉप-अप की योजना बनाएँ। इसमें कोई evaluation harness या होस्ट किया हुआ जज टूल शामिल नहीं है; ऊपर वाला कोड आप ख़ुद चलाते हैं। अरबी वर्कलोड के लिए अरबी के लिए LLM चुनना बताता है कि क्या टेस्ट करें। आमने-सामने कीमतें तुलना पेज पर हैं।

अक्सर पूछे जाने वाले सवाल

LLM eval सेट में कितने उदाहरण चाहिए?

बड़ी गिरावट पकड़ने के लिए पचास काफ़ी हैं, और लगभग 5 से 10 अंक के अंतर देखने के लिए 200। आकार से ज़्यादा कवरेज मायने रखता है, इसलिए हर तरह का टास्क और अपने ज्ञात फ़ेल केस शामिल करें।

क्या LLM-as-a-judge भरोसेमंद है?

आंशिक रूप से। MT-Bench स्टडी में मज़बूत जज 80% से ज़्यादा बार इंसानी पसंद से सहमत थे, लगभग उतनी ही बार जितना इंसान आपस में सहमत होते हैं। उनमें पोज़िशन, लंबाई और अपनी शैली की ओर झुकाव का पक्षपात भी दिखा, इसलिए पक्षपात हटाएँ और बीच-बीच में उन्हें जाँचें।

क्या जज मॉडल वही हो सकता है जिसे टेस्ट किया जा रहा है?

नहीं। जज उन जवाबों को पसंद करते हैं जो उनके अपने जैसे दिखते हैं। किसी दूसरे मॉडल परिवार का जज लें, और पूरी तुलना के दौरान उसे एक ही वर्ज़न पर पिन रखें।

LLM मूल्यांकन में पोज़िशन बायस क्या है?

जज क्वालिटी की परवाह किए बिना पहले, या दूसरे, दिखने वाले जवाब को पसंद करता है। इसे ठीक करने के लिए हर जोड़ी को दो बार जज करें, क्रम बदलकर, और जीत तभी गिनें जब दोनों क्रम सहमत हों।

क्या उसी eval में लागत और लेटेंसी की भी तुलना करूँ?

हाँ। हर eval कॉल के टोकन और समय लॉग करें। जो मॉडल दो अंक ज़्यादा लाता है, लेकिन तीन गुना लागत या लेटेंसी पर, उस पर स्विच करना फिर भी ग़लत फ़ैसला हो सकता है।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें