BroadRouter
开始使用

没有 Batch API 也能批量调用大模型:可断点续跑的执行器

BroadNet Inference 团队 · 阅读约 8 分钟 · 发布于 · 更新于

没有 Batch API 时,就自己跑任务:从 JSONL 文件读取条目,把同时进行的请求数限制在密钥的并发上限内,按每分钟限额控制请求的发起节奏,对 429 和 5xx 做有上限的退避重试,并把每条结果连同 ID 追加写入文件。重启时跳过已完成的 ID。决定完成时间的通常是速率限制,而不是模型。

有些大模型任务不是聊天。你有 5 万张客服工单要打标签,20 万条商品描述要翻译,或者一百万条评论要打分。OpenAI 和 Anthropic 等服务商为此提供了 Batch API。很多 OpenAI 兼容 API 没有,BroadNet Inference 就是其中之一。本文介绍如何自己跑这类任务:估算需要多长时间,写一个遵守限制的执行器,并让它可以安全地停止和重启。

BroadRouter 是 BroadNet 自己的网站,所以示例中的数字使用 BroadNet 公布的限制。这个方法适用于任何 chat completions API;换成你的服务商的数字即可。

BroadNet Inference 有 Batch API 吗?

没有。截至 2026 年 11 月 15 日,API 参考列出了 POST /v1/chat/completions、POST /v1/audio/transcriptions 和 GET /v1/models(模型列表),以及 /portal/ 下的账户接口。没有批量或文件上传接口,也没有批量折扣。批量任务就是一个循环发送普通请求的过程。

下面是托管 Batch API 提供的东西,这样你就知道自己要重建什么:

OpenAI Batch API Anthropic Message Batches 你自己的执行器
价格 同步价格的 5 折 5 折 正常价格
完成时间 24 小时内 大多数 1 小时内;24 小时后过期 取决于你的速率限制
每批大小 50,000 个请求或 200 MB 100,000 个请求或 256 MB 任意大小
速率限制 与各模型的限制分开 适用于排队中的请求 你的密钥的限制
结果顺序 可能不同;按 custom_id 匹配 按 custom_id 匹配 你按 ID 存放结果

有两点经验可以照搬。两家服务商都要求你给每个请求打上 ID,因为结果不会按顺序返回。两家都不承诺几秒内给出答案。你的执行器也应该这样:所有东西都带 ID,计划以小时为单位。

如果 50% 的折扣比完成时间更重要,而且你需要的模型那里也有,托管的 Batch API 可能更便宜。动手之前,用 LLM API 成本计算器把两种方案都算一下。

任务要跑多久?

写代码之前先算清楚。有两个限制会卡住吞吐量,以较慢的那个为准:

  • 并发上限 ÷ 延迟。 同时 4 个请求、每个请求 2 秒,你每秒能完成 2 个。
  • 每分钟请求数。 每分钟 30 个,你每秒只能发起 0.5 个,无论模型有多快。

BroadNet 的按量付费密钥允许同时 4 个请求、每分钟 30 个。按我们查看时 API 参考中的数值(每分钟 30 个、同时 4 个,2026-11-15),除非每个请求超过 8 秒,否则起作用的是速率限制。下表按每分钟 30 个计算:

条目数 每个请求一条 每个请求 20 条
10,000 5.6 小时 17 分钟
100,000 2.3 天 2.8 小时
1,000,000 23 天 28 小时

每分钟 30 个请求,一个密钥每小时能发 1,800 个请求,每天 43,200 个。重试也要算进去:你触发的每个 429 都会占掉一个名额。

第二列是最大的杠杆。短条目,比如评论或工单标题,可以每个请求放 10 到 50 条,以编号列表发送,返回一个 JSON 数组。检查数组是否每个输入都有一项,且每项都带着自己的编号。阿拉伯语文本分类一文展示了这种写法。长条目没法打包:每个请求仍然要放得进模型的上下文窗口,而且列表越长质量可能越差。信任打包之前,先用 200 条测试一下。

