BroadRouter
शुरू करें

Batch API के बिना LLM बैच प्रोसेसिंग: दोबारा शुरू होने वाला runner

BroadNet Inference टीम · 8 मिनट में पढ़ें · प्रकाशित · अपडेट किया गया

Batch API न हो, तो job ख़ुद चलाएँ: JSONL फ़ाइल से आइटम पढ़ें, एक साथ चलने वाले अनुरोध key की सीमा पर रोकें, अनुरोधों की शुरुआत प्रति मिनट सीमा के भीतर रखें, 429 और 5xx को सीमित backoff के साथ retry करें, और हर नतीजा उसकी ID के साथ जोड़ते जाएँ। दोबारा शुरू करने पर पूरे हो चुके ID छोड़ दें। ख़त्म होने का समय आम तौर पर मॉडल नहीं, रेट लिमिट तय करती है।

कुछ LLM jobs चैट नहीं होते। आपके पास लेबल करने के लिए 50,000 सपोर्ट टिकट हैं, अनुवाद करने के लिए 200,000 प्रोडक्ट विवरण, या स्कोर करने के लिए दस लाख रिव्यू। OpenAI और Anthropic जैसे प्रोवाइडर इसके लिए Batch API बेचते हैं। कई OpenAI-compatible API, जिनमें BroadNet Inference भी है, ऐसा नहीं करते। यह पोस्ट दिखाती है कि job ख़ुद कैसे चलाएँ: अंदाज़ा लगाएँ कि कितना समय लगेगा, सीमाओं का पालन करने वाला runner लिखें, और उसे रोकने और दोबारा शुरू करने लायक सुरक्षित बनाएँ।

BroadRouter, BroadNet की अपनी साइट है, इसलिए उदाहरण के आँकड़े BroadNet की प्रकाशित सीमाओं पर हैं। यह तरीक़ा किसी भी chat-completions API पर चलता है; अपने प्रोवाइडर के आँकड़े डालें।

क्या BroadNet Inference में Batch API है?

नहीं। 15 नवंबर 2026 को जाँचा गया API रेफ़रंस POST /v1/chat/completions, POST /v1/audio/transcriptions और GET /v1/models (मॉडल लिस्ट) दस्तावेज़ित करता है, साथ में /portal/ के तहत अकाउंट endpoint। कोई बैच या फ़ाइल-अपलोड endpoint नहीं है और कोई बैच छूट नहीं। बड़ा job सामान्य अनुरोधों का एक लूप है।

होस्टेड Batch API आपको क्या देता है, यह रहा, ताकि पता रहे कि आप क्या दोबारा बना रहे हैं:

OpenAI Batch API Anthropic Message Batches आपका अपना runner
कीमत synchronous से 50% कम 50% कम सामान्य कीमत
लौटने का समय 24 घंटे के भीतर ज़्यादातर 1 घंटे के भीतर; 24 के बाद समाप्त आपकी रेट लिमिट से तय
प्रति बैच आकार 50,000 अनुरोध या 200 MB 100,000 अनुरोध या 256 MB कोई भी आकार
रेट लिमिट प्रति-मॉडल सीमाओं से अलग queue में रखे अनुरोधों पर लागू आपकी key की सीमाएँ
नतीजों का क्रम अलग हो सकता है; custom_id से मिलाएँ custom_id से मिलाएँ आप नतीजे ID से जोड़ते हैं

दो सबक़ यहाँ भी लागू होते हैं। दोनों प्रोवाइडर हर अनुरोध पर एक ID लगवाते हैं, क्योंकि नतीजे क्रम में वापस नहीं आते। कोई भी सेकंडों में जवाब का वादा नहीं करता। आपका runner भी ऐसे ही चले: हर चीज़ पर ID, और घंटों में मापी गई योजना।

अगर लौटने के समय से ज़्यादा 50% छूट मायने रखती है, और आपके ज़रूरी मॉडल वहाँ हैं, तो होस्टेड Batch API सस्ता औज़ार हो सकता है। बनाने से पहले दोनों की कीमत LLM API लागत कैलकुलेटर से निकालें।

job में कितना समय लगेगा?

कोड लिखने से पहले यह हिसाब लगाएँ। दो सीमाएँ थ्रूपुट रोकती हैं, और धीमी वाली जीतती है:

  • In-flight सीमा ÷ लेटेंसी। 4 अनुरोध in flight और प्रति अनुरोध 2 सेकंड हों, तो आप प्रति सेकंड 2 पूरे कर सकते हैं।
  • प्रति मिनट अनुरोध। प्रति मिनट 30 पर आप प्रति सेकंड 0.5 शुरू कर सकते हैं, मॉडल कितना भी तेज़ हो।

