BroadRouter
Magsimula

LLM batch processing nang walang Batch API: resumable na runner

Ng BroadNet Inference team · 8 minutong basa · Nailathala · Na-update

Kung walang Batch API, ikaw mismo ang magpatakbo ng job: basahin ang mga item mula sa JSONL file, limitahan ang request na in flight sa limit ng key, i-pace ang pagsisimula ng request sa ilalim ng per-minute na limit, i-retry ang 429 at 5xx nang may limitadong backoff, at i-append ang bawat resulta kasama ang ID. Pag-restart, laktawan ang mga tapos na. Kadalasang ang rate limit, hindi ang model, ang nagtatakda kung kailan ito matatapos.

Hindi chat ang ilang LLM job. May 50,000 support ticket kang lalagyan ng label, 200,000 product description na isasalin, o isang milyong review na bibigyan ng score. Nagbebenta ang mga provider gaya ng OpenAI at Anthropic ng Batch API para dito. Wala nito ang maraming OpenAI-compatible na API, kasama ang BroadNet Inference. Ipinapakita ng post na ito kung paano ikaw mismo ang magpapatakbo ng job: kuwentahin kung gaano ito katagal, sumulat ng runner na sumusunod sa mga limit, at gawin itong ligtas ihinto at i-restart.

Sariling site ng BroadNet ang BroadRouter, kaya ang mga halimbawang numero ay gumagamit ng mga limit na inilathala ng BroadNet. Gumagana ang pamamaraan sa anumang chat-completions API; ipalit ang mga numero ng provider mo.

May Batch API ba ang BroadNet Inference?

Wala. Ang API reference, na sinuri noong Nobyembre 15, 2026, ay nagdo-dokumento ng POST /v1/chat/completions, POST /v1/audio/transcriptions at GET /v1/models (listahan ng model), pati mga account endpoint sa ilalim ng /portal/. Walang batch o file-upload endpoint at walang batch discount. Loop ng normal na request ang bulk job.

Ito ang ibinibigay ng hosted na Batch API, para alam mo kung ano ang binubuo mo ulit:

Batch API ng OpenAI Message Batches ng Anthropic Sarili mong runner
Presyo 50% na mas mura kaysa synchronous 50% na mas mura Normal na presyo
Turnaround Sa loob ng 24 oras Karamihan sa loob ng 1 oras; nag-e-expire pagkalipas ng 24 Itinatakda ng rate limit mo
Laki kada batch 50,000 request o 200 MB 100,000 request o 256 MB Kahit anong laki
Rate limit Hiwalay sa per-model na limit Naaangkop sa naka-queue na request Mga limit ng key mo
Ayos ng resulta Puwedeng iba; itugma sa custom_id Itugma sa custom_id Ikaw ang nagki-key ng resulta sa ID

Dalawang aral ang dala nito. Pinapalagyan ka ng parehong provider ng ID sa bawat request, dahil hindi bumabalik nang maayos ang pagkakasunod-sunod ng resulta. Walang nangangakong sasagot sa loob ng ilang segundo. Ganoon din dapat gumana ang runner mo: may ID ang lahat, at oras ang sukatan ng plano.

Kung mas mahalaga ang 50% na discount kaysa sa turnaround, at nandoon ang mga model na kailangan mo, baka mas mura ang hosted na Batch API. Presyuhan ang dalawa gamit ang LLM API cost calculator bago ka mag-build.

Gaano katagal ang job?

Kuwentahin ito bago ka magsulat ng code. Dalawang limit ang naglilimita sa throughput, at ang mas mabagal ang nananaig:

  • In-flight limit ÷ latency. Kung 4 na request ang in flight at 2 segundo kada request, 2 kada segundo ang matatapos mo.
  • Request kada minuto. Sa 30 kada minuto, 0.5 kada segundo ang masisimulan mo, gaano man kabilis ang model.

Pinapayagan ng pay-as-you-go key ng BroadNet ang 4 request na in flight at 30 kada minuto. Sa mga value sa API reference noong sinuri namin (30 kada minuto at 4 in flight, 2026-11-15), ang rate limit ang nananaig maliban kung lumampas sa 8 segundo ang bawat request, at 30 kada minuto ang ginagamit ng table sa ibaba:

Item Isang item kada request 20 item kada request
10,000 5.6 oras 17 minuto
100,000 2.3 araw 2.8 oras
1,000,000 23 araw 28 oras

Sa 30 request kada minuto, 1,800 request kada oras ang kaya ng isang key, o 43,200 kada araw. Kasama rin ang retry: gumagamit ng slot ang bawat 429 na natatamaan mo.

Ang pangalawang column ang pinakamalaking lever. Ang maiikling item, gaya ng review o subject ng ticket, ay puwedeng 10 hanggang 50 kada request bilang numbered list, na may JSON array na bumabalik. Suriin na may isang entry ang array kada input at dala ng bawat isa ang numero nito. Ipinapakita ng post tungkol sa Arabic text classification ang pattern. Hindi napagsasama ang mahahabang item: kailangan pa ring kumasya ng bawat request sa context window ng model, at puwedeng bumaba ang kalidad habang humahaba ang listahan. Subukan ang pagsasama sa 200 item bago ka magtiwala rito.

Huwag hatiin ang isang job sa ilang key para lampasan ang per-key na limit nang hindi nagtatanong. Ipinagbabawal ng Acceptable Use Policy ng BroadNet ang paglusot sa rate, concurrency o budget limit. Kung kailangan mo ng higit pa, tanungin ang BroadNet, o gumamit ng plan session, sa ibaba. Ginagawa ng batch job planner ang kuwentang ito para sa bilang ng item, latency at limit mo.

Ano ang itsura ng resumable na runner?

Binabasa ng runner na ito ang items.jsonl (isang {"id", "text"} na object kada linya) at nag-a-append ng isang result line kada item sa results.jsonl. OpenAI Python SDK lang ang kailangan nito.

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]))

Patakbuhin ito gamit ang python batch_run.py items.jsonl results.jsonl. Sinubukan namin ang eksaktong file na ito sa isang lokal na mock server na nagbabalik ng random na 429 (8%) at 500 (5%) at tumatanggi sa anumang lampas sa 4 in flight o 30 simula kada minuto. Natapos ang 25 item sa 55 segundo sa 28 request (3 retry), at hindi kailanman lumampas sa 30 simula sa anumang 60-segundong window. Nang itaas sa 300 kada minuto ang limit ng mock para makatipid ng oras, ang 120-item na run na pinatay pagkalipas ng 10 segundo ay nag-resume mula sa 39 na naka-save na resulta at natapos na may 120 natatanging ID at walang duplicate.

Bakit worker pool at hindi asyncio.gather?

Gumagamit ang gabay sa 429 ng semaphore sa paligid ng asyncio.gather. Ayos iyon para sa ilang daang call. Para sa malaking job, mas mabuti ang fixed na pool ng worker na kumukuha mula sa queue:

  • Memory. Gumagawa ang gather ng isang task kada item sa simula pa lang. Ang mga item na in flight lang ang hawak ng pool.
  • Ang concurrency ay ang laki ng pool. Hindi kailanman magkakaroon ng limang bukas na request ang apat na worker.
  • Dumadaloy sa disk ang mga resulta habang natatapos, kahit anong ayos, naka-key sa ID.

Ang Pacer ang humahawak sa pangalawang limit. Pinipigilan ka ng semaphore nang mag-isa na lumampas sa 4 in flight, pero kung isang segundo ang bawat request, 240 kada minuto ang sisimulan ng apat na worker at matatamaan ng 429 ang karamihan. Pinaghihiwalay ng pacer ang mga simula nang 2 segundo, sa lahat ng worker, kasama ang retry.

Paano nananatiling ligtas ang retry?

I-retry lang ang puwedeng magtagumpay sa pangalawang subok:

Response Gagawin
429 Mag-back off at i-retry; sinasabi ng docs ng BroadNet na “use response details and bounded backoff” (salin: gamitin ang mga detalye ng response at limitadong backoff)
500, 502, 503, 504, timeout, naputol na koneksyon I-retry nang may limitadong exponential backoff
400, 422 Ayusin ang request; parehong error ang ibabalik ng retry
401, 402, 403 Ihinto ang job; may kailangang ayusin sa key, balance o policy
413 Paikliin ang item

Pinapatay ng runner ang sariling retry ng SDK (max_retries=0) para iisa lang ang retry policy, na may nakikitang cap. Exponential ang backoff na may full jitter, naka-cap sa 60 segundo, para hindi sabay-sabay mag-retry ang mga worker na sabay-sabay pumalya. Pagkatapos ng anim na subok, isinusulat ang item bilang "ok": false at nagpapatuloy ang job. Hindi kailanman mapapahinto ng isang masamang item ang isang milyon.

Walang side effect ang model call, kaya at-least-once ang delivery dito: kung mamatay ang process sa gitna ng request, ipapadala ulit ang item na iyon pag-restart, at dalawang beses mo itong babayaran. Iyon lang ang nasasayang. Kung nagsusulat din ang job sa ibang system, gaya ng ticket o email, gawing idempotent ang pagsusulat na iyon ayon sa item ID at gawin ito sa hiwalay na pass sa results.jsonl. Malalim na tinatalakay ng post tungkol sa long-running agent ang idempotent na side effect.

Paano gumagana ang checkpointing?

Ang output file ang checkpoint. Isang na-flush na linya ang bawat natapos na item, kaya pagkatapos ng crash, deploy o Ctrl-C, binabasa ng susunod na run ang file, kinokolekta ang mga ID na may "ok": true at ang iba lang ang inilalagay sa queue. Ire-retry sa susunod na run ang mga item na pumalya dati, at ia-append ang bago nilang linya. Kapag binabasa mo ang mga resulta, kunin ang huling linya kada ID.

Tatlong gawi ang nagpapatibay nito sa loob ng ilang araw:

  1. Stable na ID. Gumamit ng database key o hash ng input, hindi kailanman ng line number na nauusog kapag nagbago ang input file.
  2. Suriin ang finish_reason. Ang reply na naputol sa max_tokens ay "ok": true pero walang silbi. Nagre-reason muna ang DeepSeek V4.1 Flash, GLM 5.3 at Qwen3.8 27B bago sumagot, at kasama ang reasoning sa max_tokens. Itinatakda ng runner ang reasoning_effort="low", na naka-dokumento sa BroadNet, at nag-iiwan ng 1,500 token.
  3. I-log ang usage kada linya. Kapag pinagsama ang usage mula sa results.jsonl, makukuha mo ang totoong token bill na maihahambing sa tantiya mo.

Magkano ang gastos: pay-as-you-go o plan session?

Sa pay-as-you-go, token ang gastos. Halimbawa, 100,000 review, 150-token na system prompt, 150-token na review at 100 output token na may mababang reasoning. 30 milyong input at 10 milyong output token iyan. Sa DeepSeek V4.1 Flash, ang gastos ay 30 × $0.175 + 10 × $0.52. Panatilihing nauuna at byte-identical ang system prompt, at puwedeng masingil ang 15 milyong token nito sa cached input na rate na $0.0055 kada 1M kung saan tumatama ang cache. Ipinapakita ng mga usage line mo kung gaano kadalas ito nangyari.

Sa plan, libre ang token at oras ang gastos. Ang DeepSeek V4.1 Flash plan session ay “runs one request at a time” (salin: isang request sa isang pagkakataon ang tinatakbo), kaya itakda ang IN_FLIGHT=1 kada session. Ang throughput kada session ay 86,400 ÷ segundo kada item, kada araw. Sinasabi ng BroadNet na mga 100 token bawat segundo ang karaniwang bilis, pero nakadepende ang latency mo sa haba ng prompt at sa reasoning, kaya sukatin ito sa 50 item. Kung 3 segundo kada item ang nasukat mo, 28,800 kada araw ang kaya ng isang session:

