Ierobežojumi, kvotas un līmeņi
Šajā lapā
Ierobežojumi, kvotas un līmeņi
Ierobežojumi nosaka, cik daudz pieprasījumu vari nosūtīt uz API minūtē. Šo limitu izpratne un pārvaldība ir kritiski svarīga, lai izvairītos no pakalpojumu pārtraukumiem darbvidē. Sliktākais scenārijs vienmēr ir vienāds: integrācija, kas izstrādes posmā darbojās nevainojami, nosūtot trīs pieprasījumus minūtē, tiek palaista ražošanā un pēkšņi sāk apstrādāt vairāku tūkstošu dokumentu rindu. 429 kļūdas uzbrūk lavīnveidīgi, un puse no apstrādes tiek zaudēta, jo caurlaidspēja netika paredzēta.
Līmeņu sistēma
OpenAI sadala ierobežojumus līmeņos, pamatojoties uz tava rēķinu vēsturi. Tu neizvēlies savu līmeni; tu to atbloķē, uzkrājot izdevumus un sagaidot noteiktu laika periodu. Šai progresijai ir svarīgas praktiskas sekas: kontam, kas izveidots tikai klienta demonstrācijai, nebūs tādas pašas jaudas kā tava ražošanas kontam, pat ja kods ir identisks.
# Līmeņi nosaka tavus ierobežojumus
# 1. līmenis: Pēc pirmā veiksmīgā maksājuma
# 2. līmenis: Pēc 50 USD kopējo izdevumu + 7 dienām
# 3. līmenis: Pēc 100 USD kopējo izdevumu + 7 dienām
# 4. līmenis: Pēc 250 USD kopējo izdevumu + 14 dienām
# 5. līmenis: Pēc 1000 USD kopējo izdevumu + 30 dienām
# Ierobežojumi ievērojami pieaug ar katru līmeni
Ierobežojumu veidi
Vienlaicīgi darbojas trīs skaitītāji, un pirmais, kuru sasniedz, tevi bloķē. Īsu tekstu apstrāde noslogos RPM (pieprasījumi minūtē) daudz ātrāk nekā TPM (tokeni minūtē); turpretī garu dokumentu analīze iztērēs TPM, pat ja esi nosūtījis tikai dažus desmitus pieprasījumu. Vienmēr pārbaudi savu uzdevumu apjomu, pirms plāno paralēlo izpildi.
# 1. RPM — Pieprasījumi minūtē (Requests Per Minute)
# 2. TPM — Tokeni minūtē (Tokens Per Minute)
# 3. RPD — Pieprasījumi dienā (Requests Per Day)
# Aptuvenās vērtības 3. līmenim (pārbaudi savus faktiskos
# ierobežojumus vietnē platform.openai.com > Settings > Limits):
# RPM: 5000 pieprasījumi/minūtē
# TPM: 2 000 000 tokeni/minūtē
# RPD: 10 000 pieprasījumi/dienā
Ierobežojumu galvenes nolasīšana
Tev nav jāminē tavs patēriņš: katra atbilde to satur savās HTTP galvenēs. SDK tās pēc noklusējuma slēpj, lai atgrieztu tikai parsētu objektu, taču with_raw_response dod piekļuvi neapstrādātai atbildei, bet parse() atjauno parasto objektu. Mijiedarbības panelis, kas barots ar šīm vērtībām, brīdinās tevi, tuvojoties griestiem, nevis ļaus to uzzināt tikai caur kļūdu.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Piekļuve galvenēm, izmantojot neapstrādātu HTTP atbildi
# Izmantojot with_raw_response režīmu
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"RPM limits: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM atlikuši: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM limits: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM atlikuši: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Atjaunošana pēc: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Atbilde: {response.output_text}")
Klienta puses ierobežošana
Labāk ir pašam sevi palēnināt, nekā tikt noraidītam. Divas implementācijas sedz lielāko daļu vajadzību.
Caurlaidspējas ierobežošana ar semaforu
Pirmā metode apvieno semaforu, kas ierobežo vienlaicīgo izsaukumu skaitu, ar kavējumu, kas aprēķināts no mērķa caurlaidspējas. Piemērā piecdesmit kopsavilkumi tiek uzsākti vienlaicīgi, bet tikai pieci norisinās paralēli, atdalīti ar kavējumu, kas atbilst 100 pieprasījumiem minūtē. Izsaucošais kods paliek vienkāršs asyncio.gather: visa disciplīna ir iekapsulēta klasē.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Ierobežo vienlaicīgo pieprasījumu skaitu."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Kavējums starp katru pieprasījumu
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"Apkopojiet koncepciju {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"Rezultāts {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Vienkāršs tokena spainis
Tokena spainis ir elastīgāks, jo tas ļauj veikt īslaicīgus uzplūdus. Spainis piepildās ar nemainīgu ātrumu un iztukšojas ar katru izsaukumu: ja tava lietotne minūti ir bijusi dīkstāvē, tā var atsākt darbību ar pilnu ātrumu piecdesmit pieprasījumiem, pēc tam dabiski atgriežoties pie piepildīšanās ātruma. Tieši tāda uzvedība ir vēlama servisam, kurš mainās starp slodzes virsotnēm un klusuma brīžiem, un tas darbojas daudz pavedienu vidēs, pateicoties slēdzenei.
import time
import threading
class TokenBucket:
"Ierobežotājs, kas balstīts uz tokena spaiņa algoritmu."
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):
"""Gaida, līdz ir pieejami pietiekami tokeni."""
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)
# Lietojums: maksimāli 50 pieprasījumi minūtē
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
Stratēģijas lieliem apjomiem
1. Sadalīšana starp vairākiem projektiem
Katram projektam ir savi ierobežojumi. Ja sasniedz savus griestus, jau esot augstā līmenī, pieprasījumu sadalīšana starp vairākiem projektiem mehāniski reizina pieejamo jaudu. Tālāk redzamais „round-robin” cikls ilustrē principu; ražošanas vidē pārvieto ciklu ārpus funkcijas, lai tas saglabātos starp izsaukumiem.
from openai import OpenAI
# Katram projektam ir savi ierobežojumi
clients = [
OpenAI(project="proj-aaaa"), # 1. projekts
OpenAI(project="proj-bbbb"), # 2. projekts
OpenAI(project="proj-cccc"), # 3. projekts
]
def round_robin_call(prompt: str, clients: list) -> str:
"""Sadalīt izsaukumus starp vairākiem projektiem."""
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. Pareizā modeļa izvēle pareizajam apjomam
Modeļa izvēle ir arī jaudas lēmums, ne tikai kvalitātes jautājums. Rezervējot smagākos modeļus kritiskiem uzdevumiem un novirzot lielos apjomus uz modeli ar augstākiem ierobežojumiem, tu atbrīvo caurlaidspēju tur, kur tā tiešām nepieciešama.
# Ekonomijas modeļiem (gpt-5.6-luna) ir visaugstākie ierobežojumi
# Izmanto tos liela apjoma uzdevumiem
# Flagmanim modelim (gpt-5.6-sol) ir viszemākie ierobežojumi
# Rezervē to kritiskiem uzdevumiem
3. Rindu izmantošana
Visbeidzot, rindu izmantošana atdala pieprasījumu ģenerēšanu no to apstrādes. Viens pavediens izņem datus no rindas noteiktā tempā, kamēr pārējā lietotne iesniedz datus brīvi; izsauktājs bloķējas uz notikumu, līdz tiek saņemts rezultāts. Šis modelis absorbē slodzes virsotnes, nekad nepārsniedzot konfigurēto caurlaidspēju.
import queue
import threading
class APIQueue:
"Rinda API izsaukumiem."
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"]
Galvenās atziņas
- Ierobežojumi darbojas vienlaicīgi RPM, TPM un RPD izteiksmē
- Tavs līmenis nosaka tavus ierobežojumus — tas pieaug, palielinoties kopējiem izdevumiem
- Lasī
x-ratelimit-*galvenes, lai reāllaikā zinātu savu patēriņu - Implementē klienta puses ierobežotāju, lai izvairītos no 429 kļūdām
- Sadali slodzi starp projektiem lieliem apjomiem
- Luna piedāvā visaugstākos ierobežojumus liela apjoma apstrādei