BroadNet की उपयोग के अनुसार भुगतान वाली key 4 अनुरोध in flight और 30 प्रति मिनट देती है। जब हमने API रेफ़रंस देखा (2026-11-15), तब के मानों पर (प्रति मिनट 30 और 4 in flight), जब तक हर अनुरोध 8 सेकंड से ज़्यादा न ले, रेट लिमिट ही बाँधती है, और नीचे की टेबल प्रति मिनट 30 मानकर चलती है:

आइटम प्रति अनुरोध एक आइटम प्रति अनुरोध 20 आइटम
10,000 5.6 घंटे 17 मिनट
100,000 2.3 दिन 2.8 घंटे
1,000,000 23 दिन 28 घंटे

प्रति मिनट 30 अनुरोध पर एक key घंटे में 1,800 अनुरोध करती है, यानी दिन में 43,200। retry भी गिने जाते हैं: आपका हर 429 एक स्लॉट ख़र्च करता है।

दूसरा कॉलम सबसे बड़ा लीवर है। छोटे आइटम, जैसे रिव्यू या टिकट के विषय, क्रमांकित लिस्ट के रूप में प्रति अनुरोध 10 से 50 जा सकते हैं, और जवाब में JSON array आता है। जाँचें कि array में हर इनपुट के लिए एक entry है और हर entry पर उसका नंबर है। अरबी टेक्स्ट वर्गीकरण पोस्ट यह पैटर्न दिखाती है। लंबे आइटम पैक नहीं होते: हर अनुरोध को फिर भी मॉडल की कॉन्टेक्स्ट विंडो में समाना होता है, और लिस्ट बढ़ने पर गुणवत्ता गिर सकती है। भरोसा करने से पहले 200 आइटम पर पैकिंग टेस्ट करें।

प्रति-key सीमा को मात देने के लिए बिना पूछे एक job को कई keys में न फैलाएँ। BroadNet की Acceptable Use Policy रेट, concurrency या बजट सीमाओं से बचने की मनाही करती है। ज़्यादा चाहिए, तो BroadNet से पूछें, या नीचे बताए प्लान सेशन इस्तेमाल करें। बैच job प्लानर आपकी आइटम संख्या, लेटेंसी और सीमाओं के लिए यही हिसाब करता है।

दोबारा शुरू होने वाला runner कैसा दिखता है?

यह runner 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 से चलाएँ। हमने यही फ़ाइल एक लोकल mock सर्वर पर टेस्ट की, जो बेतरतीब 429 (8%) और 500 (5%) लौटाता था और 4 से ज़्यादा in flight या प्रति मिनट 30 से ज़्यादा शुरुआत को अस्वीकार करता था। 25 आइटम 28 अनुरोधों (3 retry) के साथ 55 सेकंड में पूरे हुए, और किसी भी 60 सेकंड की विंडो में 30 से ज़्यादा शुरुआत नहीं हुई। समय बचाने के लिए mock की सीमा प्रति मिनट 300 करने पर, 10 सेकंड बाद रोका गया 120 आइटम का रन 39 सेव किए गए नतीजों से दोबारा शुरू हुआ और 120 अनोखी IDs के साथ, बिना किसी दोहराव के, पूरा हुआ।

asyncio.gather की जगह worker pool क्यों?

429 गाइड asyncio.gather के चारों ओर semaphore इस्तेमाल करती है। कुछ सौ कॉल के लिए यह ठीक है। बड़े job के लिए queue से आइटम लेने वाले workers का तय pool बेहतर है:

  • मेमोरी। gather शुरू में ही हर आइटम के लिए एक task बनाता है। pool सिर्फ़ in flight आइटम रखता है।
  • Concurrency ही pool का आकार है। चार workers के कभी पाँच अनुरोध खुले नहीं हो सकते।
  • नतीजे डिस्क पर बहते हैं जैसे-जैसे वे पूरे होते हैं, किसी भी क्रम में, ID के साथ।

Pacer दूसरी सीमा संभालता है। अकेला semaphore आपको 4 in flight से आगे जाने से रोकता है, लेकिन अगर अनुरोध एक सेकंड लें, तो चार workers प्रति मिनट 240 शुरू करेंगे और ज़्यादातर पर 429 पाएँगे। pacer सभी workers में, retry समेत, शुरुआत के बीच 2 सेकंड का अंतर रखता है।

retry सुरक्षित कैसे रहते हैं?

सिर्फ़ वही retry करें जो दूसरी कोशिश में सफल हो सकता है:

