Alapmodell API-k korlátozásai és kvótái

Ez a lap a Databricks Foundation modell API-k számítási feladataira vonatkozó korlátokat és kvótákat ismerteti.

A Databricks Foundation modell API-k sebességkorlátokat kényszerítenek ki a megbízható teljesítmény és a tisztességes erőforrás-kiosztás biztosítása érdekében minden felhasználó számára. Ezek a korlátok a munkaterület platformszintjétől, az alapmodell típusától és az alapmodell üzembe helyezésének módjától függően változnak.

Token-alapú végpont sebességkorlátjai

A jogkivonatonkénti fizetés végpontjait jogkivonatalapú és lekérdezésalapú díjkorlátok szabályozzák. A jogkivonatalapú sebességkorlátok a percenként feldolgozható és a bemeneti és kimeneti jogkivonatok esetében külön kikényszeríthető jogkivonatok maximális számát szabályozzák.

  • Bemeneti jogkivonatok percenként (ITPM):A legfeljebb 60 másodperces ablakban feldolgozható bemeneti jogkivonatok száma (a parancssorból). Egy ITPM-sebességkorlát szabályozza a végpont bemeneti tokenjének átviteli sebességét.
  • Kimeneti jogkivonatok percenként (OTPM): A 60 másodperces ablakban létrehozható kimeneti jogkivonatok maximális száma (a modell válaszaiból). Egy OTPM-sebességkorlát szabályozza a végpont kimeneti tokenjének átviteli sebességét.
  • Lekérdezések óránként: A legfeljebb 60 perces időtartamon belül feldolgozható lekérdezések vagy kérések száma. A tartós használati mintákkal rendelkező éles alkalmazások esetében a Databricks olyan kiépített átviteli sebességű végpontokat javasol, amelyek garantált kapacitást biztosítanak.

A korlátok nyomon követése és érvényesítése

A legkorlátozóbb sebességkorlát (ITPM, OTPM, QPH) bármikor érvényes. Ha például még nem érte el az ITPM-korlátot, akkor is korlátozott lehet a sebesség, ha túllépi a QPH- vagy OTPM-korlátot. Az ITPM- vagy OTPM-korlát elérésekor a későbbi kérések 429-ben hibaüzenetet kapnak, amely azt jelzi, hogy túl sok kérés érkezett. Ez az üzenet mindaddig megmarad, amíg a sebességkorlát ablaka vissza nem áll.

A Databricks nyomon követi és érvényesíti a tokenek percenkénti (TPM) korlátjait az alábbi funkciók használatával:

Tulajdonság Részletek
Token könyvelése és a belépés előtti ellenőrzések
  • Bemeneti tokenek számlálása: A bemeneti tokeneket a rendszer a tényleges kéréskor számítja ki.
  • Kimeneti jogkivonat becslése: Ha a kérésben megadja max_tokens , a Databricks ezt az értéket használja a kimeneti jogkivonat kapacitásának becslésére és lefoglalására, mielőtt a kérelem feldolgozásra engedélyezve lenne.
  • Belépés előtti ellenőrzés: A Databricks ellenőrzi, hogy a kérés túllépné-e az ITPM- vagy OTPM-korlátot a feldolgozás megkezdése előtt. Ha max_tokens túllépné az OTPM-korlátokat, a Databricks azonnal elutasítja a kérést egy 429-s hibával.
  • Tényleges és becsült kimenet: A válasz létrehozása után a rendszer megszámolja a tényleges kimeneti jogkivonatokat. Fontos, hogy ha a tényleges tokenhasználat kisebb, mint a fenntartott max_tokens, a Databricks a különbséget visszatéríti a sebességkorlát-kerethez, így ezek a tokenek azonnal elérhetők más kérések számára.
  • Nincs megadva max_tokens: Ha nem adja meg max_tokens, a Databricks alapértelmezett foglalást használ, és a tényleges tokenek száma a létrehozás után kerül egyeztetésre. Megjegyzés: A Claude Sonnet 4 alapértelmezés szerint 1000 kimeneti tokent használ, ha max_tokens nincs beállítva, visszaadva a "hossz" befejezési okot, amikor elérte. Ez nem a modell maximális környezethossza.
Kipukkadt kapacitás és simítás
  • Burst buffer: A sebességkorlátozó tartalmaz egy kis puffert, amely a névleges sebességnél nagyobb rövid forgalomkitöréseket képes kezelni.
  • Tolóablak: A tokenhasználatot egy olyan tolóablak-algoritmus követi nyomon, amely egyenletesebb sebességkorlátozást biztosít, mint a percenkénti kemény határok.
  • Token-vödör algoritmus: A Databricks egy olyan token-vödör implementációt használ, amely lehetővé teszi a kitörési kapacitást, miközben fenntartja az átlagos sebességkorlátozást idővel.

Az alábbiakban egy példa látható a felvétel előtti ellenőrzés és a jóváírási viselkedés működésére.

# Request with max_tokens specified
request = {
    "prompt": "Write a story about...",  # 10 input tokens
    "max_tokens": 500  # System reserves 500 output tokens
}

# Pre-admission check:
# - Verifies 10 tokens against ITPM limit
# - Reserves 500 tokens against OTPM limit
# - If either would exceed limits, returns 429 immediately

# If admitted, actual response uses only 350 tokens
# The system credits back 150 tokens (500 - 350) to your OTPM allowance
# These 150 tokens are immediately available for other requests

Kiosztási korlátok modell szerint

Az alábbi táblázatok összefoglalják a nagyvállalati szintű munkaterületekhez tartozó pay-per-token Foundation Model API-végpontok ITPM-, OTPM- és QPH-díjkorlátjait:

Megjegyzés:

Azoknál a modelleknél, amelyek támogatják a provisioned áteresztőképességet, hozz létre egy provisioned áteresztőképességi végpontot , ha a token-alapú fizetős korlátok nem felelnek meg az igényeidnek.

Nagy nyelvi modellek ITPM-korlát OTPM-korlát QPH-korlát
Gemini 3.1 Flash Lite 200,000 20,000 360 000
Qwen3.5 122B A10B (nyilvános előzetes verzió) 1,000,000 100,000 360 000
Qwen3-Next 80B A3B Instruct (bétaverzió) 1,000,000 100,000 360 000
GPT OSS 120B 1,000,000 100,000 360 000
GPT OSS 20B 1,000,000 100,000 360 000
Gemma 3 12B 1,000,000 100,000 360 000
Láma 4 Maverick 1,000,000 100,000 360 000
Llama 3.3 70B Utasítás 1,000,000 100,000 360 000
Láma 3.1 8B utasítás 1,000,000 100,000 360 000
Antropikus Claude-modellek ITPM-korlát OTPM-korlát QPH-korlát
Claude Fabel 5 200,000 20,000 360 000
Claude Haiku 4.5 200,000 20,000 360 000
Claude Opus 5 200,000 20,000 360 000
Claude Opus 4.8 200,000 20,000 360 000
Claude Opus 4.7 200,000 20,000 360 000
Claude Opus 4.6 200,000 20,000 360 000
Claude Opus 4.5 200,000 20,000 360 000
Claude Opus 4.1 200,000 20,000 360 000
Claude Sonnet 5 200,000 20,000 360 000
Claude Sonnet 4.6 200,000 20,000 360 000
Claude Sonnet 4.5 200,000 20,000 360 000
Claude Szonett 4 200,000 20,000 360 000
Modellek beágyazása ITPM-korlát OTPM-korlát QPH-korlát
Qwen3-Embedding-0.6B N/A N/A 2,160,000
GTE Nagy (En) N/A N/A 540 000
BGE Large (en) N/A N/A 2,160,000

Ajánlott eljárások a TPM-sebességkorlátok kezeléséhez

1. lépés. Token használatának figyelése

A bemeneti és kimeneti jogkivonatok számának nyomon követése külön-külön az alkalmazásokban:

# Example: Track token usage
response = model.generate(prompt)
input_tokens = response.usage.prompt_tokens
output_tokens = response.usage.completion_tokens
total_tokens = response.usage.total_tokens

# Check against limits
if input_tokens > ITPM_LIMIT or output_tokens > OTPM_LIMIT:
    # Implement backoff strategy
    pass

2. lépés. Újrapróbálkozás logikája implementálása

Adjon hozzá exponenciális visszalépést, ha sebességkorlátozási hibákba ütközik:

import time
import random

def retry_with_exponential_backoff(
    func,
    initial_delay: float = 1,
    exponential_base: float = 2,
    jitter: bool = True,
    max_retries: int = 10,
):
    """Retry a function with exponential backoff."""

    num_retries = 0
    delay = initial_delay

    while num_retries < max_retries:
        try:
            return func()
        except Exception as e:
            if "rate_limit" in str(e) or "429" in str(e):
                num_retries += 1

                if jitter:
                    delay *= exponential_base * (1 + random.random())
                else:
                    delay *= exponential_base

                time.sleep(delay)
            else:
                raise e

    raise Exception(f"Maximum retries {max_retries} exceeded")

3. lépés. Tokenhasználat optimalizálása

  • A parancssor hosszának minimalizálása: Tömör, jól strukturált kérések használata
  • A kimenet hosszának szabályozása: Paraméter használata max_tokens a válaszméret korlátozásához
  • Max_tokens beállítása kifejezetten a Claude Sonnet 4 esetében: Mindig adja meg max_tokens a Claude Sonnet 4 használatakor az alapértelmezett 1000 tokenkorlát elkerülése érdekében
  • Batch hatékonyan: Csoportosítsa a kapcsolódó kéréseket, ha lehetséges, a korlátokon belül maradva

4. lépés. Fontolja meg a modell kiválasztását

  • Kisebb modellek nagy volumenű feladatokhoz: Használj olyan modelleket, mint a GPT OSS 20B olyan feladatokhoz, amelyek nagyobb áteresztőképességet igényelnek.
  • Nagy modellek összetett feladatokhoz: Fenntartsd a GPT OSS 120B-t olyan feladatokra, amelyek maximális képességet igényelnek.

