TH ▾

คำขอแบบแบทช์ใน Python สำหรับ API LLM ที่เข้ากันได้กับ OpenAI

สำหรับงาน batch ของ LLM API ด้วย Python คุณไม่ต้องการเอนด์พอยต์ batch พิเศษ: คุณต้องการพูล worker ที่เคารพขีดจำกัดอัตรา กฎการรีเทรย์สำหรับ HTTP 429 และไฟล์ผลลัพธ์ที่คุณสามารถดำเนินการต่อจากได้ คู่มือนี้สร้างทั้งสามอย่างด้วย OpenAI SDK ที่ชี้ไปที่ base URL ของคุณ

อัปเดตเมื่อ

ท่อคู่ขนานที่นำลูกบาศก์ข้อมูลเข้าสู่แกนประมวลผล แสดงคำขอแบทช์แบบขนานใน Python

ประเด็นสำคัญ

  • API มีสองวิธีคือ chat completions และ models ดังนั้นการแบทช์จึงทำด้านของคุณด้วย pool ของคำขอพร้อมกัน
  • คีย์เต็มอนุญาตให้คำขอพร้อมกัน 8 รายการและ 300 ต่อนาที; คีย์ทดลองอนุญาตให้ 2 และ 60 ปรับขนาด pool ของคุณให้สอดคล้องกัน
  • รีเทรย์เมื่อได้ 429 โดยใช้ส่วนหัว Retry-After และแยกแยะ rate_limited ออกจากความพร้อมใช้งานพร้อมกัน
  • เขียนผลลัพธ์แต่ละรายการไปยังไฟล์ JSONL ทันทีที่เสร็จสิ้น เพื่อให้หากเกิดการล่มเสียเวลาเพียงไม่กี่นาที ไม่ใช่เสียการรันทั้งหมด

วิธีการทำงานของแบตช์ในบริบทนี้

เอนด์พอยต์เข้ากันได้กับ OpenAI และเปิดเผย POST /v1/chat/completions และ GET /v1/models ไม่มีเอนด์พอยต์ส่งงานแยกต่างหากที่รับไฟล์แล้วส่งผลลัพธ์ทีหลัง ดังนั้น batch จึงเป็นลูปที่วนคำขอปกติ ทำงานพร้อมกัน โดยมีขีดจำกัดที่ฝังอยู่ในโค้ดของคุณ นั่นง่ายกว่าที่คิด และให้ผลลัพธ์ทันทีที่เสร็จแทนที่จะรอจนจบ

ตัวเลขที่กำหนดการออกแบบคือขีดจำกัด คีย์แบบเต็มอนุญาตให้ทำคำขอพร้อมกัน 8 คำขอ และ 300 คำขอต่อนาที คีย์แบบทดลองอนุญาตให้ทำคำขอพร้อมกัน 2 คำขอ และ 60 คำขอต่อนาที ขนาดสูงสุดของ body คำขอคือ 8 MB คำขอแบบสตรีมมิงจะครอบครองช่องความพร้อมใช้งานแบบคอนเคอร์เรนซีจนกว่าสตรีมจะจบ ดังนั้นสำหรับงานแบทช์ ให้ปิดสตรีมมิง

ทำไมไม่ยิงทุกอย่างไปพร้อมกัน? เพราะ batch เป็นปัญหา throughput ที่มีเพดาน และเพดานนั้นคุณต้องเคารพ ลูปที่ส่ง 5,000 คำขอเร็วที่สุดที่ Python จะสร้างได้ จะได้รับกำแพงของ 429 responses เสียเวลาไปกับรีเทรย์ และซ่อนข้อผิดพลาดที่มีประโยชน์ไว้ในสัญญาณรบกวน พูลที่จำกัดการดำเนินการไว้สูงสุด 8 คำขอช่วยให้เส้นทางการทำงานเคลื่อนที่ด้วยความเร็วที่บริการอนุญาต และโค้ดก็เหมือนกันไม่ว่าคุณจะมี 50 แถวหรือ 500,000 แถว วางแผนสำหรับสามส่วน: พูลที่มีขอบเขต กฎการรีเทรย์หนึ่งข้อ และไฟล์ผลลัพธ์แบบ append-only

model ID คือ uncensored การตรวจสอบสิทธิ์คือ Authorization: Bearer <key> และ base URL คือ https://api.unfilteredvideo.com/v1 หากคุณยังไม่มีคีย์ หน้า API key มีเครดิตทดลองใช้ $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 ตอนนี้เตรียม input ของคุณเป็นไฟล์ 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 client ปลอดภัยต่อการแชร์ระหว่าง thread และงานเป็นแบบ network-bound ดังนั้น thread จึงเหมาะสม กำหนดขนาดพูลเป็นขีดจำกัดความพร้อมใช้งานพร้อมกันของคุณ ไม่ใช่สูงกว่านั้น: worker เพิ่มเติมเพียงเก็บข้อผิดพลาด 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()

