BroadRouter

Paano mag-evaluate ng LLM bago lumipat ng provider

Ng BroadNet Inference team · 5 minutong basa · Nailathala

Mangolekta ng 50 hanggang 200 totoong prompt na alam ang tamang resulta. I-score muna ang dalawang model gamit ang code check, at gumamit lang ng LLM judge kung saan hindi kayang magpasya ng code. Pagpalitin ang pagkakasunod ng sagot para kanselahin ang position bias, gumamit ng judge mula sa ikatlong model family, i-check ito laban sa sarili mong label, at itakda ang pass rule, kasama ang gastos at latency, bago patakbuhin.

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?

  1. Kumuha ng 300 hanggang 1,000 kamakailang request mula sa iyong usage log, pagkatapos ng redaction.
  2. I-grupo ayon sa uri ng task: extraction, classification, summarisation, sagot sa chat, code edit, tool call.
  3. 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.
  4. 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”).
  5. I-tag ang mga kritikal na case. Hindi kapareho ng bahagyang pangit na tono ang maling total sa invoice o nag-leak na instruction.
  6. 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:

  1. Walang regression sa anumang case na naka-tag na kritikal.
  2. Hindi mas mababa ang kabuuang pass rate kaysa sa kasalukuyang model nang higit sa margin of error.
  3. Pasok sa budget mo ang p95 na latency; tingnan ang TTFT vs throughput para sa kung paano ito sukatin.
  4. 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.
  5. 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.

Mga tanong

Ilang halimbawa ang kailangan ko sa isang LLM eval set?

Sapat ang limampu para mahuli ang malalaking regression, 200 para makita ang mga pagkakaibang mga 5 hanggang 10 puntos. Mas mahalaga ang saklaw kaysa sa laki, kaya isama ang bawat uri ng task at ang mga alam mong pumapalyang case.

Maaasahan ba ang LLM-as-a-judge?

Bahagya. Sa pag-aaral na MT-Bench, 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. Nagpakita rin sila ng position, verbosity at self-enhancement bias, kaya i-debias at i-spot-check sila.

Dapat bang parehong model ang judge at ang tine-test na model?

Hindi. Kinikilingan ng mga judge ang mga sagot na kahawig ng sarili nila. Gumamit ng judge mula sa ibang model family, at panatilihin ito sa iisang bersyon sa buong paghahambing.

Ano ang position bias sa LLM evaluation?

Mas pinipili ng judge ang sagot na nauuna, o ang pangalawa, anuman ang quality. Ayusin ito sa pag-judge sa bawat pares nang dalawang beses na pinagpalit ang pagkakasunod, at bilangin lang na panalo kapag pareho ang resulta sa dalawang pagkakasunod.

Dapat ko bang ihambing ang gastos at latency sa parehong eval?

Oo. I-log ang token at oras sa bawat eval call. Ang model na dalawang puntos na mas mataas ang score pero tatlong beses ang gastos o latency ay posibleng maling lipatan pa rin.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity