Patas na paghahambing ng dalawang LLM sa gawain mo: side-swap at cost log

Nagpatakbo ka ng tatlong prompt sa dalawang modelo, at nanalo ang pangalawa. Bago mo ito paniwalaan, tingnan kung alin ang nakalista pangalawa. Ang patas na paghahambing ay nangangailangan ng tatlong bagay: magkaparehong setting para sa dalawang modelo, bawat pares ay hinuhusgahan sa parehong pagkakasunod-sunod, at log ng tokens bawat tawag, para alam mo kung magkano ang buong run. Nasa ibaba ang isang maliit na Python script na gumagawa ng tatlong ito sa sarili mong gawain.

Ano ang ginagawa ng pampublikong tournament na maaari mong hiramin#

Ang Clocktower Bench ni Dwarkesh Patel ay isang hindi opisyal na research project kung saan naglalaban ang mga language model sa social-deduction game na Blood on the Clocktower. Hindi ang laro ang mahalaga dito; ang harness. Ayon sa About page ng proyekto (sinuri noong 8 Nobyembre 2026), may ilang bagay itong ginagawa na dapat gawin ng anumang head-to-head:

• isang modelo ang pumupuno sa lahat ng good seats at isa pa sa lahat ng evil seats, at bawat deal ay nilalaro nang dalawang beses na pinagpapalit ang panig, para hindi ang mapalad na upuan ang magpasya sa resulta;
• lahat ng modelo ay may parehong setting: parehong reasoning effort, 8,000-token na kisame bawat turn at 150-word na limit sa pagsasalita;
• ang Storyteller ay naka-script, kaya walang modelong nagre-referee sa laro;
• bawat API call ay isinusulat sa calls.jsonl kasama ang tokens at gastos nito. Sinasabi ng page na ang isang laro ay nagkakahalaga mula sa mga $2 hanggang $50, depende sa mga modelo (sa OpenAI at Anthropic APIs).

Ang harness ay ginawa para sa OpenAI at Anthropic models, at malamang hindi board game ang gawain mo. Pero ang tatlong ugali ay naipapasa: pantay na setting, pinagpalit na panig, at cost log. Ang natitirang bahagi ng gabay na ito ay inilalapat ang mga ito sa isang ordinaryong bagay.

Ang gawain: pag-draft ng mga sagot sa 30 support ticket#

Sabihin nating may maliit kang support desk at gusto mong malaman kung alin ang mas magandang sumulat ng first draft: DeepSeek-V4-Flash o GLM-5.3-Flash. Mayroon kang file na tickets.jsonl na may 30 totoong ticket, isang JSON object bawat linya: {"id": 1, "text": "..."}.

OpenAI-compatible ang API, kaya gumagana ang opisyal na openai package sa CheapTokens sa https://api.cheaptokens.dev/v1. Gamitin ang buong model ids mula sa docs: deepseek-ai/DeepSeek-V4-Flash-0731 at zai-org/GLM-5.3-Flash. Pareho ring binibigyan ang dalawang modelo ng pangatlong modelo bilang judge, MiniMaxAI/MiniMax-M2.7, para walang contestant ang nagmamarka sa sariling gawa.

Simulan sa bahaging nagpapagana sa log: isang function kung saan dumadaan ang bawat tawag.

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)

Ang mga field sa calls.jsonl ay ang pinipili ng script na ito; ang usage numbers ay nagmumula sa usage object ng API response. Pareho ang system prompt, pareho ang temperature at pareho ang max_tokens ng dalawang modelo. Baguhin ang isa sa mga ito para sa isang modelo at setting na ang pinaghahambing mo, hindi modelo.

Pagpalitin ang panig: husgahan ang bawat pares nang dalawang beses#

Ngayon ang judge. Maaaring kumiling ang isang judge model sa sagot sa isang partikular na slot, kaya ang isang verdict ay naghahalo ng kalidad at posisyon. Ang Clocktower trick ay akma nang husto: ipakita ang bawat pares sa parehong papel. Nanalo ang isang sagot sa isang ticket kung pinili ito ng judge sa parehong pagkakasunod-sunod. Kung ang verdict ay sumusunod sa slot sa halip na sa sagot, tie ang ticket.

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)

Dalawang detalye ang madaling makalimutan. Ang judge ay tumatakbo sa temperature=0 para maging mas matatag ang verdicts nito; hindi lahat ng modelo ay sumusunod sa setting na iyon, kaya i-rerun ang ilang pares at ihambing ang verdicts bago mo ito paniwalaan. Ang verdict ay binabasa lamang mula sa huling Verdict: na linya, at ang mga cap ay maluwag (800 para sa drafts, 1000 para sa judge) para ang modelong nag-iisip bago sumagot ay hindi maputol sa gitna ng pag-iisip; ang estimate sa ibaba ay gumagamit ng karaniwang laki, hindi ang mga cap. Ang hindi ma-parse na sagot ay nagbibigay ng None, na nahuhulog sa tie sa halip na mag-crash ang run.

