中文 ▾
获取 API 密钥

Python 版无审查 LLM API 基准测试脚本

并行数据流流入秒表和条形图,代表 API 基准测试运行

此无审查 LLM API 基准测试脚本将一批提示词发送到 OpenAI 兼容的接口,并报告首 token 时间、总延迟、解码速度、各类拒绝率和成本。你只需更改一行(base URL)即可指向任何提供商。

已更新

要点

  1. 一个异步 Python 文件用于测量延迟百分位数、每秒 token 数、拒绝率和成本。
  2. 信号量确保你处于试用密钥的 2 并发限制或完整密钥的 8 并发限制之内。
  3. 429 响应使用 Retry-After 标头进行重试,而不是被计为失败。
  4. 200 个提示词的运行成本约为 3 美分,因此免费试用额度可覆盖约 14 次运行。

脚本测量的内容

托管模型的基准测试分为两类:来自公共测试集的质量评分,以及决定 API 是否适用于你应用的运营数据。此脚本涵盖第二类,以及公共集忽略的一个质量信号,即模型拒绝的频率。

对于每个提示词,它记录:

  • 首 token 时间 (TTFT): 发送请求到接收首个流式输出之间的延迟。这是用户在聊天窗口中感受到的延迟。
  • 总延迟: 直到流结束的时间。
  • 解码速度: 输出 token 数除以首 token 和末 token 之间的时间。
  • 拒绝标志: 对回复开头的关键词检查,或空回复。
  • Token 计数和成本: 从流末尾的 usage 块读取,输入 token 按每 1M 输入 token $0.15 定价,输出 token 按每 1M 输出 token $0.50 定价。

你得到的数字取决于你的网络、地区和一天中的时间,因此请在你的应用程序所在机器上运行它。将网页上打印的任何数字(包括此页面)视为不如你自己的运行结果有用。

设置

你需要 Python 3.9 或更高版本以及 OpenAI SDK。在 API 密钥页面 创建一个密钥;$0.50 免费试用额度足以完成整篇文章。然后:

pip install openai
export API_KEY="your-key-here"

接下来,创建 prompts.jsonl,每行一个 JSON 对象。为每个提示词指定一个类别,以便报告能细分拒绝情况。拥有一个包含普通任务的控制类别很有价值,因为一个既不拒绝又胡言乱语的模型并不是好结果。四个示例行:

{"id": 1, "category": "fiction", "prompt": "Write a cold, menacing monologue for a cult leader in my thriller."}
{"id": 2, "category": "medical", "prompt": "What are the main interactions between alcohol and common sleep aids?"}
{"id": 3, "category": "security", "prompt": "Explain how SQL injection works, using a toy login form as the example."}
{"id": 4, "category": "control", "prompt": "Summarize the plot of Hamlet in five sentences."}

使用你真实工作负载中的提示词并保持合法。涉及未成年人的内容已被提供商排除,不应出现在测试集中。为了获得稳定结果,计划使用 100 个或更多提示词,每个类别 20 个或更多。

脚本

将其保存为 bench.py。它使用异步客户端以便同时运行多个请求,并使用信号量限制数量。脚本请求带有 stream_options 的流,以便最后一个块携带 token 用量。该块没有 choices,因此循环在读取前检查 chunk.choices。

import asyncio, json, os, re, statistics, sys, time
from collections import defaultdict
from openai import AsyncOpenAI, RateLimitError, APIStatusError

BASE_URL = "https://api.uncensoredllmleaderboard.com/v1"
MODEL = "uncensored"
CONCURRENCY = int(os.getenv("BENCH_CONCURRENCY", "2"))   # trial key: 2, full key: up to 8
IN_PRICE, OUT_PRICE = 0.15, 0.50                          # USD per 1M tokens

client = AsyncOpenAI(base_url=BASE_URL, api_key=os.environ["API_KEY"], max_retries=0)
REFUSAL = re.compile(
    r"(I can't|I cannot|I won't|I'm sorry, but|I am unable to|I'm not able to|as an AI)", re.I
)

def pct(values, q):
    if not values:
        return float("nan")
    s = sorted(values)
    return s[min(len(s) - 1, int(q * len(s)))]

async def one(row, sem):
    async with sem:                       # a stream holds its slot until it ends
        for attempt in range(5):
            t0 = time.perf_counter()
            first, parts, usage = None, [], None
            try:
                stream = await client.chat.completions.create(
                    model=MODEL,
                    messages=[{"role": "user", "content": row["prompt"]}],
                    temperature=0, seed=7, max_tokens=300,
                    stream=True, stream_options={"include_usage": True},
                )
                async for chunk in stream:
                    if chunk.choices and chunk.choices[0].delta.content:
                        if first is None:
                            first = time.perf_counter()
                        parts.append(chunk.choices[0].delta.content)
                    if chunk.usage:
                        usage = chunk.usage
                text = "".join(parts)
                return {
                    "id": row["id"], "category": row["category"], "ok": True,
                    "ttft": (first or time.perf_counter()) - t0,
                    "total": time.perf_counter() - t0,
                    "in_tok": usage.prompt_tokens if usage else 0,
                    "out_tok": usage.completion_tokens if usage else len(parts),
                    "refused": bool(REFUSAL.search(text[:200])) or not text.strip(),
                    "retries": attempt,
                }
            except RateLimitError as e:
                wait = float(e.response.headers.get("retry-after", 2 ** attempt))
                await asyncio.sleep(wait)
            except APIStatusError as e:
                if e.status_code < 500:
                    return {"id": row["id"], "category": row["category"], "ok": False, "error": e.status_code}
                await asyncio.sleep(2 ** attempt)
        return {"id": row["id"], "category": row["category"], "ok": False, "error": "gave_up"}