जवाब कार्रवाई
429 रुकें और retry करें; BroadNet के डॉक्स कहते हैं “use response details and bounded backoff” (अनुवाद: जवाब के ब्योरे और सीमित backoff इस्तेमाल करें)
500, 502, 503, 504, timeout, टूटे कनेक्शन सीमित exponential backoff के साथ retry करें
400, 422 अनुरोध ठीक करें; retry वही एरर भेजता है
401, 402, 403 job रोकें; key, बैलेंस या नीति पर ध्यान चाहिए
413 आइटम छोटा करें

runner SDK के अपने retry बंद करता है (max_retries=0), ताकि ठीक एक retry नीति हो, दिखने वाली सीमा के साथ। Backoff फ़ुल jitter के साथ exponential है, 60 सेकंड पर सीमित, ताकि साथ विफल हुए workers साथ retry न करें। छह कोशिशों के बाद आइटम "ok": false के रूप में लिखा जाता है और job आगे बढ़ता है। एक ख़राब आइटम कभी दस लाख को नहीं रोकता।

मॉडल कॉल का कोई side effect नहीं होता, इसलिए यहाँ डिलीवरी कम से कम एक बार है: अगर अनुरोध के बीच प्रोसेस मर जाए, तो वह आइटम दोबारा शुरू होने पर फिर भेजा जाता है, और आप उसके लिए दो बार भुगतान करते हैं। यही एकमात्र बर्बादी है। अगर job किसी दूसरे सिस्टम में भी लिखता है, जैसे टिकट या ईमेल, तो उस लेखन को आइटम ID के आधार पर idempotent बनाएँ और उसे results.jsonl पर एक अलग पास में करें। लंबे चलने वाले एजेंट वाली पोस्ट idempotent side effect विस्तार से बताती है।

checkpointing कैसे काम करती है?

आउटपुट फ़ाइल ही checkpoint है। हर पूरा हुआ आइटम एक flush की गई लाइन है, इसलिए क्रैश, deploy या Ctrl-C के बाद अगला रन फ़ाइल पढ़ता है, "ok": true वाली IDs इकट्ठा करता है और सिर्फ़ बाक़ी को queue में डालता है। पहले विफल हुए आइटम अगले रन में retry होते हैं, और उनकी नई लाइन जुड़ती है। नतीजे पढ़ते समय हर ID की आख़िरी लाइन लें।

तीन आदतें इसे दिनों तक टिकाऊ बनाती हैं:

  1. स्थिर IDs। डेटाबेस key या इनपुट का hash इस्तेमाल करें, कभी लाइन नंबर नहीं, जो इनपुट फ़ाइल बदलने पर खिसक जाता है।
  2. finish_reason जाँचें। max_tokens पर कटा जवाब "ok": true है, लेकिन बेकार। DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B जवाब से पहले reasoning करते हैं, और reasoning max_tokens में गिनी जाती है। runner reasoning_effort="low" सेट करता है, जिसे BroadNet दस्तावेज़ित करता है, और 1,500 टोकन छोड़ता है।
  3. हर लाइन पर usage लॉग करें। results.jsonl से usage जोड़ने पर असली टोकन बिल मिलता है, जिसे आप अपने अनुमान से मिला सकते हैं।

लागत क्या है: उपयोग के अनुसार भुगतान या प्लान सेशन?

उपयोग के अनुसार भुगतान में लागत टोकन है। मान लें 100,000 रिव्यू, 150 टोकन का सिस्टम प्रॉम्प्ट, 150 टोकन का रिव्यू और कम reasoning के साथ 100 आउटपुट टोकन। यह 30 मिलियन इनपुट और 10 मिलियन आउटपुट टोकन हैं। DeepSeek V4.1 Flash पर इसकी लागत 30 × $0.175 + 10 × $0.52 है। सिस्टम प्रॉम्प्ट पहले और byte-दर-byte एक जैसा रखें, तो जहाँ कैश hit होता है वहाँ उसके 15 मिलियन टोकन $0.0055 प्रति 1M की कैश्ड इनपुट दर पर बिल हो सकते हैं। आपकी usage लाइनें दिखाती हैं कि ऐसा कितनी बार हुआ।

प्लान पर टोकन मुफ़्त हैं और लागत समय है। DeepSeek V4.1 Flash का प्लान सेशन “runs one request at a time” (अनुवाद: एक समय में एक अनुरोध चलाता है), इसलिए हर सेशन के लिए IN_FLIGHT=1 रखें। प्रति सेशन थ्रूपुट 86,400 ÷ प्रति आइटम सेकंड है, प्रति दिन। BroadNet सामान्य स्पीड लगभग 100 टोकन प्रति सेकंड बताता है, लेकिन आपकी लेटेंसी प्रॉम्प्ट की लंबाई और reasoning पर निर्भर है, इसलिए 50 आइटम पर मापें। अगर आप प्रति आइटम 3 सेकंड मापते हैं, तो एक सेशन दिन में 28,800 करता है:

Job सेशन 3 s/आइटम पर समय प्लान
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” (अनुवाद: fair use के तहत best effort) दिए जाते हैं, और BroadNet प्लान keys के लिए प्रति मिनट अनुरोध सीमा प्रकाशित नहीं करता; लागू सीमाएँ आपके अकाउंट में दिखती हैं। RPM अंदाज़े से नहीं, उन्हीं से सेट करें। सेशन प्लानर गाइड बताती है कि सेशन को keys में कैसे बाँटें।

BroadNet Inference कहाँ फ़िट होता है

BroadNet Inference में Batch API नहीं है, इसलिए यह बड़े jobs के लिए तब सही है जब आप runner पर ख़ुद नियंत्रण रखना और सामान्य प्रति-टोकन कीमत देना पसंद करें, या DeepSeek V4.1 Flash प्लान सेशन से लागत तय करना चाहें। बजट वाले छोटे jobs के लिए Gemma 4 VL 26B, प्रति 1M $0.10 इनपुट और $0.22 आउटपुट पर, $5 के शुरुआती क्रेडिट पर चलता है। हर अनुरोध के बाद प्रॉम्प्ट और आउटपुट नहीं रखे जाते। अगर आपका job एक दिन रुक सकता है और आपके ज़रूरी मॉडल 50% बैच छूट वाले प्रोवाइडर पर हैं, तो वह सस्ता पड़ सकता है; तय करने से पहले तुलना करें। प्लान और सीमाएँ inference.broadnet.ai/plans पर हैं।

अक्सर पूछे जाने वाले सवाल

क्या BroadNet Inference में Batch API है?

नहीं। 15 नवंबर 2026 को जाँचा गया उसका API रेफ़रंस POST /v1/chat/completions, POST /v1/audio/transcriptions और GET /v1/models दस्तावेज़ित करता है, कोई बैच या फ़ाइल-अपलोड endpoint नहीं और कोई बैच छूट नहीं। बड़े jobs को अपनी key की सीमाओं के भीतर सामान्य अनुरोधों की तरह चलाएँ।

LLM API से 100,000 प्रॉम्प्ट कैसे प्रोसेस करूँ?

आइटम को JSONL फ़ाइल में रखें, हर एक के साथ एक ID। key की in-flight सीमा के बराबर तय संख्या में workers चलाएँ, अनुरोधों की शुरुआत प्रति मिनट सीमा के भीतर रखें, 429 और 5xx को सीमित backoff के साथ retry करें, और हर नतीजा ID के साथ आउटपुट फ़ाइल में जोड़ें, ताकि job दोबारा शुरू हो सके।

दस लाख अनुरोधों के बैच में कितना समय लगेगा?

आइटम को अपनी असली दर से भाग दें। प्रति मिनट 30 अनुरोध और प्रति अनुरोध एक आइटम पर एक key दिन में 43,200 करती है, इसलिए दस लाख में लगभग 23 दिन लगते हैं। प्रति अनुरोध 20 छोटे आइटम पैक करने से यह लगभग 28 घंटे रह जाता है, अगर मॉडल लंबा प्रॉम्प्ट ठीक से संभाले।

बैच LLM कॉल के लिए asyncio.gather इस्तेमाल करूँ या worker pool?

दसियों हज़ार आइटम के लिए queue से आइटम लेने वाले workers का एक तय pool इस्तेमाल करें। semaphore के साथ gather छोटे jobs के लिए चलता है, लेकिन यह शुरू में ही हर task बना देता है और दोबारा शुरू करना व प्रगति ट्रैक करना मुश्किल बनाता है।

क्या तेज़ी के लिए कई API key इस्तेमाल कर सकता हूँ?

पहले जाँच लें। BroadNet की Acceptable Use Policy रेट या concurrency सीमाओं से बचने की मनाही करती है, इसलिए प्रति-key सीमा पार करने के लिए एक job को कई keys में बाँटने से पहले BroadNet से पूछें। प्रति अनुरोध ज़्यादा आइटम पैक करना और प्लान सेशन थ्रूपुट बढ़ाने के दस्तावेज़ित तरीक़े हैं।

क्या फ़्लैट प्लान बैच jobs के लिए अच्छा है?

DeepSeek V4.1 Flash के लिए हो सकता है। सेशन बिना टोकन मीटर के एक समय में एक अनुरोध चलाता है, इसलिए लागत तय है और सवाल समय का है। प्रति आइटम सेकंड मापें, फिर अवधि के भीतर काम ख़त्म करने लायक सेशन ख़रीदें।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें

स्रोत