Ang pagkakasunod-sunod ay isa lamang paraan para i-tilt ang isang test. Ang settings, prompts at logging ay maaari ring mag-tilt, kaya suriin ang buong setup, hindi lang kung sino ang nauna. Narito ang parehong eksperimento bago at pagkatapos.

I-log ang bawat tawag, pagkatapos i-price ang run#

Ang log ang nagiging budget ng paghahambing. Pagkatapos ng run, isum ang tokens bawat modelo:

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")

Makakakuha ka ng isang linya bawat modelo na may call count, input tokens at output tokens. I-multiply sa dalawang presyo ng modelo (input at output ay hiwalay na sinisingil) o, mas madali, i-paste ang totals sa isang live cost marker.

Maaari ka ring mag-estimate bago ka mag-run. Ipagpalagay na ang bawat ticket kasama ang system prompt ay mga 300 input tokens, ang draft ay mga 250 output tokens, at ang judge ay nakakakita ng mga 800 input tokens (ticket kasama ang dalawang sagot at ang tanong) at sumasagot ng mga 200 tokens (ang verdict line at kaunting espasyo para mag-isip):

• drafts: 30 tickets × 2 models = 60 calls, 30 × 300 = 9000 input at 30 × 250 = 7500 output tokens bawat contestant;
• verdicts: 30 tickets × 2 orders = 60 calls, 60 × 800 = 48000 input at 60 × 200 = 12000 output tokens sa judge.

Sa kasalukuyang presyo, ang 30 drafts ng isang contestant ay nagkakahalaga ng $0.00089 sa DeepSeek-V4-Flash at $0.00048 sa GLM-5.3-Flash. Ang 60 verdicts sa MiniMax-M2.7 ay nagkakahalaga ng $0.0042. Idagdag ang tatlo at mayroon ka nang presyo ng buong paghahambing bago ka magpadala ng kahit isang request. Ang parehong drafting workload sa lahat ng tatlong modelo, na pinagsama ang input at output:

Ipinapakita rin ng table ang OpenRouter reference, para makita mo kung paano inihahambing ang total. Ang mga token assumption ay sa iyo na baguhin: kung mahaba ang tickets mo, ang judge input ang pinakamabilis lumaki, dahil dinadala nito ang dalawang sagot nang dalawang beses. Kung nag-iisip nang malakas ang judge mo bago sumagot, lumalaki rin ang output number nito, at makikita ito ng log mo. Para sa ugali ng pagbilang ng tokens bago ang isang request, tingnan ang count tokens before you send a request.

Ang parehong cap na ginagamit ng Clocktower ay sulit hiramin. Nagtatakda ito ng 8,000 tokens bawat turn, at mayroon ka nang max_tokens. Ilagay ito sa SETTINGS at hindi na makakapag-multiply nang tahimik ang isang runaway na sagot sa estimate mo.

Bago mo ilunsad ang buong run#

Mahalaga ang huling item. Magpatakbo ng tatlong ticket, buksan ang calls.jsonl at basahin ito. Tiyakin na ang finish ay nagsasabing stop sa halip na length; kung ang isang draft ay naputol ng max_tokens, maaaring natatalo ang isang modelo dahil lang sa na-truncate ang sagot nito. Ganoon din sa mga tawag ng judge: ang length doon ay nagiging tahimik na tie, kaya bilangin din ang None na verdicts. Kung ang gawain mo ay may isang tamang sagot, maaaring hindi mo na kailangan ang judge: test your prompt on 20 cases with exact-match grading.

Pagbasa ng resulta nang hindi niloloko ang sarili#

Tingnan ang tatlong numero sa wins. Tatlumpung ticket ay maliit na sample: ang hatian na 12 laban 9 na may 9 ties ay nagsasabi na malapit ang mga modelo, hindi na mas magaling ang isa. Nakakatulong dito ang log. Kung ang isang modelo ay nananalo nang bahagya pero gumagamit ng mas maraming output, ang tunay na tanong ay ang presyo ng gawain, hindi ang bilang ng panalo; price per 1M tokens versus cost per task ay tumatalakay sa paghahambing na iyon.

Kung malapit ang resulta, piliin ang mas murang modelo para sa gawain, o magdagdag ng mas maraming ticket at i-rerun. Pareho itong murang subukan dahil loop na ang buong makinarya. Kapag gusto mong ulitin ang ehersisyo sa ibang modelo, ang tatlong modelo sa itaas ay nasa likod ng isang API at isang key: pareho ang setup sa docs para sa bawat isa, at nakalista sa pricing page ang kasalukuyang presyo ng bawat isa. Ang sariling natuklasan ni Dwarkesh Patel sa OpenAI laban sa Anthropic models (detection versus deception) ay resulta niya para sa kanyang laro; ang sa iyo ay magmumula sa iyong mga ticket.