BroadRouter

思考模型的 max_tokens 怎么设:一套预算方法

BroadNet Inference 团队 · 阅读约 6 分钟 · 发布于

在思考模型上,max_tokens 同时限制思考和回答,限制太紧时回复可能在出现任何可见文本前就被截断。按任务类型测量总输出 token,把 max_tokens 设为第 95 百分位数再加 20% 左右,保证提示词加 max_tokens 不超过上下文窗口,并对被截断的回复以加倍预算重试,直到硬上限。

思考模型先思考再回答,而在大多数 OpenAI 兼容 API 上,两者共用一个预算:max_tokens。如果像对待非思考模型那样设置,比如为一个简短回答留几百 token,有些回复就会以 finish_reason: "length" 空着返回。快速修复见思考模型为什么返回空答案。本文讲的是一个可信预算背后的方法:测量、按分位数定额、遵守上下文窗口,并处理仍然被截断的回复。

思考要花多少钱、怎样降低,请看思考 token:为什么你付费的输出比看到的多。

为什么预算在答案出来之前就用完了?

模型按顺序生成:先是思考,再是可见的答案。两者的每个 token 都计入 max_tokens。BroadNet 的文档针对 DeepSeek V4.1 Flash、GLM 5.3 和 Qwen3.8 27B 写道:“the reasoning counts toward max_tokens”(译文:思考计入 max_tokens),限制太小时“the answer comes back empty”(译文:答案返回为空)。OpenAI 的 Chat Completions 参考对 max_completion_tokens 的定义也一样,是一个“including visible output tokens and reasoning tokens”(译文:包括可见输出 token 和推理 token)的上限。

所以要问的不是“我的答案有多长?”,而是“在这个任务、这个思考强度下,思考加答案一共多长?”。这个数字的波动比人们想象的大。OpenAI 的指南说,视问题而定,其模型可能生成“anywhere from a few hundred to tens of thousands of reasoning tokens”(译文:从几百到几万个推理 token 不等)。

max_tokens 设得大会更贵吗?

不会。这正是预算被设得过紧的最常见原因。max_tokens 是一个上限,你按实际生成的 token 计费。一条需要 1,800 token 的回复,上限设 4,000 还是 40,000,费用都一样。

过紧的上限真正的代价:

上限与需求 你付的钱 你得到的
上限高于需求 实际生成的 token 答案
上限低于需求 整个上限,全部是思考 没有可用结果,还要重试

举个例子。假设你有四分之一的调用需要超过 1,000 token。设 max_tokens=1000 时,这些调用每次都计费 1,000 个思考输出 token,什么也没返回,还要重试。平摊到所有调用,每次平均多浪费 250 个输出 token,这还没算重试本身,以及第二次请求带来的延迟。把上限设为 4,000,就没有任何浪费。Qwen3.8 27B 的输出价格是每 100 万 token $2.17,量一大,浪费就很可观。

高上限真正的风险是失控的回复:模型陷入循环或过度思考,生成远超所需的内容。硬上限可以兜住这一点。上限要按数据来定,方法如下。

怎样测量一个任务需要多少?

针对一种任务类型,用宽松的上限运行真实提示词,记录输出 token 和思考所占的比例。模型提供时,usage.completion_tokens_details.reasoning_tokens 给出思考部分;BroadNet 的文档列出了这个字段。

import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/qwen3.8-27b"

def measure(prompts, ceiling=16_000, **kw):
    """Run real prompts with a generous ceiling and return per-call token counts."""
    rows = []
    for p in prompts:
        r = client.chat.completions.create(model=MODEL, max_tokens=ceiling,
                                           messages=[{"role": "user", "content": p}], **kw)
        u, d = r.usage, r.usage.completion_tokens_details
        reasoning = (d.reasoning_tokens or 0) if d else 0
        rows.append({"reasoning": reasoning, "answer": u.completion_tokens - reasoning,
                     "finish": r.choices[0].finish_reason})
    return rows

def pct(values, q):
    values = sorted(values)
    return values[min(len(values) - 1, int(q * len(values)))]