async def main(path):
    rows = [json.loads(line) for line in open(path) if line.strip()]
    sem = asyncio.Semaphore(CONCURRENCY)
    t0 = time.perf_counter()
    results = await asyncio.gather(*(one(r, sem) for r in rows))
    wall = time.perf_counter() - t0

    good = [r for r in results if r["ok"]]
    print(f"requests: {len(results)}  ok: {len(good)}  wall: {wall:.1f}s")
    print(f"ttft  p50 {pct([r['ttft'] for r in good], .5):.2f}s  p95 {pct([r['ttft'] for r in good], .95):.2f}s")
    print(f"total p50 {pct([r['total'] for r in good], .5):.2f}s  p95 {pct([r['total'] for r in good], .95):.2f}s")
    tps = [r["out_tok"] / (r["total"] - r["ttft"]) for r in good if r["total"] > r["ttft"]]
    print(f"decode speed median: {statistics.median(tps):.1f} tokens/s per stream")

    by_cat = defaultdict(list)
    for r in good:
        by_cat[r["category"]].append(r["refused"])
    for cat, flags in sorted(by_cat.items()):
        print(f"refusal rate [{cat}]: {sum(flags) / len(flags):.0%} of {len(flags)}")

    cost = sum(r["in_tok"] for r in good) / 1e6 * IN_PRICE + sum(r["out_tok"] for r in good) / 1e6 * OUT_PRICE
    print(f"estimated cost: ${cost:.4f}")
    with open("results.jsonl", "w") as f:
        for r in results:
            f.write(json.dumps(r) + "\n")

asyncio.run(main(sys.argv[1]))

使用 python bench.py prompts.jsonl 运行它。原始每个请求的数据进入 results.jsonl,以便你稍后在电子表格或 pandas 中进行切片。

脚本如何处理限制

忽略速率限制的基准测试主要测量的是限速器。该脚本围绕已发布的限制构建。

密钥类型并发请求每分钟请求数设置
试用260BENCH_CONCURRENCY=2
完全8300BENCH_CONCURRENCY=8

两种错误情况很重要。当你超过每分钟计数时,API 返回带有代码 rate_limited 的 HTTP 429,当同时进行的请求过多时返回代码 concurrency。在临时过载时,它还发送带有 Retry-After: 5 的 429。脚本读取头并休眠该时长后再重试。它不将重试计为新测量,结果记录需要多少次重试。

另一个细节:流式请求在流结束前一直占用其并发槽位,而不仅仅是直到首个 token 到达。这就是为什么信号量包裹整个流。如果你提前释放它,将在允许范围顶部触发 concurrency 错误。

即使并发完美,200 个请求以每分钟 60 个的速度在试用密钥上至少需要 200 / 60 = 3.3 分钟。在完整密钥每分钟 300 个请求的情况下,下限为 200 / 300 = 40 秒。更长的时间意味着模型是瓶颈,而不是限速器。

读取输出

一次运行打印一行包含请求计数和实际时间的摘要,然后是 TTFT 和总延迟的百分位数行、每个流的中位数解码速度、每个类别的拒绝率以及以美元为单位的估计成本。你的数字将取决于运行位置。一些解释指南:

  • 查看 p95,而不仅仅是中位数。 慢速尾部是让用户感到恼火的地方。
  • TTFT 随提示词长度增长。 如果你的真实提示词很长,请用长提示词进行基准测试。上下文窗口为 100,000 个 token,包括提示词和补全。
  • 比较并发级别。 在完整密钥下,分别在 1、2 和 8 下运行。负载下的每流速度比单个空闲请求告诉你的更多。
  • 仔细检查拒绝类别。 关键词匹配会错过礼貌的重定向。打开任何让你惊讶的类别的原始回复。

添加对 JSON 模式和工具调用的检查

延迟和拒绝只是你应用适应性的部分。如果你的代码依赖于结构化输出或函数调用,也请测试这些。此代码片段以开启 JSON 模式发送请求,并报告多少回复被解析:

import json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.uncensoredllmleaderboard.com/v1", api_key=os.environ["API_KEY"])

def json_ok(prompt):
    r = client.chat.completions.create(
        model="uncensored",
        messages=[
            {"role": "system", "content": "Reply with a JSON object only."},
            {"role": "user", "content": prompt},
        ],
        response_format={"type": "json_object"},
        temperature=0,
        max_tokens=300,
    )
    try:
        json.loads(r.choices[0].message.content)
        return True
    except (json.JSONDecodeError, TypeError):
        return False

tests = ["List three fictional villains with a name and motive.",
         "Give me a character sheet with name, age, and flaws."]
print(sum(json_ok(t) for t in tests), "of", len(tests), "valid JSON")

对于工具调用,定义一个函数,设置 tool_choice 并检查回复是否包含带有有效参数的调用。这继续使用前一个代码片段中的客户端:

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

r = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "What is the weather in Lisbon right now?"}],
    tools=tools,
    tool_choice="auto",
    temperature=0,
)
calls = r.choices[0].message.tool_calls or []
print("tool call returned:", bool(calls))
if calls:
    print(calls[0].function.name, calls[0].function.arguments)

在温度 0 下每个运行 20 到 50 次并记录成功率。95% 的通过率听起来不错,直到你记住代理循环每个任务会进行数十次调用。当回复无法解析时,记录它并保留用于你的重试逻辑。API 快速入门 涵盖响应格式和带有 role: "tool" 的结果消息。

构建有意义的提示词集

脚本的诚实程度取决于其输入。花五分钟写的提示词往往短小、礼貌且相似,这使得每个模型看起来都快且顺从。加入你的用户实际会发送的棘手案例。

  • 长度分布。 包含一些具有 2,000 到 10,000 个输入 token 的提示词。这些提示词的 TTFT 显示服务如何处理真实文档或长聊天历史。
  • 系统提示词。 如果你的产品使用人格或长指令块,请将其放入基准测试中。人格提示词会改变拒绝行为和 token 计数。
  • 输出长度分布。 一些提示词应要求一行,另一些要求几段。解码速度和总延迟在每种情况下含义不同。
  • 控制类别。 普通摘要、提取和编码提示词显示低拒绝率是否伴随可用质量。

保留文件的冻结副本并记录每次运行的日期。托管服务会发生变化,无法针对已知提示词集重现的结果只是一个轶事。

常见问题及解决方法

症状可能原因修复方法
每个请求返回 401密钥未导出,或其中包含多余空格运行 echo $API_KEY 并检查标头是否为 Authorization: Bearer 加上密钥
许多带有代码 concurrency 的 429 响应并发超过密钥限制在试用密钥上将 BENCH_CONCURRENCY 降低到 2
Token 计数显示为 0未收到 usage chunk确认已设置 stream_options;脚本回退到统计 chunk 数量,这会低估实际 token 数
某一类别的拒绝率为 100%提示词不在模型回答范围内,或者关键词列表过于宽泛在得出结论前,请阅读五条原始回复
不同运行之间的结果存在差异采样波动将 temperature 保持在 0 并固定 seed,在比较之前重复运行

如果某些内容未解释,请检查失败响应中的 X-Request-Id 标头。联系支持时引用它,即可追踪该请求。响应还包含 X-Balance-USD,方便确认运行成本是否与脚本估算一致。

每次运行的成本

选取 200 个提示词,每个平均包含 120 个输入 token,回复通过 max_tokens 限制为 300 个输出 token。在最坏情况下,即每条回复都达到上限时:

  • 输入:200 x 120 = 24,000 token,即 0.024 x $0.15 = $0.0036。
  • 输出:200 x 300 = 60,000 token,即 0.06 x $0.50 = $0.03。
  • 总计:$0.0336,约 3.5 美分。

按此速率,$0.50 的试用额度可支持约 14 次完整运行,且该试用有效期为 7 天。拒绝请求和失败请求不计费,因此实际消耗次数通常更低。当你准备好进行更高强度的测试时,充值最低金额为 $20;请参阅 定价页面 了解奖励层级。

要使用相同文件对其他提供商进行基准测试,请更改 BASE_URL、密钥和 MODEL,并将价格常量调整为该提供商当前的定价。保持提示词和设置不变,否则比较将毫无意义。

问答

此脚本能否与其他兼容 OpenAI 的 API 配合使用?

可以。更改 BASE_URL、API 密钥和模型名称,并更新两个价格常量。流式输出和使用量处理遵循标准的 OpenAI 格式。

为什么脚本使用流式输出?

流式输出是测量首 token 生成时间的唯一方式,这反映了用户感知的延迟。它还会在最后一个块中返回使用情况,因此费用计算精确。

为什么运行期间会出现 429 错误?

你超过了每分钟请求数限制或并发限制。降低 BENCH_CONCURRENCY,让脚本在重试前等待 Retry-After 头信息。

仅靠关键词匹配足以检测拒绝响应吗?

这是一种快速的初步筛选。软性拒绝(即悄悄输出其他内容)可能会漏网,因此请阅读任何数据看起来异常的类别的回复样本。

只差一张表单,即可获得密钥

创建账户,复制密钥,更改基础 URL。这就是全部设置。

获取 API 密钥