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

Batch API un ražošanas kontrolsaraksts

Nodarbība 12 no 12 Atjaunota 2026. gada 2. novembris Augstākais
Šajā lapā
  1. Batch API alternatīva: 20 % ietaupījums tokenos
  2. Pieeju salīdzinājums
  3. Ražošanas kontrolsaraksts
  4. Ieteicamā arhitektūra
  5. Galvenās atziņas
  6. Pārbaudi savas zināšanas

Batch API alternatīva: 20 % ietaupījums tokenos

Ja reāllaika apstrāde nav obligāta prasība, xAI Batch API piedāvā 20 % atlaidi visiem tokeniem atbilstošajiem teksta modeļiem (no grok-4.3 līdz grok-4.7, sākot no 2026. gada 2. novembra, saskaņā ar xAI batch cenrādi). Pieteikumu vietā, lai sūtītu pieprasījumus pa vienam un pārvaldītu vienlaicīgumu, tu iesniedz savus pieprasījumus partijās, izmantojot API vai JSONL failu, un iegūsti rezultātus, tiklīdz apstrāde ir pabeigta — parasti 24 stundu laikā. Batch pieprasījumi netiek ieskaitīti ātruma ierobežojumos. Kurss Batch API: Lielapjoma apstrāde detalizēti apraksta šo darba plūsmu.

Kad izmantot Batch API

  • Produktu katalogu apstrāde (tūkstošiem aprakstu)
  • Atbalsta biļešu lielapjoma klasifikācija
  • Kopsavilkumu ģenerēšana dokumentu bāzei
  • Jebkurš uzdevums, kurā vairāku stundu aizkave ir pieņemama

Kad palikt pie klasiskā Async

  • Interaktīvs čatbots (reāllaika atbilde)
  • Caurplūde, kurā katrs solis ir atkarīgs no iepriekšējā
  • Reāllaika uzraudzība un brīdinājumi
  • Jebkurš gadījums, kurā Batch API aizkave ir nepieņemama

Pieeju salīdzinājums

Kritērijs Async + Semaphore Batch API
Izmaksas Standarta tarifs -20 % tokeniem atbilstošajiem modeļiem
Latence Sekundes līdz minūtēm Minūtes līdz stundām
Kontrole Reāllaiks, tūlītējas kļūdas Rezultāti, tiklīdz apstrāde pabeigta, kļūdas katram pieprasījumam atsevišķi
Sarežģītība Semaphore, atkārtoti mēģinājumi ar eksponenciālu pauzi, gather Pieprasījumu partija vai JSONL fails, skaitītāja izsekošana
Ātruma ierobežojumi Pakļauti RPM/TPM Pārvalda xAI

Ražošanas kontrolsaraksts

Pirms asinhrono pieprasījumu sistēmas izvietošanas ražošanas vidē, pārbaudi katru šī saraksta punktu:

Konfigurācija

  • Noildze ir iestatīta uz 3600 sekundēm spriešanas modeļiem
  • Semaphore ir pielāgots taviem faktiskajiem ātruma ierobežojumiem (nevis aplēsēm)
  • Ir ieviesta eksponenciāla pauze ar nejaušību (jitter) 429 kļūdām
  • API atslēgas tiek ielādētas no vides mainīgajiem, nekad nav iekodētas kodā
  • Galvene x-grok-conv-id tiek izmantota daudzpakāpju sarunām

Kļūdu apstrāde

  • Funkcijā asyncio.gather tiek izmantots return_exceptions=True, lai izolētu kļūdas
  • 429, noildzes un savienojuma kļūdas izraisa atkārtotu mēģinājumu
  • Nederīgu pieprasījumu kļūdas (BadRequestError) neizraisa atkārtotu mēģinājumu
  • Neizdevušies pieprasījumi tiek identificēti un var tikt atkārtoti
  • Žurnālos tiek iekļauts kļūdas veids, mēģinājuma numurs un atkārtota mēģinājuma aizture

Uzraudzība

  • Patērēto tokenu skaits tiek izsekots, izmantojot response.usage
  • Kešatmiņas trāpījumu koeficients tiek mērīts, lai validētu x-grok-conv-id izmantošanu
  • Izmaksas tiek aplēstas reāllaikā, izmantojot cost_in_usd_ticks
  • Atlikušie ātruma ierobežojumi tiek uzraudzīti, lai dinamiski pielāgotu semaphore

Veiktspēja

  • Lielākām par 100 pieprasījumiem partijām tiek izmantota sadalīšana gabalos (chunking)
  • Starprezultāti tiek saglabāti starp apakšpartijām
  • Ilgi darbojošiem uzdevumiem tiek attēlots progress
  • Semaphore tiek pielāgots, pamatojoties uz izmantoto modeli (spriešana = zemāks)