เวอร์ชันนี้ไม่มี retry และไม่มี resume ดังนั้นจึงเป็นจุดเริ่มต้น client ถูกสร้างด้วย max_retries=0 บน client เพราะ SDK จะ retry ให้เองตามค่าเริ่มต้น และคุณต้องการจุดเดียวที่เป็นเจ้าของกฎการ retry สองส่วนถัดไปจะเพิ่มกฎนั้นและตรรกะการ resume

จัดการ 429 ให้ถูกต้อง

มี 429 สามประเภทใน API นี้ ซึ่งต้องการการตอบสนองที่แตกต่างกันเล็กน้อย:

  • rate_limited: คุณส่งคำขอมากเกินไปในหนึ่งนาที ลดความเร็วลง พูลที่มี worker น้อยลง หรือการ sleep สั้นๆ แก้ไขได้
  • concurrency: มีคำขอมากเกินไปที่กำลังดำเนินการอยู่พร้อมกัน พูลของคุณใหญ่กว่าขีดจำกัดของคุณ หรือคุณมีสตรีมที่เปิดอยู่ที่คุณลืม
  • ภาระงานล้นชั่วคราว: 429 พร้อม header Retry-After: 5 โค้ดของคุณไม่มีปัญหา รอตามเวลาที่ระบุแล้วลองอีกครั้ง

ตัวช่วย retry หนึ่งตัวครอบคลุมทั้งสามกรณี มันรอ Retry-After เมื่อมีอยู่ และในกรณีอื่นจะ back off แบบ exponential พร้อม jitter เล็กน้อย คำขอที่ล้มเหลวและถูกปฏิเสธจะไม่ถูกคิดเงิน ดังนั้นการ retry จึงฟรี

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)

อย่า retry แบบตาบอดกับข้อผิดพลาดทุกข้อ 400 หมายถึงคำขอของคุณผิด เช่น body เกิน 8 MB หรือข้อความที่ผิดรูปแบบ และการส่งอีกครั้งจะล้มเหลวแบบเดียวกัน บันทึกด้วย row id แล้วข้ามไป

เวอร์ชัน async พร้อม semaphore

หากสคริปต์ของคุณทำงานอยู่ใน event loop อยู่แล้ว หรือต้องการป้อนข้อมูลให้เว็บเซอร์วิส ให้ใช้ AsyncOpenAI และ asyncio.Semaphore เพื่อจำกัดจำนวนคำขอที่กำลังดำเนินการอยู่ 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 พร้อม coroutines หลายหมื่นรายการจะสร้างพวกมันทั้งหมดพร้อมกัน สำหรับอินพุตขนาดใหญ่มาก ให้ประมวลผลไฟล์เป็นช่วงๆ ละไม่กี่พันแถว

ทำให้การรันสามารถดำเนินการต่อได้

งานระยะยาวล้มเหลวในลักษณะที่น่าเบื่อ: แล็ปท็อปเข้าสู่โหมดสลีบ การเชื่อมต่อขาดหาย คุณกด Ctrl+C เนื่องจากแถวที่เสร็จแล้วแต่ละแถวจะถูกเพิ่มเข้าไปใน output.jsonl พร้อม id ของมัน การดำเนินการต่อจึงหมายถึงการข้าม id ที่มีอยู่แล้ว

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 ไปยังพูลใดพูลหนึ่งดังกล่าว เปิดไฟล์ผลลัพธ์ในโหมด append เสมอ ไม่ใช่โหมด write หรือการรีสตาร์ทจะลบความคืบหน้าของคุณ นอกจากนี้ให้บันทึกข้อผิดพลาดไปยังไฟล์ที่สอง errors.jsonl เพื่อให้คุณสามารถรันเฉพาะความล้มเหลวอีกครั้งหลังจากอ่านสาเหตุที่ล้มเหลว

เพื่อให้ได้ผลลัพธ์ที่ซ้ำกันได้ในการรันซ้ำ ให้ส่ง seed คงที่ พร้อมกับ temperature ต่ำ seed จะถูกส่งผ่านไปยังโมเดลพร้อมกับ top_p, stop และค่าปรับ

ทดสอบบนข้อมูลตัวอย่างขนาดเล็กก่อน

รัน 20 แถวก่อนที่จะรัน 20,000 แถว เลือกแถวที่รวมกรณีเลวร้ายที่สุดของคุณ: อินพุตที่ยาวที่สุด หนึ่งที่มีอักขระแปลกๆ หนึ่งที่เป็นค่าว่าง อ่านผลลัพธ์ด้วยตา ตรวจสอบว่า usage ตรงกับประมาณการต้นทุนของคุณ และยืนยันว่าตัวช่วยรีเทรย์ทำงานโดยการเพิ่มจำนวน worker ให้สูงกว่าขีดจำกัดของคุณชั่วคราว คุณควรเห็น 429 พร้อมโค้ด concurrency ใน log การรอ และรีเทรย์ที่สำเร็จ การเห็นสิ่งนั้นบน 20 แถวดีกว่าการค้นพบมันที่แถวที่ 9,000

