---
title: "Mag-evaluate ng LLM bago lumipat: eval set at LLM judge"
description: "Bumuo ng eval set mula sa totoong traffic, i-score gamit ang code check at debiased na LLM judge, at ihambing ang quality, gastos at latency bago mag-migrate."
url: https://broadrouter.com/fil/blog/evaluate-llm-before-switching/
lang: fil
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Isinalin mula sa Ingles sa tulong ng AI. [Basahin ang orihinal sa Ingles](https://broadrouter.com/blog/evaluate-llm-before-switching/) (na-update noong 2026-11-14).

# Paano mag-evaluate ng LLM bago lumipat ng provider

Ng BroadNet Inference team · 5 minutong basa · Nailathala 2026-11-14

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.

## Mga pangunahing punto

-   Buuin ang eval set mula sa totoong log, hindi sa inimbentong prompt, at isama ang mahihirap at pumapalyang case.
-   Unahin ang deterministic na check (nag-parse ang JSON, tama ang field, pumasa ang test). Gumamit lang ng LLM judge para sa mga katangiang hindi kayang i-check ng code.
-   May position, verbosity at self-preference bias ang mga LLM judge. Dalawang beses i-judge ang bawat pares, pinagpalit ang pagkakasunod.
-   Sa 100 case, ang score na 80% ay may 95% margin na mga ±8 puntos. Ingay lang ang maliliit na pagkakaiba.
-   Itakda nang maaga ang pass rule, kasama ang gastos, latency at walang regression sa mga kritikal na case.

**Sa page na ito**

1.  Paano bumuo ng eval set mula sa totoong traffic?
2.  Aling check ang dapat sa code at alin ang sa judge?
3.  Ano ang nagkakamali sa LLM-as-a-judge?
4.  Paano magpatakbo ng magkatabing paghahambing?
5.  Gaano kalaking pagkakaiba ang totoo?
6.  Ano dapat ang decision rule?
7.  Saan pumapasok ang BroadNet Inference

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](https://broadrouter.com/fil/glossary/openai-compatible-api/), [base URL](https://broadrouter.com/fil/glossary/base-url/) at model ID lang ito. Saklaw ng [migration checklist](https://broadrouter.com/fil/blog/openai-compatible-api-migration-checklist/) ang bahaging iyon, at saklaw ng [checklist sa provider](https://broadrouter.com/fil/blog/choose-llm-api-provider-checklist/) 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](https://broadrouter.com/fil/blog/artificial-analysis-alternatives/). Ang sumasagot ay isang maliit na [eval](https://broadrouter.com/fil/glossary/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](https://broadrouter.com/fil/blog/llm-api-usage-logging/), 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](https://broadrouter.com/fil/glossary/llm-as-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:

```python
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](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/).

## 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](https://broadrouter.com/fil/blog/llm-latency-ttft-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](https://broadrouter.com/tools/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](https://broadrouter.com/fil/blog/fine-tuning-readiness/) 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](https://broadrouter.com/fil/models/deepseek-v4.1-flash/), [GLM 5.3](https://broadrouter.com/fil/models/glm-5.3/) at [Qwen3.8 27B](https://broadrouter.com/fil/models/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](https://broadrouter.com/fil/models/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](https://broadrouter.com/fil/blog/choosing-an-llm-for-arabic/) kung ano ang ite-test. Nasa [compare page](https://broadrouter.com/compare/) ang magkatabing presyo.

Mga libreng tool para rito (Ingles)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Libreng tools (Ingles)](https://broadrouter.com/tools/)

## Mga termino sa artikulong ito

[LLM-as-a-judge](https://broadrouter.com/fil/glossary/llm-as-judge/)

Ang LLM-as-a-judge ay paraan ng evaluation kung saan isang language model ang nagma-marka sa output ng ibang model, sa pag-score ng iisang sagot batay sa rubric o sa pagpili ng mas mahusay sa dalawang sagot. Malapit ito sa paghusga ng tao sa mas mababang gastos pero may mga kilalang bias, gaya ng pagpabor sa una o mas mahabang sagot.

[Eval (LLM evaluation)](https://broadrouter.com/fil/glossary/eval/)

Ang eval (maikli para sa evaluation) ay isang paulit-ulit na test ng language model o prompt: fixed na set ng mga input, paglalarawan kung ano ang magandang output, at grader (code, tao o ibang model) na nagbibigay ng score sa bawat output para maikumpara ang mga bersyon.

[Latency](https://broadrouter.com/fil/glossary/latency/)

Ang latency, para sa isang language model API, ay ang tagal ng isang request mula sa pagpapadala hanggang matanggap ang huling output token. Kabuuan ito ng time to first token at ng generation time, at kadalasang iniuulat bilang percentile gaya ng p50 at p95 sa halip na average.

[Prepaid credit](https://broadrouter.com/fil/glossary/prepaid-credit/)

Ang prepaid credit ay perang idinadagdag sa isang API account bago gamitin. Ibinabawas sa balance ang gastos ng bawat request, at kapag naubos ang balance, titigil ang mga metered request hanggang mag-top-up ka. Nililimitahan nito ang gastos sa halagang naibayad mo na.

[API key](https://broadrouter.com/fil/glossary/api-key/)

Ang API key ay isang lihim na string na kumikilala at nagpapahintulot sa client na tumatawag sa isang API. Kadalasang hinihingi ito ng mga LLM API sa Authorization: Bearer header, at ang sinumang may hawak ng key ay makakagawa ng mga request na sisingilin sa account na may-ari nito.

[Base URL](https://broadrouter.com/fil/glossary/base-url/)

Ang base URL ay ang fixed na root address ng isang API, gaya ng https://api.example.com/v1, na idinudugtong ng client sa unahan ng bawat endpoint path, gaya ng /chat/completions. Sa mga OpenAI-compatible SDK, kapag pinalitan ang base URL, kasama ang API key at model ID, sa ibang provider na tatawag ang parehong code.

[Temperature](https://broadrouter.com/fil/glossary/temperature/)

Ang temperature ay isang sampling parameter na kumokontrol kung gaano ka-random ang output ng isang language model. Hinahati ng model ang score ng bawat token sa temperature bago gawing probability: sa mababang value, nangingibabaw ang pinaka-malamang na token; sa mataas na value, pumapantay ang distribution kaya mas madalas mapili ang hindi gaanong malamang na token.

[Throughput](https://broadrouter.com/fil/glossary/throughput/)

Ang throughput, sa LLM serving, ay ang kabuuang trabahong natatapos ng isang system kada yunit ng oras sa lahat ng sabay-sabay na request, kadalasang sinusukat bilang output tokens per second o requests per second. Iba ito sa bilis kada stream, na kung gaano kabilis natatanggap ng iisang request ang mga token nito.

## 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.

## Magbasa pa

-   [Paano pumili ng LLM API provider: 20-point na checklist](https://broadrouter.com/fil/blog/choose-llm-api-provider-checklist/)
-   [Paglipat sa OpenAI-compatible API: checklist sa migration](https://broadrouter.com/fil/blog/openai-compatible-api-migration-checklist/)
-   [Pagpili ng LLM API para sa Arabic: ano ang dapat i-test](https://broadrouter.com/fil/blog/choosing-an-llm-for-arabic/)
-   [Usage logging ng LLM API: gastos kada user at feature, walang PII](https://broadrouter.com/fil/blog/llm-api-usage-logging/)
-   [LLM latency: TTFT vs tokens per second vs end-to-end na oras](https://broadrouter.com/fil/blog/llm-latency-ttft-throughput/)
-   [Bago mag-fine-tune: tukuyin muna ang problemang lulutasin](https://broadrouter.com/fil/blog/fine-tuning-readiness/)
-   [GPU hardware at paraan ng serving ng BroadNet, ayon sa BroadNet](https://broadrouter.com/fil/blog/broadnet-gpu-fleet-and-serving/)
-   [I-cache ang LLM API response, makatipid: exact-match cache sa Python](https://broadrouter.com/fil/blog/cache-llm-responses-cut-cost/)
-   [Gabay: Paano gamitin ang OpenAI Python SDK sa BroadNet Inference](https://broadrouter.com/fil/guides/openai-python-sdk/)
-   [Gabay: Bakit walang laman ang sagot ng isang reasoning model](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/)

Subukan ito sa totoong workload mo. May US$5 na panimulang credit ang mga bagong account para sa Gemma at transcription. Kailangan ng top-up para sa DeepSeek, GLM, at Qwen3.8.

[Magsimula](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-evaluate-llm-before-switching&utm_content=page-cta) ·

**Mga source**

-   [Zheng et al., Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena, arXiv 2306.05685 (kinuha noong 2026-11-14)](https://arxiv.org/abs/2306.05685)
-   [Arize docs, best practice para sa evaluator (kinuha noong 2026-11-14)](https://arize.com/docs/ax/concepts/evaluators/evaluator-best-practices)
-   [API reference ng BroadNet Inference (kinuha noong 2026-11-14) (Ingles)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-evaluate-llm-before-switching&utm_content=sources)
-   [Machine-readable na presyo ng BroadNet Inference, pricing.json (kinuha noong 2026-11-14) (Ingles)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-evaluate-llm-before-switching&utm_content=sources)