Drošība

  • API atslēgas netiek eksponētas žurnālos vai kļūdu ziņojumos
  • Atbildes, kas satur sensitīvus datus, tiek apstrādātas operatīvajā atmiņā, nevis rakstītas diskā
  • Attālinātā krātuve (store_messages) ir atspējota konfidenciāliem datiem
  • use_encrypted_content ir iespējots, ja nepieciešama spriešanas konfidencialitāte

Ieteicamā arhitektūra

import os
import asyncio
import uuid
from asyncio import Semaphore
from openai import AsyncOpenAI, RateLimitError, APITimeoutError
import httpx

class GrokAsyncProcessor:
    def __init__(self, max_concurrent: int = 5):
        self.client = AsyncOpenAI(
            api_key=os.getenv("XAI_API_KEY"),
            base_url="https://api.x.ai/v1",
            timeout=httpx.Timeout(3600.0)
        )
        self.sem = Semaphore(max_concurrent)
        self.conv_id = str(uuid.uuid4())

    async def request(self, prompt: str, max_retries: int = 5) -> str:
        async with self.sem:
            for attempt in range(max_retries):
                try:
                    response = await self.client.chat.completions.create(
                        model="grok-4.5",
                        messages=[{"role": "user", "content": prompt}],
                        extra_headers={"x-grok-conv-id": self.conv_id}
                    )
                    return response.choices[0].message.content
                except RateLimitError:
                    if attempt == max_retries - 1:
                        raise
                    await asyncio.sleep(2 ** attempt)
                except APITimeoutError:
                    if attempt == max_retries - 1:
                        raise
                    await asyncio.sleep(2 ** attempt)

    async def batch(self, prompts: list[str]) -> list[str | Exception]:
        tasks = [self.request(p) for p in prompts]
        return await asyncio.gather(*tasks, return_exceptions=True)

Šī klase apkopo visus šajā kursā aplūkotos modeļus: asinhrons klients, semaphore, eksponenciāla pauze, kešatmiņa un kļūdu apstrāde. Tā nodrošina stabilu sākumpunktu taviem ražošanas projektiem.

Galvenās atziņas

  • Batch API piedāvā 20 % atlaidi atbilstošajiem modeļiem, taču uzliek apstrādes aizkavi
  • Izvēlies starp reāllaika async un batch, pamatojoties uz savām latences prasībām
  • Ražošanas kontrolsaraksts aptver konfigurāciju, kļūdas, uzraudzību, veiktspēju un drošību
  • Klase GrokAsyncProcessor apkopo visus kursa modeļus vienā abstrakcijā
  • Vienmēr testē savu konfigurāciju ar nelielu partiju pirms lielapjoma apstrādes uzsākšanas

Pārbaudi savas zināšanas

Async, ierobežojumi, kešatmiņa: ražošanas modeļi piecos jautājumos.

1. Kad async ir pārāks par sync?

Atbilde: Vienmēr, kad apstrādā vairākus neatkarīgus pieprasījumus: AsyncClient (vai AsyncOpenAI) pārklāj tīkla gaidīšanas laikus — caurlaidība pieaug, nepalielinot pavedienu skaitu.

2. Kā apstrādāt partiju, nesaskaroties ar ierobežojumiem?

Atbilde: asyncio.gather paralēlismam, semaphore vienlaicīgu pieprasījumu ierobežošanai un eksponenciāla pauze HTTP 429 gadījumā — ievērojot konsoles RPM/TPM ierobežojumus.

3. Kā mērogā apstrādāt daudzpakāpju kontekstu?

Atbilde: Izmantojot servera puses atbilžu glabāšanu un atkārtoti izmantotu šifrētu spriešanu — stāvoklis atrodas API pusē, tavs kods tikai izseko identifikatorus.

4. Kas jāzina par kešatmiņu un noildzēm?

Atbilde: Sarunu kešatmiņa (x-grok-conv-id) paātrina turpinātās pavedienus, un spriešanas pieprasījumiem ir nepieciešamas pielāgotas noildzes — divi iestatījumi, kas transformē ražošanu.

5. Ko satur kursa ražošanas kontrolsaraksts?

Atbilde: Apgūts async, ievēroti ierobežojumi (semaphore + eksponenciāla pauze), batch aukstam apjomam, konfigurētas noildzes un atkārtoti mēģinājumi, izsekotas izmaksas — robustums kā kontrolsaraksts.

Ierobežota vienlaicīgums, plānotas kļūmes, servera puses stāvoklis: async modeļi pārvērš tavus skriptus servisos — noslēdzošais kontrolsaraksts tos nostiprina.