Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Ierobežojumi, kvotas un līmeņi

Nodarbība 13 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Ierobežojumi, kvotas un līmeņi
  2. Līmeņu sistēma
  3. Ierobežojumu veidi
  4. Ierobežojumu galvenes nolasīšana
  5. Klienta puses ierobežošana
  6. Stratēģijas lieliem apjomiem
  7. Galvenās atziņas

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