在线AI教程 / AI上云
[OpenRouter] How to Benchmark LLMs
如何给 LLM 做基准测试 OpenRouter ·11/12/2026 用你自己应用的输入与输出格式里拿到的证据来挑模型。把完全相同的任务经 OpenRouter 跑一遍,比较判
如何给 LLM 做基准测试
OpenRouter ·11/12/2026


用你自己应用的输入与输出格式里拿到的证据来挑模型。把完全相同的任务经 OpenRouter 跑一遍,比较判分后的准确率、计费成本和请求耗时。在我们的 60 个合成任务上,GPT-6.1 Sol 在所测契约与设置下、跨三轮重复通过 180/180 次试验。
太长不看(TL;DR)
代码检查衡量正确性与输出合规性。 Sol 在我们的合成集上通过 180/180 次试验;DeepSeek 的回答成本最低,通过 157/180 次。 与公开排行榜的一致性很弱,Spearman 相关系数仅 0.109。 在信任一个分数之前,先查每个任务跑了多少次、拿回多少条回答、以及每笔账单是否都已核验。
先把行为定义清楚,再定义它的检查。
第 1 步:写出答案能被脚本核验的任务
一个任务需要输入、预期答案和输出契约。对发票,要写明计入哪些行、舍入方式,以及可接受的货币后缀。
全部 40 个 baseline 任务和 20 个 hard 任务,我们都在最终运行之前就写好了。
类别示例检查 发票算术折扣后未付款行的合计十进制总额与舍入 日期与排期转换一个时间戳,或列出匹配的日期精确的时刻或日期列表 邮件提取把字段提取成 JSON键、类型与值 Python 函数针对隐藏输入实现一个函数在隔离 runtime 里的结果 输出约束在指定限制内产出文本长度、词汇与格式 退款决策在书面政策的边界上套用它每个订单的决策
参考答案要独立算出。把 prompt 调优用的 case 与最终评估分开。退款 case 只检验书面决策,不执行交易。
第 2 步:用代码判分,并检验判分器
对 APPROVE 用精确匹配,对 JSON 用 schema/值检查。只把允许的差异做归一化。若你的消费方只收一个数字,那么容忍数字周围的散文,就会把一次失败藏起来。
拿已知正确、错误和格式畸形的回答来测。对退款阈值,把正好 $200 和正好 30 天纳入,再取各边界之上一点的值。
我们开发用的检查器曾把合法 Python 判成无效,因为它漏了 ord 和 type。最终研究之前我们修好了它,明确指定 CPython 3.12.10/WASI 并加资源限制。否则检查器的失败会被算到模型头上。
完整研究的 runner 会隔离生成的代码,并在 sandbox 环境缺失时停下。教学示例不执行任何生成代码。
第 3 步:跑三任务 Python 示例
下载配套 ZIP。解压之前,把它的 SHA-256 校验和与下面这个值比对:
a38ee17a2eb7090f9f4849a605cc8214691c889ca0ae40c121259603592178e8
PowerShell:
Get-FileHash .\benchmark-reader-companion.zip -Algorithm SHA256
Linux 或 macOS:
Linux
sha256sum benchmark-reader-companion.zip
macOS
shasum -a 256 benchmark-reader-companion.zip
若两个值不一致,停下来检查下载。一致之后再解压 ZIP。你需要 Python 3.12 或更高版本。标准库版教学 runner、JSON 示例和比较逻辑已在 Windows x64 与 Linux 上通过离线检查;macOS 仍未测试。随包附带的完整研究 sandbox 与原生 Ori 安装仅支持 Windows x64。
在解压出来的文件夹里:
python verify_package.py python three_tasks.py check
这条 check 打印 OFFLINE reference and grader checks passed; zero inference calls。完整脚本按文件顺序给出。它的配套模块负责请求、持久化和报告。
"""Three exact contracts; run from the extracted companion (standard library).""" import argparse from datetime import datetime, timezone from decimal import Decimal import json from pathlib import Path import re
from reader_core import execute, reconcile, report, read, load_config, finish_grade
TASKS = [ {"id": "invoice", "prompt": "Two unpaid lines cost 3 x 12.50 USD and 2 x 4.25 USD. Return only their total with exactly two decimal places.", "expected": "46.00"}, {"id": "utc", "prompt": "Convert 2026-10-18T10:30:00+02:00 to UTC. Return only YYYY-MM-DDTHH:MM:SSZ.", "expected": "2026-10-18T08:30:00Z"}, {"id": "refund", "prompt": "Policy: approve only if amount <= 200 USD and age <= 30 days. Amount=200 USD; age=30 days. Return only APPROVE or DENY.", "expected": "APPROVE"}, ]
def refund_policy(amount, days): return "APPROVE" if Decimal(str(amount)) <= 200 and days <= 30 else "DENY"
def grade(task, text, finish): terminal = finish_grade(finish) if terminal: return terminal if not isinstance(text, str) or not text.strip(): return {"passed": False, "classification": "empty"} text = text.strip() patterns = {"invoice": r"\d+\.\d{2}", "utc": r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z", "refund": r"APPROVE|DENY"} valid = bool(re.fullmatch(patterns.get(task["id"], r"\d+\.\d{2}"), text)) passed = valid and text == task["expected"] and finish == "stop" return {"passed": passed, "classification": "pass" if passed else ("incorrect" if valid else "malformed")}
在采用一个分数之前,先查它的参考答案与拒绝规则。这些离线夹具覆盖边界决策、无效格式和被截断的回答,且不调用模型。
def offline(): money = Decimal(3) Decimal("12.50") + Decimal(2) Decimal("4.25") assert format(money, ".2f") == TASKS[0]["expected"] utc = datetime.fromisoformat("2026-10-18T10:30:00+02:00") assert utc.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") == TASKS[1]["expected"] assert refund_policy(200, 30) == TASKS[2]["expected"] for amount, days, expected in [(200.01, 30, "DENY"), (200, 31, "DENY"), (199.99, 29, "APPROVE"), (0, 0, "APPROVE")]: assert refund_policy(amount, days) == expected for task in TASKS: assert grade(task, task["expected"], "stop")["passed"] for bad in ("wrong", None, "", '{"answer": 46}', "APPROVE please"): assert not grade(task, bad, "stop")["passed"] assert not grade(task, task["expected"], "length")["passed"] assert not grade(TASKS[0], "47.00", "stop")["passed"] assert not grade(TASKS[2], "DENY", "stop")["passed"] print("OFFLINE reference and grader checks passed; zero inference calls.")
把检查与花钱分开。命令行接口默认做离线校验,推理之前必须显式给 live 选项和额度。
def main(tasks=None, grader=grade, default_config="demo-config.json", offline_check=None): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("operation", nargs="?", default="check", choices=["check", "plan", "run", "report", "reconcile"]) parser.add_argument("--config", default=default_config) parser.add_argument("--run-dir", type=Path, default=Path("runs/demo")) parser.add_argument("--live", action="store_true") parser.add_argument("--max-usd", default="0") parser.add_argument("--resume", action="store_true") parser.add_argument("--tasks", help="Optional exact-contract custom task JSON") args = parser.parse_args() if args.operation == "check": if args.tasks: parser.error("Use an example entry point with its own offline_check; check does not accept --tasks overrides") if offline_check is not None: offline_check() elif tasks is not None or grader is not grade or args.tasks: parser.error("Custom tasks/graders require offline_check=... for their own reference and fixture checks") else: offline() return selected = read(args.tasks) if args.tasks else (tasks if tasks is not None else TASKS) config = load_config(args.config) if args.operation == "report": print(json.dumps(report(args.run_dir), indent=2)) elif args.operation == "reconcile": reconcile(args.run_dir, live=args.live) print(json.dumps(report(args.run_dir), indent=2)) else: execute(args.run_dir, selected, config, grader, args.max_usd, live=args.live, resume=args.resume, plan=args.operation == "plan")
if __name__ == "__main__": main()
配置并查看计划
用随包提供的 Luna 配置来设定模型、重复次数、token 额度和 provider 约束:
{ "models": [ "openai/gpt-6-luna" ], "repeats": 1, "max_tokens": 1024, "settings": { "openai/gpt-6-luna": { "provider": { "require_parameters": true, "allow_fallbacks": true, "max_price": { "prompt": 0.09999999999999999, "completion": 0.5, "request": 0 } }, "reasoning": { "effort": "low" } } } }
Sol 的配置保留重复次数与 token 设置,但用它自己的价格上限:
{ "models": [ "openai/gpt-6.1-sol" ], "repeats": 1, "max_tokens": 1024, "settings": { "openai/gpt-6.1-sol": { "provider": { "require_parameters": true, "allow_fallbacks": true, "max_price": { "prompt": 2.0, "completion": 10.0, "request": 0 } }, "reasoning": { "effort": "low" } } } }
models 选候选模型,repeats 指定每个任务发几次请求,max_tokens 设定 completion 额度。reasoning 可能在可见输出之前就把这份额度耗掉。离线检查不发任何 API 调用。付费运行必须显式给 —live 标志。被长度截断的回答直接判失败、不重试。
价格上限以「每百万 token 的美元数」计;Luna 的 prompt 上限约为 $0.10。若某个 provider 不再支持已保存的设置,runner 必须停下,而不是悄悄改掉它们。provider fallback 不会换模型,也不会重发推理。
python three_tasks.py plan --config luna-config.json
实际离线输出:
{"planned_calls": 3, "max_tokens": 1024, "models": ["openai/gpt-6-luna"], "repeats": 1, "estimated_reservations_usd": "0.0023543749999999999565625"}
reservation 只是一个本地成本估算,既不是账户上的冻结,也不是保证的封顶。先做 plan,再定额度。
教学用选择调用数估算 reservations Luna,三个任务3$0.0023544 Sol,三个任务3$0.0470875 Luna,下面的 JSON 任务1$0.00080725 Sol,下面的 JSON 任务1$0.016145
改任务、重复次数或 token 都会改变估算。若花费超出估算,脚本就不再发送新请求。
做一次小额付费运行
在 API-key settings 里建一个 key,充值 credit,并给 key 设一个合适的限额。在你的终端里本地设置变量。
PowerShell:
$env:OPENROUTER_API_KEY = "YOUR_OPENROUTER_API_KEY"
Bash 或 Zsh:
export OPENROUTER_API_KEY="YOUR_OPENROUTER_API_KEY"
若已配好同名变量,直接复用即可。这个包不加载 .env。对随包提供的三任务 Luna 配置:
python three_tasks.py run --config luna-config.json --run-dir runs/my-luna --live --max-usd 0.01 python three_tasks.py reconcile --run-dir runs/my-luna --live python three_tasks.py report --run-dir runs/my-luna
对账只做只读的 generation metadata 查询。报告显示 response coverage(完成的回答数除以计划试验数)、passes/graded、failures、已核验成本和中位请求耗时。账单核验完成之前,报告会把成本保持为未结。请求耗时不含判分和元数据查询,也不是首 token 时间。
真实实跑结果会有波动。下面的合成示例只为演示报告形态,不是对模型的测量。
第 4 步:加你自己的任务和判分器
随包提供的 custom-tasks.json 展示了任务格式:
[ { "id": "custom-total", "prompt": "Four items cost 12.50 USD each. Return only the total with exactly two decimals.", "expected": "50.00" } ]
python custom_task.py check 会用 Decimal 独立算出参考答案,并测试正确、错误和畸形的回答。金额类自定义 ID 走两位小数判分器。另一种契约需要它自己的判分器和检查。
完整的 json_extraction.py 按文件顺序分三部分给出。它允许 JSON 里的空白和键顺序差异,但拒绝缺失、多余或重复的键以及错误的类型。一个 schema 合法但值错了的对象判为 incorrect。被过滤掉或异常结束有各自的分类。
"""A complete exact-schema JSON extraction example; offline check by default.""" import json
from reader_core import finish_grade from three_tasks import main
CUSTOMER_EMAIL = "mira@example.test" ORDER_CODE = "A-104" ITEM_COUNT = 3 SOURCE_TEXT = ("Customer: Mira. Email: mira@example.test. Order: A-104. " "Items: 3. Gift wrap: no.")
Define reference fields from the independently specified source facts.
Do not ask a model (or the grader) to produce the reference.
EXPECTED = {"email": CUSTOMER_EMAIL, "order_id": ORDER_CODE, "item_count": ITEM_COUNT, "gift_wrap": False} TASKS = [{"id": "order-extraction", "grader": "exact-order-json-v1", "prompt": "Extract email, order_id, item_count and gift_wrap from this order. " "Return a JSON object only, with exactly those keys. email and order_id " "are strings; item_count is an integer; gift_wrap is a boolean. " + SOURCE_TEXT, "expected": EXPECTED}]
光有 JSON 语法还不够。先拒绝重复的键和无效的数值,再校验 schema,然后才把字段与参考答案比较。
def strict_json(text): def pairs(items): result = {} for key, value in items: if key in result: raise ValueError("Duplicate JSON key") result[key] = value return result def nonfinite(value): raise ValueError("Nonfinite JSON number") return json.loads(text, object_pairs_hook=pairs, parse_constant=nonfinite)
def grade(task, text, finish): terminal = finish_grade(finish) if terminal: return terminal if not isinstance(text, str) or not text.strip(): return {"passed": False, "classification": "empty"} try: actual = strict_json(text) except (ValueError, TypeError): return {"passed": False, "classification": "malformed"} types = {"email": str, "order_id": str, "item_count": int, "gift_wrap": bool} schema_ok = (type(actual) is dict and actual.keys() == types.keys() and all(type(actual[key]) is kind for key, kind in types.items())) if not schema_ok: return {"passed": False, "classification": "malformed"} passed = actual == task["expected"] return {"passed": passed, "classification": "pass" if passed else "incorrect"}
接受与拒绝都要测。这些夹具把「合法但值错」与「畸形输出」区分开,并验证被过滤或截断不能算通过。
CORRECT = '{"order_id":"A-104","email":"mira@example.test","gift_wrap":false,"item_count":3}' WRONG = '{"email":"other@example.test","order_id":"A-104","item_count":3,"gift_wrap":false}' MALFORMED = ["not JSON", '``json\n' + CORRECT + '\n``', '{"email":"mira@example.test"}', CORRECT.replace('3}', 'true}'), CORRECT.replace('3}', '3.0}'), CORRECT.replace('3}', 'NaN}'), CORRECT[:-1] + ',"item_count":3}', CORRECT[:-1] + ',"extra":1}']
def offline(): assert EXPECTED == {"email": "mira@example.test", "order_id": "A-104", "item_count": 3, "gift_wrap": False} assert f"Email: {CUSTOMER_EMAIL}." in SOURCE_TEXT assert f"Order: {ORDER_CODE}." in SOURCE_TEXT assert f"Items: {ITEM_COUNT}." in SOURCE_TEXT and "Gift wrap: no." in SOURCE_TEXT task = TASKS[0] assert grade(task, CORRECT, "stop")["passed"] assert grade(task, json.dumps(EXPECTED, indent=2), "stop")["passed"] assert grade(task, WRONG, "stop")["classification"] == "incorrect" for text in MALFORMED: assert grade(task, text, "stop")["classification"] == "malformed", text assert grade(task, "", "stop")["classification"] == "empty" assert grade(task, CORRECT, "content_filter")["classification"] == "content_filtered" assert grade(task, CORRECT, "length")["classification"] == "truncated" print("OFFLINE JSON extraction: independent source facts, schema, correct/wrong/malformed fixtures passed; zero requests.")
if __name__ == "__main__": main(tasks=TASKS, grader=grade, offline_check=offline)
最后那次 main(…) 调用把任务、判分和参考答案检查接到 runner 上。改好源事实和预期字段后,跑:
python json_extraction.py check python json_extraction.py plan --config luna-config.json
预期的 check 输出:
OFFLINE JSON extraction: independent source facts, schema, correct/wrong/malformed fixtures passed; zero requests.
用不同的文件夹。下面这些额度只适用于随包提供的单 case 计划。
python json_extraction.py run --config luna-config.json --run-dir runs/json-luna --live --max-usd 0.01 python json_extraction.py run --config sol-config.json --run-dir runs/json-sol --live --max-usd 0.03 python json_extraction.py reconcile --run-dir runs/json-luna --live python json_extraction.py reconcile --run-dir runs/json-sol --live
开跑前把重复次数设成一致。一个 case 重复三次测的是波动性,不是工作负载覆盖度。要下更宽的结论,先补上代表性的边界与 held-out case。
第 5 步:比较已保存的 runs,并处理缺失的回答
对你已保存的 JSON runs:
python compare_runs.py runs/json-luna runs/json-sol --output comparisons/json
它写出 comparison.md 和 comparison.json,不做推理、也不重新判分。它会校验契约、设置和身份;不兼容的 runs 需要去排查,而不是悄悄排出一个名次。
先离线演练一遍:
python synthetic_comparison.py runs/comparison-demo python compare_runs.py runs/comparison-demo/luna runs/comparison-demo/sol --output comparisons/full
下表给出这些合成夹具值,列名做了缩写:
夹具标签完成/计划通过/已判分被过滤已核验成本/100中位秒数 Luna6/65/61$0.0001000.150 Sol5/65/50unavailable0.155
Sol 的夹具缺一条回答、账单也未经核验。它 5/5 的分数覆盖并不完整。这些数字不衡量任何一个模型。
把不确定的那次试验和它的 reservation 留着。修好访问或限流问题,然后在配置、来源和额度都不变的情况下续跑:
python json_extraction.py run --config luna-config.json --run-dir runs/json-luna --live --max-usd 0.01 --resume
续跑只继续那些从未尝试过的试验。一笔已知账单补不回缺失的文本。若某次请求找不到 generation 记录,报告会把它保持标记为未结。不要丢掉这次 run,也不要删掉尝试记录。README 讲了崩溃后残留锁的处理。
要只比较所有参与方都答过的 case:
python compare_runs.py runs/comparison-demo/luna runs/comparison-demo/sol --common-completed --output comparisons/common
这个显式交集保留原始覆盖度并列出被排除的项。它可能挑中更容易的 case,也修不了缺失的账单。绝不要在不作说明的情况下比较不同的子集。
可选的 60 任务 runner 与 runtime 安装说明在配套包里。它的历史结果提供了一个更大的可跑例子。
在我们的 benchmark 上,哪个模型表现最好?
每个模型把 40 个 baseline 和 20 个 hard 任务各跑三遍,得到 120 个 baseline 和 60 个 hard 判分。这些结果描述的是在固定设置下、于 2026 年 10 月 20 日完成的这 60 个合成任务。AA 指我们那份标了日期的公开快照里的 Artificial Analysis Intelligence Index。
模型与 API IDBaseline %Hard %合计通过成本/100 条回答中位秒数AA index Claude Haiku 5.5 anthropic/claude-haiku-5.590.876.7155/180$0.034343.3743.4 Claude Sonnet 5.5 anthropic/claude-sonnet-5.547.545.084/180$0.472732.3356 GPT-6 Luna openai/gpt-6-luna98.373.3162/180$0.018483.8138.1 GPT-6.1 Sol openai/gpt-6.1-sol100.0100.0180/180$0.244903.5251.8 Gemini 3.8 Flash google/gemini-3.8-flash95.096.7172/180$0.304123.3840.9 DeepSeek V4.1 Flash deepseek/deepseek-v4.1-flash93.375.0157/180$0.003944.6624.7 Grok 4.7 x-ai/grok-4.799.296.7177/180$1.034625.9746.4 MiMo V2.6 Flash xiaomi/mimo-v2.6-flash89.263.3145/180$0.031565.0037.9 Mistral Large 4.0 mistralai/mistral-large-4-090.051.7139/180$0.5894531.4538.4 GLM 5.3 z-ai/glm-5.392.573.3155/180$0.060831.5944.8
「每 100 条回答的成本」是 180 条已判分回答的已核验成本按比例折算到 100 条,不含运营开销与未结账单。中位秒数衡量本地请求耗时。
在这个集合上有三条发现影响选型。
通过率最高。 Sol 通过 180/180,约合每 100 条回答 $0.2449。 回答成本最低。 DeepSeek 约合每 100 条 $0.00394,通过 157/180,含 14 次截断。Luna 以约 $0.01848 通过 162/180。按你要求的通过率和失败后果来选。 输出合规性影响分数。 Sonnet 的 66 条畸形回答涵盖 21 次发票、30 次日期和 15 次退款试验。原始回答里带了说明文字,而 prompt 只要求一个数字或一段 JSON。这个分数衡量的是契约合规性与答案正确性,不是纯粹的推理能力。
每个模型行合计 180。最后一行合计全部 1,800 条回答。各分类记的是失败的检查,不是其底层成因。
模型PassedIncorrectMalformedTruncatedEmpty Haiku15571800 Sonnet84306600 Luna16218000 Sol1800000 Gemini1728000 DeepSeek15709140 Grok1773000 MiMo145813140 Mistral13987251 GLM15518700 Total1526100120531
53 条被截断的回答全部仍算失败。
该研究请求 8,192 token,并在支持时开 low reasoning。有 16 次试验因为先前尝试没返回回答而需要补发请求。其中一次补发同样没返回回答、又得再派发一次,于是为 16 条入选回答总共派发了 17 次补发。没有对任何已返回的回答做重试。配套包保留了每一次尝试。
已核验的研究账单为 $5.1032,另有 $0.5383 作为未结账单的预留。Reader 的计划为 Luna 的 180 次研究试验估算 $0.97、为 Sol 估算 $19.46。路由、日期,以及原始的并发/续跑调度,都限制了与串行 reader runner 之间的可比性。
公开 LLM benchmark 与你自己的 benchmark 比起来如何?
我们在 2026 年 10 月 20 日 10:03 UTC 通过 benchmarks API 取了一份 Artificial Analysis 快照,精确匹配 canonical 模型版本。
Spearman 相关系数比较名次顺序,−1 表示名次完全相反,+1 表示完全一致。跨十个模型:
集合Spearman 相关系数 Baseline0.115 Hard0.183 Combined0.109
在这个样本里一致性很弱。任务与设置不同,使得我们无法对 benchmark 的普遍可靠性下结论。用公开分数做初筛,再评估你自己的工作负载。
每个任务该跑几次?
在 600 个「模型-任务」配对里,有 68 对是模型在部分重复中通过、在另一些重复中失败的。把每一次重复都留着。这些是对 60 个 case 的重复观测,不是每个模型 180 个互异 case。名次接近时,需要更多 held-out case 和更多重复。
常见问题(FAQ)
我需要多少个测试用例?
先从一小批入手,覆盖一条工作流里常见的输入、边界和已知失败。十个仔细评审过的例子足以支撑初步探索,但它们给不出统计保证。当差异很小或失败代价很高时,补上代表性的 held-out case 来扩充。重复用来评估一致性,替代不了覆盖度。
我能用 LLM judge 吗?
可以,用于 tone 或解释质量这类难以精确核验的性质。拿人工标注的例子校验它的 rubric,并检视分歧所在。可计算的答案和必需的 schema 仍用代码检查。我们的 LLM-as-a-judge guide 讲了这条思路。
下一步
用我们的 golden eval dataset guide 从你的应用构建一套有代表性的集合。比较各候选模型,然后在检查上给 pull request 设闸。