不要未经询问就把一个任务分散到多个密钥上,以突破单密钥限制。BroadNet 的可接受使用政策禁止规避速率、并发或预算限制。如果你需要更多,请询问 BroadNet,或者使用下文介绍的套餐会话。批量任务规划器会根据你的条目数、延迟和限制来做这笔算术。

可断点续跑的执行器长什么样?

这个执行器读取 items.jsonl(每行一个 {"id", "text"} 对象),并为每个条目向 results.jsonl 追加一行结果。它只需要 OpenAI Python SDK。

import asyncio, json, os, random, time
from openai import AsyncOpenAI, APIStatusError, APIConnectionError, APITimeoutError

client = AsyncOpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                     api_key=os.environ["BROADNET_API_KEY"],
                     max_retries=0,        # we retry ourselves, with a cap we can see
                     timeout=120)
MODEL = os.environ.get("MODEL", "broadnet/deepseek-v4.1-flash")
IN_FLIGHT = int(os.environ.get("IN_FLIGHT", "4"))     # PAYG key: 4 in flight. Plan: 1 per session.
RPM = int(os.environ.get("RPM", "30"))                # PAYG key: 30 requests a minute
MAX_ATTEMPTS = 6

class Pacer:
    """Spaces request starts at least 60/RPM seconds apart, across all workers."""
    def __init__(self, rpm):
        self.gap, self.next, self.lock = 60 / rpm, 0.0, asyncio.Lock()
    async def wait(self):
        async with self.lock:
            now = time.monotonic()
            delay = max(0.0, self.next - now)
            self.next = max(now, self.next) + self.gap
        await asyncio.sleep(delay)

def retryable(e):
    if isinstance(e, (APIConnectionError, APITimeoutError)):
        return True
    return isinstance(e, APIStatusError) and e.status_code in (429, 500, 502, 503, 504)

async def call(item, pacer):
    for attempt in range(MAX_ATTEMPTS):
        await pacer.wait()                          # every attempt counts against the rate limit
        try:
            r = await client.chat.completions.create(
                model=MODEL, max_tokens=1500, reasoning_effort="low",
                messages=[{"role": "system", "content": "Classify the review as positive, negative or mixed. Reply with one word."},
                          {"role": "user", "content": item["text"]}])
            c = r.choices[0]
            return {"id": item["id"], "ok": True, "finish_reason": c.finish_reason,
                    "output": c.message.content, "usage": r.usage.model_dump() if r.usage else None}
        except Exception as e:
            if not retryable(e) or attempt == MAX_ATTEMPTS - 1:
                return {"id": item["id"], "ok": False, "error": repr(e)[:300]}
            await asyncio.sleep(random.uniform(0, min(60, 2 ** attempt)))   # full jitter, capped

async def run(in_path, out_path):
    done = set()
    if os.path.exists(out_path):                    # resume: skip ids that already succeeded
        with open(out_path) as f:
            done = {json.loads(l)["id"] for l in f if l.strip() and json.loads(l).get("ok")}
    todo = [it for it in map(json.loads, open(in_path)) if it["id"] not in done]
    print(f"{len(done)} done, {len(todo)} to go")
    pacer, queue = Pacer(RPM), asyncio.Queue()
    for it in todo:
        queue.put_nowait(it)
    with open(out_path, "a") as out:
        async def worker():
            while True:
                try:
                    it = queue.get_nowait()
                except asyncio.QueueEmpty:
                    return
                res = await call(it, pacer)
                out.write(json.dumps(res, ensure_ascii=False) + "\n")
                out.flush()                         # one line per finished item = the checkpoint
        await asyncio.gather(*(worker() for _ in range(IN_FLIGHT)))

if __name__ == "__main__":
    import sys
    asyncio.run(run(sys.argv[1], sys.argv[2]))