หากงานต้องการผลลัพธ์ที่มีโครงสร้าง ให้เพิ่มโหมด JSON ด้วย response_format={"type": "json_object"} อธิบายคีย์ในพรอมต์ และแยกวิเคราะห์แต่ละคำตอบภายใน try block นับจำนวนความล้มเหลวในการแยกวิเคราะห์ในช่วงทดสอบ หากอัตราความล้มเหลวสูงกว่าร้อยละหนึ่งหรือสอง แสดงว่าพรอมต์ต้องการสคีมาที่ชัดเจนกว่า และนั่นจะแก้ไขได้ง่ายกว่าการรันซ้ำในภายหลัง แถวที่แยกวิเคราะห์ไม่สำเร็จจะถูกส่งไปยัง errors.jsonl พร้อม id ของมัน และตรรกะการดำเนินการต่อจะถือว่าแถวนั้นยังไม่เสร็จ

สุดท้าย ตั้งค่า client timeout ที่เหมาะกับเอาต์พุตที่ยาวที่สุดที่คาดไว้ SDK ยอมรับ timeout=60 บน client หรือต่อคำขอ; คำขอที่ค้างและไม่ส่งกลับจะครอบครองหนึ่งใน 8 สล็อตของคุณไปนานเท่าที่มันอยู่ที่นั่น

การกำหนดขนาดพูลและการประมาณการเวลา

Throughput ถูกจำกัดด้วยสองสิ่ง: ความพร้อมใช้งานพร้อมกันหารด้วยเวลาที่คำขอหนึ่งใช้ และขีดจำกัดคำขอต่อนาที บนคีย์เต็ม ขีดจำกัดคือ 300 ต่อนาที ซึ่งคือ 5 ต่อวินาที หากคำขอทั่วไปใช้เวลา 2 วินาที worker 8 ตัวจะผลิต 8 / 2 = 4 คำขอต่อวินาที หรือ 240 ต่อนาที ซึ่งอยู่ภายใต้ขีดจำกัด หากคำขอใช้เวลา 1 วินาที worker 8 ตัวจะพยายาม 8 ต่อวินาทีและชนขีดจำกัด ดังนั้นจึงเพิ่มดีเลย์เล็กน้อยหรือยอมรับ 429 เป็นครั้งคราวที่ตัวช่วยรีเทรย์ของคุณดูดซับ

ที่ความเร็ว 4 ต่อวินาที แถว 10,000 แถวใช้เวลา 2,500 วินาที หรือประมาณ 42 นาที บนคีย์ทดลอง ด้วยคำขอพร้อมกัน 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 หรือหน้า support

เครดิตเป็นแบบเติมเงินล่วงหน้าเป็นจำนวนเต็มดอลลาร์จากการเติมเงินตั้งแต่ $20 ถึง $500 พร้อมโบนัส +5% จาก $50, +10% จาก $100 และ +15% จาก $200 จ่ายด้วยคริปโต (USDT บน TRC20 หรือ USDC บน Base) เครดิตไม่หมดอายุ หน้าราคา มีรายละเอียดเต็มรูปแบบ หมายเหตุสำหรับชุดข้อมูลที่ละเอียดอ่อน: พรอมต์ไม่ถูกนำไปใช้ในการฝึกโมเดล

ถาม-ตอบ

API มี endpoint แบบแบทช์หรือไม่?

ไม่ มันเปิดเผย chat completions และรายการโมเดล คุณทำ batch โดยรันคำขอปกติหลายคำขอพร้อมกันจากโค้ดของคุณเอง ภายใน 8 concurrent และ 300 ต่อนาทีบนคีย์เต็ม

ควรใช้ thread กี่ตัว

ใช้ worker 8 ตัวสำหรับคีย์เต็ม และ 2 ตัวสำหรับคีย์ทดลอง โดยให้ตรงกับขีดจำกัดความพร้อมใช้งาน (concurrency) การใช้ worker มากเกินไปจะทำให้เกิดข้อผิดพลาด 429 ที่มีโค้ด concurrency

ควรทำอย่างไรเมื่อได้รับ HTTP 429

รอค่า Retry-After หากใน response มีค่าดังกล่าว มิฉะนั้นให้ถอยหลัง (back off) สักสองสามวิแล้วลองใหม่ คำขอที่ล้มเหลวจะไม่ถูกคิดเงิน ดังนั้นการลองใหม่จึงไม่เสียค่าใช้จ่าย

สามารถสตรีม response ในงานแบบ batch ได้หรือไม่

ทำได้ แต่ไม่ควรทำ คำขอแบบสตรีมจะยึดช่องความพร้อมใช้งาน (concurrency slot) ไว้จนกว่าสตรีมจะสิ้นสุด ซึ่งทำให้ปริมาณงานลดลง ควรปิดสตรีมสำหรับงานแบบ batch

คีย์ของคุณอยู่ห่างเพียงขั้นตอนแบบฟอร์มเดียว

สร้างบัญชี คัดลอกคีย์ และเปลี่ยน URL พื้นฐาน นั่นคือการตั้งค่าทั้งหมด

รับคีย์ API