अपने कार्य पर दो LLM की निष्पक्ष तुलना करें: साइड-स्वैप और लागत लॉग

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

एक सार्वजनिक टूर्नामेंट क्या करता है जिसे आप उधार ले सकते हैं#

Dwarkesh Patel का Clocktower Bench एक अनौपचारिक शोध परियोजना है जहाँ भाषा मॉडल एक-दूसरे के खिलाफ सामाजिक-अनुमान खेल Blood on the Clocktower खेलते हैं। यहाँ खेल मुद्दा नहीं है; हार्नेस मुद्दा है। परियोजना के About पृष्ठ (8 नवंबर 2026 को जाँचा गया) के अनुसार, यह कुछ ऐसी चीजें करता है जो किसी भी आमने-सामने की तुलना में होनी चाहिए:

• एक मॉडल सभी अच्छी सीटें खेलता है और दूसरा सभी बुरी सीटें, और प्रत्येक डील को पक्षों की अदला-बदली के साथ दो बार खेला जाता है, ताकि भाग्यशाली सीट परिणाम तय न करे;
• सभी मॉडलों को समान सेटिंग्स मिलती हैं: समान तर्क प्रयास, प्रति टर्न 8,000-टोकन की सीमा और भाषण पर 150-शब्द की सीमा;
• Storyteller स्क्रिप्टेड है, इसलिए कोई मॉडल खेल की अध्यक्षता नहीं करता;
• प्रत्येक API कॉल को उसके टोकन और लागत के साथ calls.jsonl में लिखा जाता है। पृष्ठ कहता है कि एक खेल की लागत लगभग $2 से $50 तक होती है, मॉडलों के आधार पर (OpenAI और Anthropic APIs पर)।

हार्नेस OpenAI और Anthropic मॉडलों के लिए बनाया गया है, और आपका कार्य शायद बोर्ड गेम नहीं है। लेकिन तीन आदतें स्थानांतरित होती हैं: समान सेटिंग्स, अदला-बदली पक्ष, और लागत लॉग। इस गाइड का शेष भाग उन्हें किसी सामान्य चीज़ पर लागू करता है।

कार्य: 30 सहायता टिकटों के उत्तरों का मसौदा तैयार करना#

मान लीजिए आप एक छोटा सहायता डेस्क चलाते हैं और जानना चाहते हैं कि DeepSeek-V4-Flash या GLM-5.3-Flash बेहतर पहला मसौदा लिखता है। आपके पास tickets.jsonl फ़ाइल है जिसमें 30 वास्तविक टिकट हैं, प्रति पंक्ति एक JSON ऑब्जेक्ट: {"id": 1, "text": "..."}।

API OpenAI-संगत है, इसलिए आधिकारिक openai पैकेज https://api.cheaptokens.dev/v1 पर CheapTokens के साथ काम करता है। दस्तावेज़ों से पूर्ण मॉडल आईडी का उपयोग करें: deepseek-ai/DeepSeek-V4-Flash-0731 और zai-org/GLM-5.3-Flash। दोनों मॉडलों को एक तीसरा मॉडल न्यायाधीश के रूप में भी मिलता है, MiniMaxAI/MiniMax-M2.7, ताकि कोई भी प्रतियोगी अपने काम को ग्रेड न करे।

उस भाग से शुरू करें जो लॉग को संभव बनाता है: एक फ़ंक्शन जिसके माध्यम से हर कॉल गुजरती है।

import json, os, re
from openai import OpenAI

client = OpenAI(base_url="https://api.cheaptokens.dev/v1",
                api_key=os.environ["CHEAPTOKENS_API_KEY"])

CONTESTANTS = {"deepseek": "deepseek-ai/DeepSeek-V4-Flash-0731",
               "glm": "zai-org/GLM-5.3-Flash"}
JUDGE = "MiniMaxAI/MiniMax-M2.7"
SETTINGS = {"temperature": 0.2, "max_tokens": 800}   # same for both

def call(model, messages, role, ticket_id, **settings):
    r = client.chat.completions.create(model=model, messages=messages, **settings)
    with open("calls.jsonl", "a", encoding="utf-8") as f:
        f.write(json.dumps({
            "role": role, "ticket": ticket_id, "model": model,
            "input_tokens": r.usage.prompt_tokens,
            "output_tokens": r.usage.completion_tokens,
            "finish": r.choices[0].finish_reason}) + "\n")
    return r.choices[0].message.content or ""

def draft(model, ticket):
    msgs = [{"role": "system", "content": "You answer support tickets. "
             "Reply in under 80 words, politely, with no promises about refunds."},
            {"role": "user", "content": ticket["text"]}]
    return call(model, msgs, "draft", ticket["id"], **SETTINGS)

calls.jsonl में फ़ील्ड वे हैं जिन्हें यह स्क्रिप्ट चुनती है; उपयोग संख्याएँ API प्रतिक्रिया के usage ऑब्जेक्ट से आती हैं। दोनों मॉडलों को समान सिस्टम प्रॉम्प्ट, समान temperature और समान max_tokens मिलता है। एक मॉडल के लिए उनमें से एक को बदलें और आप सेटिंग्स की तुलना कर रहे हैं, मॉडलों की नहीं।

पक्ष बदलें: प्रत्येक जोड़ी को दो बार आंकें#

अब न्यायाधीश। एक न्यायाधीश मॉडल किसी विशेष स्लॉट में उत्तर की ओर झुक सकता है, इसलिए एकल निर्णय गुणवत्ता को स्थिति के साथ मिला देता है। Clocktower की तरकीब अच्छी तरह फिट बैठती है: प्रत्येक जोड़ी को दोनों भूमिकाओं में दिखाएं। एक उत्तर टिकट जीतता है केवल यदि न्यायाधीश दोनों क्रमों में उसे चुनता है। यदि निर्णय उत्तर के बजाय स्लॉट का अनुसरण करता है, तो टिकट बराबरी का है।

def judge(ticket, first, second):
    prompt = (f"Ticket:\n{ticket['text']}\n\nReply A:\n{first}\n\nReply B:\n{second}\n\n"
              "Which reply is better for the customer? Finish with a last line: Verdict: A or Verdict: B.")
    out = call(JUDGE, [{"role": "user", "content": prompt}], "judge",
               ticket["id"], temperature=0, max_tokens=1000)
    letters = re.findall(r"Verdict:\s*([AB])\b", out)
    return letters[-1] if letters else None

tickets = [json.loads(l) for l in open("tickets.jsonl", encoding="utf-8")]
wins = {"deepseek": 0, "glm": 0, "tie": 0}

for t in tickets:
    a = draft(CONTESTANTS["deepseek"], t)
    b = draft(CONTESTANTS["glm"], t)
    v1 = judge(t, a, b)   # DeepSeek's reply shown as A
    v2 = judge(t, b, a)   # GLM's reply shown as A
    pick1 = {"A": "deepseek", "B": "glm"}.get(v1)
    pick2 = {"A": "glm", "B": "deepseek"}.get(v2)
    wins[pick1 if pick1 and pick1 == pick2 else "tie"] += 1

print(wins)

दो विवरण छूटना आसान है। न्यायाधीश temperature=0 पर चलता है ताकि उसके निर्णय अधिक स्थिर रहें; हर मॉडल उस सेटिंग का सम्मान नहीं करता, इसलिए कुछ जोड़ियों को फिर से चलाएं और निर्णयों की तुलना करें इससे पहले कि आप उन पर भरोसा करें। निर्णय केवल अंतिम Verdict: पंक्ति से पढ़ा जाता है, और सीमाएँ उदार हैं (मसौदों के लिए 800, न्यायाधीश के लिए 1000) ताकि उत्तर देने से पहले तर्क करने वाला मॉडल विचार के बीच में कट न जाए; नीचे दिया गया अनुमान विशिष्ट आकारों का उपयोग करता है, सीमाओं का नहीं। अपार्सेबल उत्तर None देता है, जो रन को क्रैश करने के बजाय बराबरी में गिर जाता है।

क्रम परीक्षण को झुकाने का एकमात्र तरीका नहीं है। सेटिंग्स, प्रॉम्प्ट और लॉगिंग भी इसे झुका सकते हैं, इसलिए पूरे सेटअप की जाँच करें, केवल यह नहीं कि कौन पहले जाता है। यहाँ वही प्रयोग पहले और बाद में है।

हर कॉल लॉग करें, फिर रन की कीमत लगाएं#

लॉग वह है जो तुलना को बजट में बदल देता है। रन के बाद, प्रति मॉडल टोकन का योग करें:

from collections import defaultdict

totals = defaultdict(lambda: [0, 0, 0])
for line in open("calls.jsonl", encoding="utf-8"):
    c = json.loads(line)
    s = totals[c["model"]]
    s[0] += c["input_tokens"]; s[1] += c["output_tokens"]; s[2] += 1

for model, (tin, tout, n) in totals.items():
    print(model, n, "calls", tin, "input", tout, "output")

आपको प्रति मॉडल एक पंक्ति मिलेगी जिसमें कॉल गणना, इनपुट टोकन और आउटपुट टोकन होंगे। मॉडल की दो कीमतों (इनपुट और आउटपुट अलग-अलग बिल किए जाते हैं) से गुणा करें या, आसान तरीका, कुल योग को लाइव लागत मार्कर में पेस्ट करें।