用 python batch_run.py items.jsonl results.jsonl 运行。我们用这个文件原样测试过一个本地模拟服务器,它会随机返回 429(8%)和 500(5%),并拒绝任何超过同时 4 个或每分钟 30 次发起的请求。25 个条目在 55 秒内完成,共 28 个请求(3 次重试),任何 60 秒窗口内的发起次数都没有超过 30 次。为节省时间把模拟服务器的限制提高到每分钟 300 次后,一个 120 条的任务在 10 秒后被强行终止,重启时从已保存的 39 条结果继续,最终得到 120 个不重复的 ID,没有重复项。

为什么用 worker 池,而不是 asyncio.gather?

429 指南在 asyncio.gather 外面套了一个信号量。几百次调用这样做没问题。对于大任务,固定数量的 worker 从队列中取任务更好:

  • 内存。 gather 一开始就为每个条目创建一个任务。worker 池只持有正在进行的条目。
  • 并发数就是池的大小。 四个 worker 永远不可能同时打开五个请求。
  • 结果随完成随写入磁盘,顺序不限,以 ID 为键。

Pacer 负责第二个限制。单靠信号量只能保证同时不超过 4 个,但如果每个请求只要一秒,四个 worker 每分钟会发起 240 个请求,其中大部分都会碰到 429。pacer 让所有 worker 的请求发起间隔至少 2 秒,重试也算在内。

重试怎样才安全?

只重试那些第二次有可能成功的请求:

响应 处理方式
429 退避后重试;BroadNet 的文档写道 “use response details and bounded backoff”(译文:利用响应详情并使用有上限的退避)
500、502、503、504、超时、连接中断 用有上限的指数退避重试
400、422 修正请求;重试只会得到同样的错误
401、402、403 停止任务;密钥、余额或策略需要处理
413 缩短条目

执行器关闭了 SDK 自带的重试(max_retries=0),这样就只有一套重试策略,上限也一目了然。退避采用指数退避加完全随机抖动,上限 60 秒,这样一起失败的 worker 不会一起重试。尝试六次后,该条目会被写成 "ok": false,任务继续往下走。一个坏条目永远不会让一百万条停下来。

模型调用没有副作用,所以这里的投递语义是“至少一次”:如果进程在请求中途挂掉,重启后这个条目会被再次发送,你会为它付两次钱。这是唯一的浪费。如果任务还要写入别的系统,比如工单或邮件,就按条目 ID 让这次写入幂等,并在单独一轮中遍历 results.jsonl 来完成。长时间运行智能体一文深入介绍了幂等的副作用。

检查点是怎么工作的?

输出文件就是检查点。每个完成的条目是一行已 flush 的内容,所以在崩溃、部署或按下 Ctrl-C 之后,下一次运行会读取这个文件,收集 "ok": true 的 ID,只把剩下的放进队列。之前失败的条目会在下一次运行时重试,新的结果行会被追加进去。读取结果时,每个 ID 取最后一行。

让它连续数天都稳得住,靠的是三个习惯:

  1. 稳定的 ID。 使用数据库主键或输入内容的哈希,绝不使用输入文件一变就会移位的行号。
  2. 检查 finish_reason。 在 max_tokens 处被截断的回复是 "ok": true,但毫无用处。DeepSeek V4.1 Flash、GLM 5.3 和 Qwen3.8 27B 都会先思考再回答,而思考内容计入 max_tokens。执行器设置了 BroadNet 文档中提供的 reasoning_effort="low",并留出 1,500 个 token。
  3. 每一行都记录用量。 把 results.jsonl 中的 usage 加总,就得到真实的 token 账单,可以和你的估算对比。

成本多少:按量付费还是套餐会话?

按量付费时,成本就是 token。以 10 万条评论为例:系统提示词 150 token,每条评论 150 token,低思考强度下输出 100 token。合计 3,000 万输入 token 和 1,000 万输出 token。在 DeepSeek V4.1 Flash 上,费用是 30 × $0.175 + 10 × $0.52。把系统提示词放在最前面并保持逐字节一致,在命中缓存的地方,其中的 1,500 万 token 可以按缓存输入价格计费,即每 1M $0.0055。你的 usage 行会显示实际命中了多少。

