OpenAI-संगत LLM API के लिए Python में बैच अनुरोध
LLM API बैच पायथन कार्य के लिए, आपको एक विशेष बैच एंडपॉइंट की आवश्यकता नहीं है: आपको एक वर्कर पूल की आवश्यकता है जो रेट लिमिट का सम्मान करे, HTTP 429 के लिए एक रीट्राई नियम, और एक परिणाम फ़ाइल जिसे आप फिर से शुरू कर सकें। यह गाइड OpenAI SDK का उपयोग करके तीनों को आपके बेस URL पर इंगित करके बनाती है।

मुख्य बिंदु
- API की दो विधियाँ हैं, चैट पूर्णताएँ और मॉडल्स, इसलिए बैचिंग समानांतर अनुरोधों के पूल के साथ आपके पक्ष पर की जाती है।
- एक फुल कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 की अनुमति देती है; एक ट्रायल कुंजी 2 और 60 की अनुमति देती है। अपने पूल का आकार उसी अनुसार सेट करें।
- Retry-After हेडर का उपयोग करके 429 पर पुनः प्रयास करें, और रेट लिमिटेड को समानांतरता से अलग बताएँ।
- प्रत्येक परिणाम को JSONL फ़ाइल में लिखें जैसे ही वह समाप्त हो जाए ताकि क्रैश में मिनटों का नुकसान हो, पूरे रन का नहीं।
यहाँ बैचिंग कैसे काम करती है
एंडपॉइंट OpenAI-कम्पैटिबल है और POST /v1/chat/completions तथा GET /v1/models एक्सपोज़ करता है। कोई अलग जॉब-सबमिशन एंडपॉइंट नहीं है जो फ़ाइल लेता है और बाद में रिटर्न करता है। इसलिए बैच सामान्य अनुरोधों पर एक लूप है, जो समानांतर अनुरोधों के साथ चलाया जाता है, और सीमाएँ आपके कोड में बिल्ट-इन हैं। यह जितना सुनने में आता है उससे सरल है, और यह आपको परिणाम तब देता है जब वे पूरे होते हैं, अंत में नहीं।
डिज़ाइन को आकार देने वाली संख्याएँ सीमाएँ हैं। एक फुल कुंजी 8 समानांतर अनुरोधों और प्रति मिनट 300 अनुरोधों की अनुमति देती है। एक ट्रायल कुंजी 2 समानांतर और प्रति मिनट 60 की अनुमति देती है। अधिकतम अनुरोध बॉडी 8 MB है। एक स्ट्रीमिंग अनुरोध स्ट्रीम खत्म होने तक अपनी कॉन्करेंसी स्लॉट को हॉल्ड करता है, इसलिए बैच वर्क के लिए, स्ट्रीमिंग को बंद रखें।
बस सब कुछ एक साथ क्यों न फ़ायर करें? क्योंकि एक बैच एक सीलिंग वाला थ्रूपुट प्रॉब्लम है, और सीलिंग आपकी है जिसे सम्मानित करना है। एक लूप जो 5,000 अनुरोधों को Python द्वारा बनाए जा सकने वाले सबसे तेज़ गति से भेजता है, 429 रिस्पॉन्स की एक दीवार प्राप्त करता है, रेट्राइज़ पर समय बर्बाद करता है, और उपयोगी एरर्स को नॉइज़ में दबा देता है। एक पूल जो फ्लाइट में अधिकतम 8 अनुरोधों को हॉल्ड करता है, सेवा की अनुमत गति पर लाइन को आगे बढ़ाता है, और यह कोड वही रहता है चाहे आपके पास 50 रो या 500,000 हों। तीन चीज़ों की योजना बनाएं: एक बाउंडेड पूल, एक रीट्राइज़ नियम, और एक एपेंड-ओनली रिजल्ट्स फ़ाइल।
मॉडल आईडी uncensored है, ऑथेंटिकेशन Authorization: Bearer <key> है, और बेस यूआरएल https://api.unfilteredvideo.com/v1 है। यदि आपके पास अभी तक कुंजी नहीं है, तो API कुंजी पेज पर एक क्लिक $0.50 ट्रायल है।
इंस्टॉल और सेटअप करें
आपको Python 3.9 या नया चाहिए और आधिकारिक openai पैकेज। कुंजी को स्क्रिप्ट में नहीं, बल्कि एक पर्यावरण चर में डालें।
pip install openai
export API_KEY="paste-your-key-here"
# quick check that the key and base URL work
curl https://api.unfilteredvideo.com/v1/models -H "Authorization: Bearer $API_KEY"
मॉडल सूची में uncensored दिखना चाहिए। अब अपनी इनपुट को एक JSONL फ़ाइल के रूप में तैयार करें, एक ऑब्जेक्ट प्रति लाइन जिसमें एक id और प्रोसेस करने के लिए टेक्स्ट हो। id वह है जो आपको बाद में पुनः आरंभ करने देता है।
{"id": "r001", "text": "Summarise this product review in one sentence: ..."}
{"id": "r002", "text": "Summarise this product review in one sentence: ..."}
एक थ्रेड पूल जो सीमाओं के भीतर रहता है
अधिकांश स्क्रिप्ट्स के लिए, ThreadPoolExecutor सबसे छोटा रास्ता है। OpenAI क्लाइंट थ्रेड्स के बीच साझा करने के लिए सुरक्षित है, और कार्य नेटवर्क-बाउंडेड है, इसलिए थ्रेड उपयुक्त हैं। पूल का आकार अपनी समानांतरता सीमा पर सेट करें, उससे ऊपर नहीं: अतिरिक्त वर्कर्स बस 429 त्रुटियाँ एकत्र करते हैं।
import json, os
from concurrent.futures import ThreadPoolExecutor, as_completed
from openai import OpenAI
client = OpenAI(api_key=os.environ["API_KEY"], base_url="https://api.unfilteredvideo.com/v1", max_retries=0)
MODEL = "uncensored"
WORKERS = 8 # use 2 on a trial key
def run_one(row):
resp = client.chat.completions.create(
model=MODEL,
temperature=0.2,
max_tokens=200,
messages=[{"role": "user", "content": row["text"]}],
)
return {
"id": row["id"],
"output": resp.choices[0].message.content,
"in": resp.usage.prompt_tokens,
"out": resp.usage.completion_tokens,
}
rows = [json.loads(line) for line in open("input.jsonl")]
with ThreadPoolExecutor(max_workers=WORKERS) as pool, open("output.jsonl", "a") as out:
futures = [pool.submit(run_one, r) for r in rows]
for f in as_completed(futures):
out.write(json.dumps(f.result()) + "\n")
out.flush()
इस वर्जन में कोई रीट्राइज़ और कोई रीज्यूम नहीं है, इसलिए यह एक स्टार्टिंग पॉइंट है। क्लाइंट max_retries=0 के साथ बनाया गया है क्योंकि SDK डिफ़ॉल्ट रूप से अपने आप रीट्राइज़ करता है, और आप एक जगह चाहते हैं जो रीट्राइज़ नियम को ओन करती है। अगले दो सेक्शन उस नियम और रीज्यूम लॉजिक को जोड़ते हैं।
429 को सही तरीके से हैंडल करें
इस API पर 429 के तीन प्रकार हैं, और उन्हें थोड़े अलग प्रतिक्रियाओं की आवश्यकता है:
rate_limited: आपने एक मिनट में बहुत सारे अनुरोध भेज दिए। गति धीमी करें। कम वर्कर्स वाला एक पूल, या एक छोटा विलंब, इसे ठीक कर देता है।concurrency: एक साथ बहुत सारे अनुरोध सक्रिय थे। आपका पूल आपकी सीमा से बड़ा है, या आपके पास ऐसे खुले स्ट्रीम हैं जिन्हें आपने भूल गए हैं।- अस्थायी ओवरलोड: एक
Retry-After: 5हेडर के साथ 429। आपके कोड में कुछ गलत नहीं है। निर्दिष्ट समय तक प्रतीक्षा करें और फिर से कोशिश करें।
एक रीट्राइज़ हेल्पर तीनों को कवर करता है। यह मौजूद होने पर Retry-After के लिए इंतज़ार करता है और अन्यथा थोड़ी ज़िटर के साथ एक्सपोनेंशियली बैकऑफ़ करता है। फेल और रिफ्यूज किए गए अनुरोधों के लिए चार्ज नहीं किया जाता है, इसलिए रीट्राइज़ फ्री है।
import random, time
import openai
from openai import OpenAI
client = OpenAI(api_key=__import__("os").environ["API_KEY"], base_url="https://api.unfilteredvideo.com/v1", max_retries=0)
MODEL = "uncensored"
def call_with_retry(messages, attempts=6):
for n in range(attempts):
try:
return client.chat.completions.create(model=MODEL, messages=messages, max_tokens=200)
except openai.RateLimitError as e:
wait = e.response.headers.get("Retry-After")
delay = float(wait) if wait else min(60, 2 ** n) + random.random()
print("429", getattr(e, "code", None), "waiting", round(delay, 1), "s")
time.sleep(delay)
except (openai.APIConnectionError, openai.APITimeoutError):
time.sleep(min(30, 2 ** n))
raise RuntimeError("gave up after %d attempts" % attempts)
हर त्रुटि पर अंधाधुंध पुनः प्रयास न करें। एक 400 का मतलब है कि आपका अनुरोध गलत है, उदाहरण के लिए 8 MB से अधिक बॉडी या एक खराब संदेश, और इसे फिर से भेजने से वही त्रुटि आएगी। इसे पंक्ति id के साथ लॉग करें और आगे बढ़ें।
एक असिंक संस्करण सेमेफोर के साथ
यदि आपका स्क्रिप्ट पहले से ही इवेंट लूप में चल रहा है, या आप वेब सेवा को डेटा भेजना चाहते हैं, तो AsyncOpenAI और एक asyncio.Semaphore का उपयोग करें जो चल रहे अनुरोधों को सीमित करता है। सेमेफोर पूल साइज की भूमिका निभाता है।
import asyncio, json, os
from openai import AsyncOpenAI
client = AsyncOpenAI(api_key=os.environ["API_KEY"], base_url="https://api.unfilteredvideo.com/v1", max_retries=0)
MODEL = "uncensored"
sem = asyncio.Semaphore(8)
async def run_one(row, out):
async with sem:
resp = await client.chat.completions.create(
model=MODEL,
max_tokens=200,
messages=[{"role": "user", "content": row["text"]}],
)
out.write(json.dumps({"id": row["id"], "output": resp.choices[0].message.content}) + "\n")
out.flush()
async def main():
rows = [json.loads(l) for l in open("input.jsonl")]
with open("output.jsonl", "a") as out:
await asyncio.gather(*(run_one(r, out) for r in rows))
asyncio.run(main())
उसी रीट्राई लॉजिक के साथ कॉल को घेरें, await asyncio.sleep का उपयोग करके time.sleep के स्थान पर। एक सावधानी: gather के साथ दस लाखों कोरूटीन एक साथ बनाते हैं। बहुत बड़े इनपुट के लिए, फ़ाइल को कुछ हज़ार पंक्तियों के स्लाइस में प्रोसेस करें।
रन को रीज्यूमेबल बनाएं
लंबे कार्य बोरिंग तरीकों से फेल होते हैं: लैपटॉप विश्राम कर लेता है, कनेक्शन टूट जाता है, आप Ctrl+C दबा देते हैं। चूँकि हर पूरी हुई पंक्ति output.jsonl में उसकी id के साथ ऐपेंड की जाती है, पुनः आरंभ करने का मतलब है उन ids को स्किप करना जो आपके पास पहले से मौजूद हैं।
import json, os
from openai import OpenAI
client = OpenAI(api_key=os.environ["API_KEY"], base_url="https://api.unfilteredvideo.com/v1")
MODEL = "uncensored"
def done_ids(path="output.jsonl"):
if not os.path.exists(path):
return set()
return {json.loads(line)["id"] for line in open(path) if line.strip()}
finished = done_ids()
todo = [r for r in map(json.loads, open("input.jsonl")) if r["id"] not in finished]
print(len(finished), "done,", len(todo), "to go")
todo को ऊपर बताए गए किसी भी पूल में फ़ीड करें। आउटपुट फ़ाइल को ऐपेंड मोड में खोलें, लेखन मोड में नहीं, वरना रीस्टार्ट से आपकी प्रोग्रेस मिट जाएगी। त्रुटियों को एक दूसरी फ़ाइल errors.jsonl में भी लिखें, ताकि आप यह पढ़कर कि वे क्यों फेल हुईं, केवल फेल हुए रिकॉर्ड्स को ही पुनः चलाएँ।
रीरन के बीच दोहराए जाने वाले आउटपुट के लिए, एक स्थिर seed और एक कम temperature पास करें। सीड को टॉप_p, स्टॉप और पेनल्टीज़ के साथ मॉडल को पास किया जाता है।
पहले एक छोटे स्लाइस पर टेस्ट करें
20,000 पंक्तियाँ चलाने से पहले 20 पंक्तियाँ चलाएं। उन पंक्तियों को चुनें जिनमें आपके सबसे खराब केस शामिल हों: सबसे लंबा इनपुट, एक जिसमें अजीब अक्षर हैं, और एक खाली। आउटपुट को आँखों से पढ़ें, जांचें कि usage आपकी लागत अनुमान से मेल खाता है, और रीट्राई हेल्पर के व्यवहार की पुष्टि करें कि यह आपके लिमिट से ऊपर वर्कर काउंट बढ़ाकर काम करता है। आपको लॉग में concurrency कोड के साथ एक 429, एक वेट और एक सफल रीट्राई दिखनी चाहिए। यह 20 पंक्तियों पर देखना बेहतर है कि 9,000वीं पंक्ति पर यह पता चलना।
यदि जॉब को स्ट्रक्चर्ड आउटपुट की आवश्यकता है, तो response_format={"type": "json_object"} के साथ JSON मोड जोड़ें, प्रॉम्प्ट में कीज़ का वर्णन करें, और हर जवाब को एक ट्राई ब्लॉक के अंदर पार्स करें। टेस्ट स्लाइस के दौरान पार्स फेल्योर की गिनती करें। प्रतिशत या दो प्रतिशत से ऊपर की दर आमतौर पर इस बात का संकेत है कि प्रॉम्प्ट में स्पष्ट स्कीमा की आवश्यकता है, और इसे अब ठीक करना बाद में रीरन करने से सस्ता है। पार्स करने में फेल हुई पंक्तियाँ अपनी id के साथ errors.jsonl में जाती हैं, और रीज्यूम लॉजिक उन्हें पूरा नहीं हुआ मानता है।
अंत में, एक क्लाइंट टाइमआउट सेट करें जो आपकी सबसे लंबी अपेक्षित आउटपुट के अनुरूप हो। SDK क्लाइंट पर या प्रति अनुरोध timeout=60 स्वीकार करता है; एक अनुरोध जो कभी लौटता नहीं है, अन्यथा आपके 8 स्लॉट में से एक को तब तक पकड़े रखेगा जब तक वह वहीं रहता है।
पूल का साइज़िंग और समय का अनुमान
थ्रूपुट दो चीजों से सीमित है: समानांतर अनुरोधों की संख्या को एक अनुरोध के समय से भाग देना, और प्रति मिनट अनुरोधों की सीमा। एक पूर्ण कुंजी पर सीमा प्रति मिनट 300 है, जो प्रति सेकंड 5 है। यदि एक सामान्य अनुरोध में 2 सेकंड लगते हैं, तो 8 वर्कर प्रति सेकंड 8 / 2 = 4 अनुरोध उत्पन्न करते हैं, या प्रति मिनट 240, जो सीमा के भीतर है। यदि अनुरोधों में 1 सेकंड लगते हैं, तो 8 वर्कर प्रति सेकंड 8 का प्रयास करेंगे और सीमा पर पहुँचेंगे, इसलिए एक छोटा विलंब जोड़ें या कभी-कभी आने वाले 429 त्रुटियों को स्वीकार करें जिन्हें आपका रीट्राई हेल्पर अवशोषित कर लेता है।
प्रति सेकंड 4 पर, 10,000 पंक्तियों में 2,500 सेकंड लगते हैं, लगभग 42 मिनट। एक ट्रायल API कुंजी पर, 2 समकालिक अनुरोधों और प्रति मिनट 60 के साथ, कठोर सीमा प्रति सेकंड 1 है, इसलिए वही 10,000 पंक्तियाँ 10,000 सेकंड लेंगी, लगभग 2 घंटे 47 मिनट। व्यावहारिक रूप से, $0.50 ट्रायल क्रेडिट उससे पहले खत्म हो जाएगा, जो इसे कुछ सौ पंक्तियों पर स्क्रिप्ट का परीक्षण करने के लिए एक अच्छी जगह बनाता है, न कि उत्पादन चलाने के लिए।
एक बड़े बैच की लागत क्या है
मूल्य $0.15 प्रति 1M इनपुट टोकन और $0.50 प्रति 1M आउटपुट टोकन है। एक क्लासिफिकेशन-स्टाइल जॉब लें: 50,000 पंक्तियाँ, प्रत्येक लगभग 200 इनपुट टोकन और 100 आउटपुट टोकन की।
- इनपुट: 50,000 × 200 = 10,000,000 टोकन, जो 10 × $0.15 = $1.50 है।
- आउटपुट: 50,000 × 100 = 5,000,000 टोकन, जो 5 × $0.50 = $2.50 है।
- कुल: $4.00, या प्रति पंक्ति $0.00008।
उपरोक्त स्क्रिप्ट प्रत्येक पंक्ति के लिए in और out रिकॉर्ड करती है, इसलिए आप अपनी वास्तविक रन से उसी आंकड़े की गणना कर सकते हैं। X-Balance-USD प्रतिक्रिया शीर्षक शेष क्रेडिट भी दिखाता है, और X-Request-Id वह है जिसे आपको docs या सहायता पृष्ठों पर मदद के लिए उद्धृत करना चाहिए।
क्रेडिट $20 से $500 तक पूर्ण-डॉलर टॉप-अप में प्रीपेड होता है, $50 से +5%, $100 से +10% और $200 से +15% बोनस के साथ, क्रिप्टो (TRC20 पर USDT या Base पर USDC) से भुगतान किया जाता है। यह कभी खत्म नहीं होता। मूल्य निर्धारण पेज पर पूर्ण विवरण है। संवेदनशील डेटासेट्स के लिए एक नोट: प्रॉम्प्ट्स को ट्रेनिंग के लिए उपयोग नहीं किया जाता है।
अधिक गाइड
प्रश्न और उत्तर
क्या API का एक बैच एंडपॉइंट है?
नहीं। यह चैट पूर्णताएँ और मॉडल सूची प्रदान करता है। आप अपने कोड से कई सामान्य अनुरोध समानांतर रूप से चलाकर बैच बनाते हैं, एक पूर्ण कुंजी पर 8 समानांतर और प्रति मिनट 300 की सीमा के भीतर।
मुझे कितने थ्रेड्स का उपयोग करना चाहिए?
पूर्ण कुंजी पर 8 वर्कर्स और ट्रायल कुंजी पर 2 वर्कर्स का उपयोग करें, जो कन्करेंसी सीमाओं से मेल खाते हैं। अधिक वर्कर्स केवल कोड concurrency के साथ 429 त्रुटियां उत्पन्न करते हैं।
जब मुझे HTTP 429 मिलता है तो मुझे क्या करना चाहिए?
यदि प्रतिक्रिया में Retry-After मान है तो उसका प्रतीक्षा करें, अन्यथा कुछ सेकंड के लिए बैकऑफ़ करें, फिर पुनः प्रयास करें। विफल अनुरोधों के लिए चार्ज नहीं किया जाता है, इसलिए पुनः प्रयास करने में कोई लागत नहीं आती।
क्या मैं बैच जॉब में स्ट्रीमिंग प्रतिक्रियाएं प्राप्त कर सकता हूँ?
आप ऐसा कर सकते हैं, लेकिन आपको ऐसा नहीं करना चाहिए। एक स्ट्रीमिंग अनुरोध स्ट्रीम समाप्त होने तक अपनी कन्करेंसी स्लॉट को पकड़े रखता है, जिससे थ्रूपुट कम हो जाता है। बैच कार्य के लिए स्ट्रीमिंग बंद रखें।
आपकी कुंजी बस एक फ़ॉर्म दूर है
एक खाता बनाएँ, कुंजी कॉपी करें, बेस URL बदलें। सेटअप यही है।