def recommend(rows, margin=1.2):
    total = [r["reasoning"] + r["answer"] for r in rows]
    return {"p50": pct(total, 0.5), "p95": pct(total, 0.95), "max": max(total),
            "max_tokens": int(pct(total, 0.95) * margin),
            "cut_off": sum(r["finish"] == "length" for r in rows)}

# print(recommend(measure(my_prompts)))                       # default effort
# print(recommend(measure(my_prompts, reasoning_effort="low")))

想得到一个可信的数字,要遵守这些规则:

  1. 每次只测一种任务类型。 分类、抽取、代码审查和规划的分布差别很大。一个全局的 max_tokens,要么在重试上浪费钱,要么放任失控的回复。
  2. 50 条以上的真实提示词。 十个样本的第 95 百分位数,其实就是最大的那个。
  3. 你用到的每个思考强度都要测。 reasoning_effort="low" 会改变分布。BroadNet 文档写的是 low;其他取值请先测试再依赖。
  4. 如果 cut_off 不为零,提高上限再跑一次。 被截断的样本掩盖了它真实的长度。
  5. 模型或提示词变了就重新测。 新版本的模型可能思考得更多或更少。

然后按 recommend() 的结果为每种任务设置 max_tokens。第 95 百分位数加 20%,能让大多数调用远低于上限,只把少数特别长的回复交给下面的重试路径。拿到数据后,免费的思考 token 预算工具可以在浏览器里帮你算完。

上下文窗口怎样限制预算?

上下文窗口同时容纳提示词和答案。BroadNet 的价格数据把 context_length 定义为“the most tokens one request can hold, prompt and answer together”(译文:一个请求最多能容纳的 token 数,提示词和答案合计)。因此:

max_tokens ≤ 上下文长度 − 提示词 token

模型 上下文 提示词为 200,000 token 时 max_tokens 的可用空间
GLM 5.3 1,048,576 848,576
DeepSeek V4.1 Flash 1,048,576 848,576
Qwen3.8 27B 262,144 62,144

这对长上下文任务很重要。一个在 Qwen3.8 27B 上把历史累积到 250,000 token 的智能体,只剩约 12,000 token 给思考和答案。长上下文任务往往还需要更多思考,所以要在每次调用时检查剩余空间,而不是只在启动时查一次。是否装得下,见上下文窗口和上下文窗口计算器。

回复仍然被截断时怎么办?

每次调用都检查 finish_reason。如果是 length,答案就是缺失或不完整的,即使 content 里有一些文本。不要把它当作完整结果解析;被截断的 JSON 对象是下游出错的常见原因(结构化输出)。

在上下文允许的空间内,以加倍的预算重试,直到硬上限:

import json, urllib.request

FEED = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
CONTEXT = {m["id"]: m.get("context_length") for m in FEED["models"]}

def ask(model, messages, budget=4_000, hard_cap=32_000, **kw):
    """Retry a cut-off reply with a doubled budget, never past the cap or the context window."""
    while True:
        r = client.chat.completions.create(model=model, messages=messages,
                                           max_tokens=budget, **kw)
        if r.choices[0].finish_reason != "length":
            return r
        room = CONTEXT[model] - r.usage.prompt_tokens        # context holds prompt + answer
        nxt = min(budget * 2, hard_cap, room)
        if nxt <= budget:
            raise RuntimeError(f"still cut off at max_tokens={budget}")
        print(f"cut off at {budget}, retrying with {nxt}")
        budget = nxt

视任务而定,加倍之外还有两种办法:

  • 以 reasoning_effort="low" 重试,预算不变。简单任务上模型常常想得过多,降低思考强度不用提高上限就能解决。
  • 拆分任务。 如果某个回复总是撞到很高的上限,通常说明这个请求一次要的东西太多了。

记录每次截断及其任务类型。截断率上升,说明提示词、模型或输入数据变了,预算需要重新测量。重试是新的推理,会再次计费,所以要像长时间运行的智能体:超时与重试中那样限制重试次数。

流式输出会带来什么变化?