Job Session Oras sa 3 s/item Plan
100,000 item 1 Mga 3.5 araw Isang Orbit week, $15 kada session
100,000 item 4 Mga 21 oras Apat na Orbit week, isa kada session; o mga 21 Meteor hour kada session sa $1 bawat isa
1,000,000 item 6 Mga 6 na araw Anim na Orbit week

Ibinibigay ang mga plan nang “best effort under fair use” (salin: best effort sa ilalim ng fair use), at hindi naglalathala ang BroadNet ng per-minute na request limit para sa plan key; ipinapakita ng account mo ang mga limit na naaangkop. Itakda ang RPM mula sa mga iyon, hindi sa hula. Ipinapaliwanag ng gabay sa session planner kung paano hatiin ang mga session sa mga key.

Saan pumapasok ang BroadNet Inference

Walang Batch API ang BroadNet Inference, kaya bagay ito sa bulk job kapag mas gusto mong ikaw mismo ang kumontrol sa runner at magbayad ng normal na per-token na presyo, o i-fix ang gastos gamit ang DeepSeek V4.1 Flash plan session. Para sa maliliit na job na may budget, tumatakbo sa $5 na panimulang credit ang Gemma 4 VL 26B sa $0.10 input at $0.22 output kada 1M. Hindi itinatago ang mga prompt at output pagkatapos ng bawat request. Kung puwedeng maghintay ng isang araw ang job mo at nasa provider na may 50% na batch discount ang mga model na kailangan mo, baka mas mura iyon; maghambing bago mag-commit. Nasa inference.broadnet.ai/plans ang mga plan at limit.

Mga tanong

May Batch API ba ang BroadNet Inference?

Wala. Ang API reference nito, na sinuri noong Nobyembre 15, 2026, ay nagdo-dokumento ng POST /v1/chat/completions, POST /v1/audio/transcriptions at GET /v1/models, na walang batch o file-upload endpoint at walang batch discount. Patakbuhin ang bulk job bilang ordinaryong request sa loob ng limit ng key mo.

Paano ko ipoproseso ang 100,000 prompt gamit ang LLM API?

Ilagay ang mga item sa JSONL file na may ID ang bawat isa. Magpatakbo ng fixed na bilang ng worker na katumbas ng in-flight limit ng key, i-pace ang pagsisimula ng request sa ilalim ng per-minute na limit, i-retry ang 429 at 5xx nang may limitadong backoff, at i-append ang bawat resulta sa output file na naka-key sa ID para maipagpatuloy ang job.

Gaano katagal ang batch na may isang milyong request?

Hatiin ang mga item sa totoong rate mo. Sa 30 request kada minuto at isang item kada request, 43,200 kada araw ang kaya ng isang key, kaya mga 23 araw ang isang milyon. Kapag pinagsama ang 20 maikling item kada request, nagiging mga 28 oras ito, kung kaya ng model nang maayos ang mas mahabang prompt.

asyncio.gather ba o worker pool ang dapat kong gamitin sa batch na LLM call?

Para sa sampu-sampung libong item, gumamit ng fixed na pool ng worker na kumukuha mula sa queue. Gumagana ang gather na may semaphore sa maliliit na job, pero ginagawa nito ang bawat task sa simula pa lang at pinapahirap ang pag-resume at pag-track ng progress.

Puwede ba akong gumamit ng ilang API key para bumilis?

Magtanong muna. Ipinagbabawal ng Acceptable Use Policy ng BroadNet ang paglusot sa rate o concurrency limit, kaya tanungin ang BroadNet bago mo hatiin ang isang job sa ilang key para lampasan ang per-key na limit. Ang pagsasama ng mas maraming item kada request at ang mga plan session ang naka-dokumentong paraan para dagdagan ang throughput.

Maganda ba ang flat na plan para sa batch job?

Puwede, para sa DeepSeek V4.1 Flash. Isang request sa isang pagkakataon ang tinatakbo ng session nang walang token meter, kaya fixed ang gastos at oras ang tanong. Sukatin ang segundo kada item, saka bumili ng sapat na session para matapos sa loob ng period.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity