Para mag-evaluate ng LLM bago lumipat, patakbuhin ang dalawang model sa 50 hanggang 200 totoong prompt na alam ang tamang resulta. Mag-score muna gamit ang code check, at gumamit lang ng debiased na LLM judge kung saan hindi kayang magpasya ng code. I-log ang gastos at latency, at itakda nang maaga ang pass rule.
Maliit lang ang pagbabago sa code: sa OpenAI-compatible na API, base URL at model ID lang ito. Saklaw ng migration checklist ang bahaging iyon, at saklaw ng checklist sa provider ang presyo, limit at privacy. Ang mahirap ay malaman kung kasinghusay ang bagong model para sa mga task mo. Hindi iyan sinasagot ng mga pampublikong leaderboard; pambuo ng shortlist ang Artificial Analysis at mga alternatibo nito. Ang sumasagot ay isang maliit na eval set na binuo mula sa sarili mong traffic, sa isa o dalawang araw na trabaho.
Paano bumuo ng eval set mula sa totoong traffic?
- Kumuha ng 300 hanggang 1,000 kamakailang request mula sa iyong usage log, pagkatapos ng redaction.
- I-grupo ayon sa uri ng task: extraction, classification, summarisation, sagot sa chat, code edit, tool call.
- Kumuha ng sample na 10 hanggang 40 kada uri, mas marami para sa mga uring mataas ang volume o panganib. Isama ang mahahabang prompt, input na hindi English at ang mga case na inireklamo ng mga user.
- Isulat ang inaasahang resulta para sa bawat isa: eksaktong value, isang schema, test na dapat pumasa, o maikling rubric (“binabanggit ang refund window; walang inimbentong patakaran”).
- I-tag ang mga kritikal na case. Hindi kapareho ng bahagyang pangit na tono ang maling total sa invoice o nag-leak na instruction.
- I-freeze ito sa version control. Magdagdag ng case kapag may bagong palya, pero huwag kailanman magbura para lang gumanda ang itsura ng isang model.
Aling check ang dapat sa code at alin ang sa judge?
Gamitin ang pinakamurang maaasahang check para sa bawat case:
| Task | Check | Kailangan ng judge? |
|---|---|---|
| JSON extraction | Nag-parse, pumasa sa schema, tugma ang mga field sa inaasahan | Hindi |
| Classification | Tugma ang label sa inaasahan | Hindi |
| Code edit | Pumasa ang mga test | Hindi |
| Tool call | Tamang function, pumasa ang validation ng arguments | Hindi |
| Buod | May kinakailangang fact; walang fact na wala sa source | Minsan |
| Sagot sa chat, tono, pagiging matulungin | Rubric | Oo |
Libre, nauulit at hindi nabobola ang mga deterministic na check, kaya ilipat sa code check ang pinakamaraming case na kaya mo.
Ano ang nagkakamali sa LLM-as-a-judge?
Ang LLM-as-a-judge ay model na nagmamarka sa sagot ng ibang model ayon sa isang rubric. Nakita ng pag-aaral na MT-Bench (Zheng et al.) na sumang-ayon ang malalakas na judge sa preference ng tao nang mahigit 80% ng pagkakataon, halos kasindalas ng pagsang-ayon ng mga tao sa isa’t isa. Pinangalanan din ng parehong paper ang mga bias na kailangan mong paghandaan sa disenyo:
| Bias | Ano ang nangyayari | Lunas |
|---|---|---|
| Position | Mas pinipili ang unang (o pangalawang) sagot na ipinakita | Dalawang beses i-judge ang bawat pares, pinagpalit ang pagkakasunod; bilangin lang na panalo kung pareho ang dalawa |
| Verbosity | Mas pinipili ang mas mahahabang sagot | Rubric na nagbibigay-gantimpala sa pagiging tama at maikli; lagyan ng limit ang haba sa prompt |
| Self-preference | Mas pinipili ang mga sagot na kapareho ng sarili nitong istilo | Judge mula sa model family na iba sa dalawang kandidato |
| Mahinang reasoning | Hindi napapansin ang mali sa math o code | Code check ang gamitin para sa mga case na iyon |
Dalawa pang rule mula sa praktika. I-pin ang judge: parehong bersyon ng model, parehong prompt, temperature 0, sa buong paghahambing. At i-calibrate ito: ikaw mismo ang mag-label ng 30 hanggang 50 pares, patakbuhin ang judge sa mga iyon, at pagkatiwalaan lang ito kung kadalasang sumasang-ayon ito sa iyo. Ganito rin ang payo ng evaluator guide ng Arize (“Collect 20–100 examples”; salin: mangolekta ng 20–100 halimbawa) na may label ng tao, at inirerekomenda nito ang mga categorical na label gaya ng pass/fail kaysa sa malalaking numeric na scale.
Paano magpatakbo ng magkatabing paghahambing?
Patakbuhin ang dalawang kandidato sa bawat case, itago sa judge kung alin ang alin, pagpalitin ang pagkakasunod, at i-log ang gastos at oras:
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}
Dahil sa swap rule, nananalo lang ang isang model kapag mas pinili ito ng judge sa dalawang posisyon; tabla ang anumang hindi pagkakasundo. May silbi rin ang bahagi ng hindi pagkakasundo: kapag mataas ito, masyadong malabo ang judge o ang rubric. Pansinin ang max_tokens=4000: sa mga reasoning model, kasama sa limit ang pag-iisip, at nagbubunga ang mababang cap ng mga walang lamang sagot na mukhang palya. Tingnan ang bakit walang lamang sagot ang ibinabalik ng mga reasoning model.
Gaano kalaking pagkakaiba ang totoo?
Mga sample ang eval score. Para sa pass rate na p sa n na case, ang standard error ay √(p × (1 − p) ÷ n), at ang 95% margin ay mga doble niyon.
| Mga case | Pass rate | 95% margin |
|---|---|---|
| 50 | 80% | mga ±11 puntos |
| 100 | 80% | mga ±8 puntos |
| 200 | 80% | mga ±6 puntos |
| 400 | 80% | mga ±4 puntos |
Kaya hindi pa napapatunayang mas mahusay ang model na 82% laban sa 79% sa 100 case. Tingnan na lang ang pagkakaiba kada case: aling mga case ang lumipat mula pass papuntang fail? Mas marami ang sinasabi ng mga iyon kaysa sa kabuuan, at sa mga kritikal na case, puwedeng isang paglipat lang ang magpasya sa paglipat ng provider.
Ano dapat ang decision rule?
Isulat ito bago mo patakbuhin ang eval, para hindi ito mabaluktot ng resulta. Isang praktikal na template:
- Walang regression sa anumang case na naka-tag na kritikal.
- Hindi mas mababa ang kabuuang pass rate kaysa sa kasalukuyang model nang higit sa margin of error.
- Pasok sa budget mo ang p95 na latency; tingnan ang TTFT vs throughput para sa kung paano ito sukatin.
- Mas mababa ang gastos kada matagumpay na case, o mas mataas lang nang halagang napagkasunduan ninyong sulit para sa quality. Presyuhan ang buwanang pagkakaiba gamit ang LLM API cost calculator.
- Shadow period: ipadala ang bahagi ng live traffic sa bagong model, i-log ang dalawa, at ihambing bago tuluyang lumipat.
Ang parehong eval set din ang simula kung nag-iisip ka ng custom na model: saklaw ng bago mag-fine-tune kung kailan sapat na ang prompt at retrieval.
Saan pumapasok ang BroadNet Inference
Nagse-serve ang BroadNet Inference ng ilang model family sa likod ng iisang OpenAI-compatible na endpoint, kasama ang DeepSeek V4.1 Flash, GLM 5.3 at Qwen3.8 27B, kaya puwedeng tumakbo sa parehong client at key ang mga kandidato at isang judge mula sa ibang family. May token usage ang bawat response para sa paghahambing ng gastos, at nagsisimula ang mga bagong account sa $5 na credit; kung walang top-up, Gemma 4 VL 26B lang ang napapatakbo ng credit na iyon, kaya magplano ng maliit na top-up para maihambing ang mas malalaking model. Wala itong kasamang evaluation harness o hosted na judge tooling; ikaw mismo ang magpapatakbo ng code sa itaas. Para sa mga workload sa Arabic, inililista ng pagpili ng LLM para sa Arabic kung ano ang ite-test. Nasa compare page ang magkatabing presyo.
