Omejitve hitrosti, kvote in ravni
Na tej strani
Omejitve hitrosti, kvote in ravni
Omejitve hitrosti določajo, koliko zahtev lahko pošljete API-ju na minuto. Razumevanje in upravljanje teh omejitev je ključnega pomena za preprečevanje prekinitev storitev v produkcijskem okolju. Nočna mora je vedno enaka: integracija, ki je brezhibno delovala v razvojnem okolju, kjer ste pošiljali tri zahteve na minuto, gre v produkcijo in nenadoma obdela čakalno vrsto več tisoč dokumentov. Napake 429 se usujejo kot plaz in polovica obdelave je izgubljena, ker pretok ni bil predviden.
Sistem ravni
OpenAI organizira omejitve v ravni (stopnje) glede na vašo zgodovino obračunavanja. Ravni ne izberete sami; odklenete jo z zbiranjem porabe in čakanjem določenega časovnega okna. Ta napredek ima pomembno praktično posledico: račun, ustvarjen zgolj za demonstracijo stranki, ne bo imel enake zmogljivosti kot vaš produkcijski račun, čeprav je koda identična.
# Tiers determine your limits
# Tier 1: After first successful payment
# Tier 2: After $50 cumulative spend + 7 days
# Tier 3: After $100 cumulative spend + 7 days
# Tier 4: After $250 cumulative spend + 14 days
# Tier 5: After $1000 cumulative spend + 30 days
# Limits increase significantly with each tier
Vrste omejitev hitrosti
Hkrati veljajo trije števci in prvi, ki ga dosežete, vas blokira. Obdelava kratkih besedil bo nasičila RPM (zahteve na minuto) dolgo pred TPM (žetoni na minuto); nasprotno pa bo analiza dolgih dokumentov izčrpala TPM, čeprav ste poslali le nekaj deset zahtev. Pred določanjem stopnje vzporednosti vedno preverite red velikosti svojih pozivov.
# 1. RPM — Requests Per Minute
# 2. TPM — Tokens Per Minute
# 3. RPD — Requests Per Day
# Order of magnitude for Tier 3 (check your actual limits
# at platform.openai.com > Settings > Limits):
# RPM: 5,000 requests/minute
# TPM: 2,000,000 tokens/minute
# RPD: 10,000 requests/day
Branje glav omejitev hitrosti
Porabe vam ni treba ugibati: vsak odgovor jo nosi v svojih HTTP glavah. SDK jih privzeto skrije, da vrne le razčlenjen objekt, vendar vam with_raw_response omogoča dostop do surovega odgovora, parse() pa rekonstruira običajni objekt. Nadzorna plošča, napajana s temi vrednostmi, vas opozori, ko se približujete zgornji meji, namesto da bi to odkrili šele ob napaki.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Access headers via the raw HTTP response
# Using with_raw_response mode
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"RPM limit: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM remaining: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM limit: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM remaining: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Reset in: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Response: {response.output_text}")
Omejevanje hitrosti na strani odjemalca
Bolje je, da se sami upočasnite, kot da vas zavrnejo. Dve implementaciji pokrivata večino potreb.
Omejevanje pretoka s semaforjem
Prva kombinira semafor, ki omejuje število sočasnih klicev, z zamikom, izračunanim iz ciljnega pretoka. V primeru se petdeset povzetkov zažene hkrati, vendar jih le pet teče vzporedno, razmaknjenih z zamikom, ki ustreza 100 zahtevam na minuto. Klicna koda ostane preprost asyncio.gather: vsa disciplina je encapsulirana v razredu.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Limits the number of simultaneous requests."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Delay between each request
async def call(self, prompt: str) -> str:
async with self.semaphore:
await asyncio.sleep(self.delay)
response = await async_client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
return response.output_text
async def batch_processing():
limiter = RateLimiter(max_concurrent=5, rpm=100)
prompts = [f"Summarize concept {i}" for i in range(50)]
tasks = [limiter.call(p) for p in prompts]
results = await asyncio.gather(*tasks)
for i, r in enumerate(results):
print(f"Result {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Preprosto vedro žetonov
Vedro žetonov je bolj prilagodljivo, ker omogoča sunkovite obremenitve. Vedro se polni s stalno hitrostjo in prazni z vsakim klicem: če je vaša aplikacija minuto mirovala, lahko znova začne s polno hitrostjo za petdeset zahtev, nato pa se naravno vrne na hitrost polnjenja. To je točno obnašanje, ki ga želite za storitev, ki se izmenjuje med vrhunci in zatišji, in deluje v večnitnih okoljih zahvaljujoč zaklepu.
import time
import threading
class TokenBucket:
"""Rate limiter based on the token bucket algorithm."""
def __init__(self, tokens_per_second: float, max_capacity: int):
self.tokens_per_second = tokens_per_second
self.max_capacity = max_capacity
self.tokens = max_capacity
self.last_refill = time.monotonic()
self.lock = threading.Lock()
def wait(self, tokens_needed: int = 1):
"""Waits until enough tokens are available."""
while True:
with self.lock:
now = time.monotonic()
elapsed = now - self.last_refill
self.tokens = min(
self.max_capacity,
self.tokens + elapsed * self.tokens_per_second
)
self.last_refill = now
if self.tokens >= tokens_needed:
self.tokens -= tokens_needed
return
time.sleep(0.1)
# Usage: max 50 requests per minute
bucket = TokenBucket(tokens_per_second=50/60, max_capacity=50)
def limited_call(prompt: str) -> str:
bucket.wait(1)
response = client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
return response.output_text
Strategije za velike količine
1. Porazdelitev med več projektov
Vsak projekt ima svoje omejitve hitrosti. Če dosežete zgornjo mejo, čeprav ste že na visoki ravni, porazdelitev klicev med več projektov mehansko pomnoži razpoložljivo zmogljivost. Spodnji primer krožnega razporejanja (round-robin) ponazarja načelo; v produkciji premaknite cikel zunaj funkcije, da se ohrani med klici.
from openai import OpenAI
# Each project has its own rate limits
clients = [
OpenAI(project="proj-aaaa"), # Project 1
OpenAI(project="proj-bbbb"), # Project 2
OpenAI(project="proj-cccc"), # Project 3
]
def round_robin_call(prompt: str, clients: list) -> str:
"""Distributes calls across multiple projects."""
import itertools
client_cycle = itertools.cycle(clients)
client = next(client_cycle)
return client.responses.create(
model="gpt-5.6-terra",
input=prompt
).output_text
2. Uporaba pravega modela za pravo količino
Izbira modela je tudi odločitev o zmogljivosti, ne le o kakovosti. Pridržanje najtežjih modelov za kritične naloge in preusmeritev obsega na model z višjimi omejitvami sprosti pretok tam, kjer ga dejansko potrebujete.
# Economy models (gpt-5.6-luna) have the highest limits
# Use them for high-volume tasks
# The flagship model (gpt-5.6-sol) has the lowest limits
# Reserve it for critical tasks
3. Čakanje v vrsti
Nazadnje čakanje v vrsti loči proizvodnjo zahtev od njihove porabe. Ena nit odstranjuje elemente iz vrste s fiksnim tempom, medtem ko preostanek aplikacije prosto oddaja zahteve; klicalec blokira na dogodku, dokler ne prispe njegov rezultat. Ta vzorec absorbira vrhunce, ne da bi kdajkoli presegel konfigurirani pretok.
import queue
import threading
class APIQueue:
"""Queue for API calls."""
def __init__(self, rpm: int = 100):
self.queue = queue.Queue()
self.delay = 60.0 / rpm
self.running = True
self.worker = threading.Thread(target=self._process, daemon=True)
self.worker.start()
def _process(self):
while self.running:
try:
prompt, future = self.queue.get(timeout=1)
response = client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
future["result"] = response.output_text
future["event"].set()
time.sleep(self.delay)
except queue.Empty:
continue
def submit(self, prompt: str) -> str:
future = {"result": None, "event": threading.Event()}
self.queue.put((prompt, future))
future["event"].wait()
return future["result"]
Ključne ugotovitve
- Omejitve hitrosti veljajo hkrati za RPM, TPM in RPD
- Vaša raven določa vaše omejitve – povečuje se z vašo kumulativno porabo
- Berite glave
x-ratelimit-*, da v realnem času poznate svojo porabo - Implementirajte omejevalnik hitrosti na strani odjemalca, da se izognete napakam 429
- Za velike količine porazdelite obremenitev med projekte
- Luna ponuja najvišje omejitve hitrosti za obsežno obdelavo