Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Batch API ja tuotantotarkistuslista

Oppitunti 12 / 12 Päivitetty 2. marraskuuta 2026 Edistynyt
Tällä sivulla
  1. Batch API -vaihtoehto: 20 % alennus tokeneista
  2. Lähestymistapojen vertailu
  3. Tuotantotarkistuslista
  4. Suositeltu arkkitehtuuri
  5. Keskeiset asiat
  6. Testaa tietämyksesi

Batch API -vaihtoehto: 20 % alennus tokeneista

Kun reaaliaikainen käsittely ei ole pakollista, xAI:n Batch API tarjoaa 20 % alennuksen kaikista tokeneista tukikelpoisissa tekstimalleissa (grok-4.3:sta grok-4.7:ään 2. marraskuuta 2026 alkaen xAI:n batch-hinnoittelun mukaan). Pyyntöjen lähettämisen sijaan yksi kerrallaan ja samanaikaisuuden hallinnan sijaan lähetät pyyntösi erissä API:n kautta tai JSONL-tiedostona, ja haet tulokset käsittelyn valmistuessa – yleensä 24 tunnin kuluessa. Batch-pyynnöt eivät kuluta kiintiöitä. Kurssi Batch API: Bulk Processing käy läpi työnkulun yksityiskohtaisesti.

Milloin käyttää Batch API:a

  • Tuoteluetteloiden käsittely (tuhansia kuvauksia)
  • Tukipyyntöjen massaluokittelu
  • Yhteenvetojen generointi dokumenttikannalle
  • Mikä tahansa tehtävä, jossa muutaman tunnin viive on hyväksyttävä

Milloin pysyä klassisessa Async-mallissa

  • Interaktiivinen chatbot (reaaliaikainen vaste)
  • Putki, jossa jokainen vaihe riippuu edellisestä
  • Reaaliaikainen valvonta ja hälytykset
  • Mikä tahansa tapaus, jossa Batch API:n viive on mahdoton hyväksyä

Lähestymistapojen vertailu

Kriteeri Async + Semaphore Batch API
Kustannus Normaali hinta -20 % tokeneista tukikelpoisissa malleissa
Viive Sekunteja minuutteihin Minuutteja tunteihin
Kontrolli Reaaliaikainen, välittömät virheet Tulokset käsittelyn valmistuessa, pyyntökohtaiset virheet
Monimutkaisuus Semaphore, backoff, gather Pyyntöerä tai JSONL-tiedosto, laskurin seuranta
Kiintiöt RPM/TPM:n alainen xAI hallinnoi

Tuotantotarkistuslista

Ennen kuin otat asynkronisen pyyntöjärjestelmäsi käyttöön tuotannossa, käy läpi jokainen kohta tällä listalla:

Konfiguraatio

  • Aikakatkaisu on asetettu 3600 sekuntiin päättelymalleille
  • Semaphore on mitoitettu todellisten kiintiöidesi perusteella (ei arvioiden)
  • Eksponentiaalinen backoff on toteutettu jitterillä 429-virheille
  • API-avaimet ladataan ympäristömuuttujista, ei koskaan kovakoodattuina koodiin
  • x-grok-conv-id-otsikkoa käytetään monivaiheisiin keskusteluihin

Virheenkäsittely

  • return_exceptions=True käytetään funktiossa asyncio.gather virheiden eristämiseksi
  • 429-, aikakatkaisu- ja yhteysvirheet laukaisevat uudelleenyrityksen
  • Virheelliset pyyntövirheet (BadRequestError) eivät laukaise uudelleenyritystä
  • Epäonnistuneet pyynnöt tunnistetaan ja ne voidaan yrittää uudelleen Lokit sisältävät virhetyypin, yrityskerran numeron ja uudelleenyrityksen viiveen

Valvonta

  • Kulutettujen tokenien määrä seurataan kentän response.usage kautta
  • Välimuistin osumaprosentti mitataan x-grok-conv-id-käytön validoimiseksi
  • Kustannukset estimoidaan reaaliajassa käyttäen cost_in_usd_ticks
  • Jäljellä olevia kiintiöitä valvotaan semaphoren dynaamiseksi säätämiseksi

Suorituskyky

  • Paloitelua (chunking) käytetään yli 100 pyynnön erille
  • Välitulokset tallennetaan osierien välillä
  • Edistymistä näytetään pitkään kestäville töille
  • Semaphore säädetään käytetyn mallin perusteella (päättely = matalampi)

Tietoturva

  • API-avaimia ei paljasteta lokeissa tai virheilmoituksissa
  • Arkaluonteista dataa sisältävät vastaukset käsitellään muistissa, ei kirjoiteta levylle
  • Etätallennus (store_messages) on poistettu käytöstä luottamukselliselle datalle
  • use_encrypted_content on käytössä, kun päättelyn luottamuksellisuus vaaditaan

Suositeltu arkkitehtuuri

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)

Tämä luokka kapseloi kaikki tällä kurssilla käydyt mallit: asynkroninen asiakas, semaphore, backoff, välimuisti ja virheenkäsittely. Se tarjoaa vankan lähtökohdan tuotantoprojekteillesi.

Keskeiset asiat

  • Batch API tarjoaa 20 % alennuksen tukikelpoisista malleista, mutta asettaa käsittelyviiveen
  • Valitse reaaliaikaisen asyncin ja batchin välillä viiverajoitustesi perusteella
  • Tuotantotarkistuslista kattaa konfiguraation, virheet, valvonnan, suorituskyvyn ja tietoturvan
  • GrokAsyncProcessor-luokka kapseloi kaikki kurssin mallit yhdeksi abstraktioksi
  • Testaa aina konfiguraatiosi pienellä erällä ennen massakäsittelyn käynnistämistä

Testaa tietämyksesi

Async, kiintiöt, välimuisti: tuotantomalleja viidessä kysymyksessä.

1. Milloin async voittaa synkronisen?

Vastaus: Aina kun käsitellään useita itsenäisiä pyyntöjä: AsyncClient (tai AsyncOpenAI) limittää verkkoodotukset – läpivienti moninkertaistuu ilman säikeiden moninkertaistamista.

2. Miten käsittelet erän osuamatta kiintiöihin?

Vastaus: asyncio.gather rinnakkaisuuteen, semaphore rajoittamaan samanaikaisia pyyntöjä ja eksponentiaalinen backoff HTTP 429 -virheille – kunnioittaen konsolin RPM/TPM-rajoja.

3. Miten hallitset monivaiheista kontekstia laajassa mittakaavassa?

Vastaus: Palvelinpuoleisen vastauksen tallennuksen ja uudelleenkäytetyn salatun päättelyn kautta – tila elää API-puolella, koodisi seuraa vain tunnisteita.

4. Mitä sinun tulee tietää välimuistista ja aikakatkaisuista?

Vastaus: Keskusteluvälimuisti (x-grok-conv-id) nopeuttaa jatkoseurantaa, ja päättelypyynnöt vaativat sovitettuja aikakatkaisuja – kaksi asetusta, jotka muuttavat tuotannon.

5. Mitä kurssin tuotantotarkistuslista sisältää?

Vastaus: Hallittu async, kunnioitetut kiintiöt (semaphore + backoff), batch kylmälle volyymille, konfiguroidut aikakatkaisut ja uudelleenyritykset, seurannassa olevat kustannukset – robustius tarkistuslistana.

Rajoitettu samanaikaisuus, suunnitellut epäonnistumiset, palvelinpuoleinen tila: async-mallit muuttavat skriptisi palveluiksi – viimeinen tarkistuslista lukitsee ne paikoilleen.