आप रन से पहले अनुमान भी लगा सकते हैं। मान लें कि प्रत्येक टिकट और सिस्टम प्रॉम्प्ट लगभग 300 इनपुट टोकन हैं, एक मसौदा लगभग 250 आउटपुट टोकन है, और न्यायाधीश लगभग 800 इनपुट टोकन (टिकट और दोनों उत्तर और प्रश्न) देखता है और लगभग 200 टोकन (निर्णय पंक्ति और सोचने के लिए थोड़ी जगह) के साथ उत्तर देता है:

• मसौदे: 30 टिकट × 2 मॉडल = 60 कॉल, प्रति प्रतियोगी 30 × 300 = 9000 इनपुट और 30 × 250 = 7500 आउटपुट टोकन;
• निर्णय: 30 टिकट × 2 क्रम = 60 कॉल, न्यायाधीश पर 60 × 800 = 48000 इनपुट और 60 × 200 = 12000 आउटपुट टोकन।

वर्तमान कीमतों पर, एक प्रतियोगी के 30 मसौदों की लागत DeepSeek-V4-Flash पर $0.00089 और GLM-5.3-Flash पर $0.00048 है। MiniMax-M2.7 पर 60 निर्णयों की लागत $0.0042 है। तीनों को जोड़ें और आपके पास एक भी अनुरोध भेजने से पहले पूरी तुलना की कीमत है। तीनों मॉडलों में समान ड्राफ्टिंग कार्यभार, इनपुट और आउटपुट को एक साथ गिना गया:

तालिका OpenRouter संदर्भ भी दिखाती है, ताकि आप देख सकें कि कुल कैसे तुलना करता है। टोकन अनुमान आपके बदलने के लिए हैं: यदि आपके टिकट लंबे हैं, तो न्यायाधीश इनपुट सबसे तेज़ी से बढ़ता है, क्योंकि इसमें दोनों उत्तर दो बार होते हैं। यदि आपका न्यायाधीश उत्तर देने से पहले ज़ोर से सोचता है, तो उसका आउटपुट नंबर भी बढ़ता है, और आपका लॉग इसे दिखाएगा। अनुरोध से पहले टोकन गिनने की आदत के लिए, अनुरोध भेजने से पहले टोकन गिनें देखें।

Clocktower जो समान सीमा उपयोग करता है, वह चुराने लायक है। यह प्रति टर्न 8,000 टोकन सेट करता है, और आपके पास पहले से max_tokens है। इसे SETTINGS में डालें और एक भागता हुआ उत्तर चुपचाप आपके अनुमान को कई गुना नहीं कर सकता।

पूरा रन शुरू करने से पहले#

वह अंतिम आइटम मायने रखता है। तीन टिकट चलाएं, calls.jsonl खोलें और पढ़ें। जांचें कि finish में stop कहता है length के बजाय; यदि कोई मसौदा max_tokens द्वारा काट दिया गया था, तो एक मॉडल केवल इसलिए हार रहा हो सकता है क्योंकि उसका उत्तर काट दिया गया था। न्यायाधीश के कॉल के लिए भी यही बात लागू होती है: वहाँ एक length एक मौन बराबरी में बदल जाता है, इसलिए None निर्णयों को भी गिनें। यदि आपके कार्य का एक ही सही उत्तर है, तो आपको न्यायाधीश की बिल्कुल आवश्यकता नहीं हो सकती: 20 मामलों पर अपने प्रॉम्प्ट का परीक्षण सटीक-मिलान ग्रेडिंग के साथ करें।

परिणाम को स्वयं को मूर्ख बनाए बिना पढ़ना#

wins में तीन संख्याओं को देखें। तीस टिकट एक छोटा नमूना है: 12 से 9 के बंटवारे और 9 बराबरियों के साथ बताता है कि मॉडल करीब हैं, यह नहीं कि एक बेहतर है। लॉग यहाँ मदद करता है। यदि एक मॉडल थोड़ा जीतता है लेकिन बहुत अधिक आउटपुट का उपयोग करता है, तो असली सवाल कार्य की कीमत है, जीत की गिनती नहीं; प्रति 1M टोकन कीमत बनाम प्रति कार्य लागत उस तुलना पर चलता है।

यदि परिणाम करीब है, तो कार्य के लिए सस्ता मॉडल चुनें, या अधिक टिकट जोड़ें और फिर से चलाएं। दोनों को आज़माना सस्ता है क्योंकि पूरी मशीनरी पहले से ही एक लूप है। जब आप किसी अन्य मॉडल पर अभ्यास दोहराना चाहते हैं, तो ऊपर के तीन मॉडल एक API और एक कुंजी के पीछे हैं: दस्तावेज़ों में सेटअप प्रत्येक के लिए समान है, और मूल्य निर्धारण पृष्ठ सूचीबद्ध करता है कि अभी प्रत्येक की लागत क्या है। Dwarkesh Patel का OpenAI बनाम Anthropic मॉडलों पर अपना निष्कर्ष (पहचान बनाम धोखा) उनके खेल के लिए उनका परिणाम है; आपका आपके टिकटों से आएगा।