用套餐时,token 免费,成本是时间。DeepSeek V4.1 Flash 的套餐会话 “runs one request at a time”(译文:一次运行一个请求),所以每个会话设置 IN_FLIGHT=1。每个会话每天的吞吐量是 86,400 ÷ 每条秒数。BroadNet 给出的典型速度是 约每秒 100 个 token,但你的延迟取决于提示词长度和思考量,所以用 50 条实测一下。如果实测每条 3 秒,一个会话每天能处理 28,800 条:

任务 会话数 每条 3 秒时的耗时 套餐
100,000 条 1 约 3.5 天 一个 Orbit 周套餐,每个会话 $15
100,000 条 4 约 21 小时 四个 Orbit 周套餐,每个会话一个;或每个会话约 21 个 Meteor 小时,每小时 $1
1,000,000 条 6 约 6 天 六个 Orbit 周套餐

套餐以 “best effort under fair use”(译文:在合理使用前提下尽力提供)的方式交付,BroadNet 没有公布套餐密钥的每分钟请求上限;你的账户里会显示适用的限制。RPM 要按这些限制设置,不要靠猜。会话规划指南解释了如何把会话分配到不同的密钥上。

BroadNet Inference 处在什么位置

BroadNet Inference 没有 Batch API,所以当你宁愿自己掌控执行器、按正常的每 token 价格付费,或者想用 DeepSeek V4.1 Flash 套餐会话把成本固定下来时,它适合跑批量任务。对于预算有限的小任务,Gemma 4 VL 26B 每 1M 输入 $0.10、输出 $0.22,可以使用 $5 初始额度运行。每个请求结束后,提示词和输出都不会被保留。如果你的任务能等一天,而你需要的模型在某家有 50% 批量折扣的服务商那里,那里可能更便宜;投入之前先比较一下。套餐和限制见 inference.broadnet.ai/plans。

常见问题

BroadNet Inference 有 Batch API 吗?

没有。截至 2026 年 11 月 15 日,它的 API 参考只列出 POST /v1/chat/completions、POST /v1/audio/transcriptions 和 GET /v1/models,没有批量或文件上传接口,也没有批量折扣。批量任务请在密钥的限制内以普通请求运行。

怎么用大模型 API 处理 10 万条提示词?

把条目放进 JSONL 文件,每条带一个 ID。运行固定数量的 worker,数量等于密钥的并发上限;按每分钟限额控制请求发起节奏;对 429 和 5xx 做有上限的退避重试;把每条结果按 ID 追加写入输出文件,这样任务可以续跑。

一百万个请求的批量任务要跑多久?

用条目数除以你的实际速率。每分钟 30 个请求、每个请求一条时,一个密钥每天能处理 43,200 条,一百万条约需 23 天。每个请求打包 20 条短条目,可以缩短到约 28 小时,前提是模型能处理好更长的提示词。

批量调用大模型,该用 asyncio.gather 还是 worker 池?

几万条以上,用固定数量的 worker 从队列中取任务。gather 加信号量适合小任务,但它会一开始就创建所有任务,让续跑和进度跟踪更难。

能用多个 API 密钥来加速吗?

先确认。BroadNet 的可接受使用政策禁止规避速率或并发限制,所以在把一个任务拆到多个密钥上以突破单密钥限制之前,请先询问 BroadNet。每个请求打包更多条目和使用套餐会话,是有文档说明的提高吞吐量的方式。

固定价格套餐适合跑批量任务吗?

对 DeepSeek V4.1 Flash 来说可以。一个会话一次运行一个请求且不计 token,所以成本是固定的,问题在于时间。先测出每条的秒数,再买足够的会话,在套餐周期内跑完。

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