使用 stream=True 时,思考发生在第一个可见 token 之前,所以思考模型在开头可能看起来像卡住了。在聊天界面里,内容到来之前显示一个“思考中”状态,客户端超时也要按思考时间来设,而不只是按答案。

有些服务端还会在单独的字段里流式输出思考文本本身。这个字段名并不统一:DeepSeek 自己的 API 用 reasoning_content,vLLM 则把字段从 reasoning_content 改名为 reasoning,并警告旧的客户端代码“could silently read an empty”(译文:可能悄无声息地读到一个空的)字段。BroadNet 的文档没有说明思考文本字段,所以在没检查过你所用模型的原始响应之前,不要基于它开发功能。如果确实要读,请防御性地读取:

for chunk in stream:
    if chunk.choices:
        delta = chunk.choices[0].delta
        thinking = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
        # log or display `thinking` only if your provider actually sends it
        if delta.content:
            print(delta.content, end="")
    elif chunk.usage:                                  # last chunk, with include_usage
        print("\nreasoning tokens:", getattr(chunk.usage.completion_tokens_details, "reasoning_tokens", None))

最后一个数据块里的 usage 需要 stream_options={"include_usage": True},BroadNet 的文档有说明。流式输出的更多内容见流式输出指南和 SSE 详解。

应该发送哪个参数名?

API 参数 是否包含思考
OpenAI Chat Completions max_completion_tokens(max_tokens 已弃用) 是
OpenAI Responses max_output_tokens 是
BroadNet Inference(Chat Completions) max_tokens,按文档说明 是
vLLM 服务端 max_tokens,以及可选的 thinking_token_budget 是

在不同供应商之间迁移代码时,发送该供应商文档里写的参数名,并用一次测试调用确认限制确实生效。一个被悄悄忽略的限制,在失控回复出现之前看起来一切正常。其他会变化的参数见迁移检查清单。

BroadNet Inference 适合什么场景

BroadNet 的三个思考模型在模型提供思考 token 数时,会在 usage 中报告,所以上面的测量方法可以直接使用。DeepSeek V4.1 Flash 和 GLM 5.3 的空间最大,上下文为 1,048,576 token;Qwen3.8 27B 为 262,144。如果某个任务不需要思考,Gemma 4 VL 26B 没有被列为思考模型,可以完全绕开预算问题。在固定价格的 DeepSeek V4.1 Flash 套餐上,思考 token 不按 token 计费,但被截断的回复仍然浪费时间,所以同样的预算方法依然适用。BroadNet 没有说明单独的思考上限;如果你需要,请选择提供该功能的供应商或自托管服务端。

常见问题

为什么我的思考模型返回空回复?

模型在写答案之前,就把整个 max_tokens 预算花在了隐藏的思考上,此时 finish_reason 为 "length"。调高 max_tokens、调低 reasoning_effort,或两者都做。本文附有一篇给出快速修复方法的简短指南。

思考模型的 max_tokens 应该设多少?

先测量。用宽松的上限跑 50 条以上的真实提示词,取该任务 completion_tokens 的第 95 百分位数,再加 20% 左右。BroadNet 文档给出的下限是 1,000 token 或更多;OpenAI 建议刚开始使用其模型时预留 25,000。

max_tokens 设得更高会更贵吗?

本身不会。你按模型生成的 token 计费,而不是按上限。只有当回复原本会被截断时,更高的上限才会多花钱;而那种情况下,被截断的回复本来也要让你多付一次重试。

max_completion_tokens 和 max_tokens 是一回事吗?

在 OpenAI 上,max_completion_tokens 取代了已弃用的 max_tokens,并明确包含推理 token。许多 OpenAI 兼容供应商的文档写的仍是 max_tokens。BroadNet 的文档使用 max_tokens,并说明思考计入其中。

能单独限制思考部分、不限制回答吗?

只有服务端支持时才行。vLLM 有 thinking_token_budget 参数,一些供应商也有自己的参数。BroadNet 文档提供的是把 reasoning_effort 设为 low,而不是单独的思考上限,所以要把两者合在一起做预算。

以 Markdown 格式阅读问 ChatGPT问 Claude问 Perplexity