Figyelés és hibaelhárítás

Monitorozza a tokenhasználati mintákat a teljesítmény optimalizálása érdekében:

# Example: Log token usage for monitoring
import logging

logger = logging.getLogger(__name__)

def log_token_usage(response):
    usage = response.usage
    logger.info(f"Input tokens: {usage.prompt_tokens}")
    logger.info(f"Output tokens: {usage.completion_tokens}")
    logger.info(f"Total tokens: {usage.total_tokens}")

    # Alert if approaching limits
    if usage.prompt_tokens > ITPM_LIMIT * 0.8:
        logger.warning("Approaching ITPM limit")
    if usage.completion_tokens > OTPM_LIMIT * 0.8:
        logger.warning("Approaching OTPM limit")

Sebességkorlát hibáinak kezelése

Ha túllépi a sebességkorlátokat, az API hibát 429 Too Many Requests ad vissza:

{
  "error": {
    "message": "Rate limit exceeded: ITPM limit of 200,000 tokens reached",
    "type": "rate_limit_exceeded",
    "code": 429,
    "limit_type": "input_tokens_per_minute",
    "limit": 200000,
    "current": 200150,
    "retry_after": 15
  }
}

A hibaválasz a következőket tartalmazza:

  • limit_type: Melyik korlátot lépték túl (ITPM, OTPM, QPS vagy QPH)
  • limit: A konfigurált korlátérték
  • current: Az Aktuális használat
  • retry_after: Javasolt várakozási idő másodpercben

Gyakori problémák és megoldások

Probléma Solution
Gyakori 429-hibák Exponenciális visszalépés implementálása, a kérelmek sebességének csökkentése és magasabb sebességkorlátok kérése
Elérte az ITPM korlátját A parancssor hosszának optimalizálása
Elérte az OTPM korlátját A max_tokens válasz hosszának korlátozása
Elérte a QPH-korlátot Kérelmek egyenletesebb elosztása az idő függvényében

Kiosztott átviteli sebesség korlátai

A magasabb korlátokat igénylő termelési munkaterhelések esetében a kiépített átviteli sebesség végpontjai a következőket kínálják:

  • Nincs TPM-korlátozás: Kapacitás feldolgozása kiépített erőforrások alapján
  • Magasabb sebességkorlátok: Munkaterületenként másodpercenként legfeljebb 200 lekérdezés
  • Kiszámítható teljesítmény: A dedikált erőforrások konzisztens késést biztosítanak

Kimeneti token limitek

Az alábbi táblázat az egyes támogatott modellek kimeneti jogkivonat-korlátait foglalja össze:

Model Kimeneti token korlát
GPT OSS 120B 25,000
GPT OSS 20B 25,000
Gemma 3 12B 8,192
Láma 4 Maverick 8,192
LLaMA 3.1 70B 8,192
Llama 3.1 8B 8,192

További korlátok

A kiosztott átviteli kapacitás munkaélataira vonatkozó korlátozások a következők:

  • A Meta Llama-modell system.ai Unity Catalogban való üzembe helyezéséhez ki kell választania a vonatkozó Instruct-verziót . A Meta Láma-modellek alapverziói nem támogatottak a Unity Catalogból való üzembe helyezéshez. Lásd a kiépített átviteli sebesség végpontjainak üzembe helyezését.
  • A Llama 4 Mavericket használó kiosztott átviteli sebesség számítási feladatai esetén:
    • A kiosztott átviteli sebesség számítási feladatainak támogatása nyilvános előzetes verzióban érhető el.
    • Az automatikus skálázás nem támogatott.
    • A metrikák panelja nincs támogatva.
    • A forgalom felosztása nem támogatott a Llama 4 Mavericket kiszolgáló végponton. A Llama 4 Mavericket kiszolgáló végponton nem lehet több modellt kiszolgálni.

Regionális rendelkezésre állás és adatfeldolgozás

A Databricks által üzemeltetett alapmodell-régió rendelkezésre állását lásd: Alapmodell áttekintése.

Az adatfeldolgozásról és a tartózkodási helyről további információt az adatfeldolgozás és a tartózkodási hely című témakörben talál.

Alapmodellek és külső modellek erőforrás- és hasznos adatkorlátai

Az alábbi táblázatok összefoglalják az alapmodelleket és külső modelleket kiszolgáló végpontok erőforrás- és hasznos adatkorlátjait.

Tulajdonság Részletesség Limit
Hasznos teher mérete Kérelmenként 4 MB
Kérelem/válasz mérete Kérelmenként Az 1 MB-nál nagyobb kérések/válaszok nem lesznek naplózva.
Lekérdezések másodpercenként (QPS) Munkaterületenként 200
Modell végrehajtási időtartama Kérelmenként 597 másodperc
Többletterhelés késése Kérelmenként Kevesebb mint 50 ezredmásodperc

További erőforrások

  • Last updated on