Async Client en Prestatieoptimalisatie
Op deze pagina
Bijgewerkt op 3 november 2026 op basis van de xAI-pagina Rate limits en de referentie voor de Images API: limieten voor het Imagine-model tellen als verzoeken per seconde—6 op het instapniveau, 100 op het hoogste niveau—en niet “30 per minuut”; een semaphore begrenst gelijktijdige verzoeken, niet de doorvoer; afbeeldingen worden standaard als JPEG uitgevoerd; en de specifieke tijdsbestedingen uit de oude versie, die niet op gepubliceerde metingen berustten, maken plaats voor een berekening. Bronnen: Rate limits · Images API.
Prestaties optimaliseren met Async
Wanneer u veel afbeeldingen moet genereren of bewerken, vormen opeenvolgende aanroepen een flessenhals. De async-client van de xAI API stelt u in staat meerdere verzoeken parallel uit te voeren, wat de totale verwerkingstijd aanzienlijk verkort.
De AsyncOpenAI-client
Async maakt een enkele generatie niet sneller: een enkel afbeeldingsverzoek kost exact evenveel tijd. Wat het elimineert, is onnodig wachten tussen verzoeken—terwijl de eerste afbeelding op de server wordt berekend, kan uw programma tien andere aanvragen in plaats van geblokkeerd te blijven. Daarom is de winst nul bij één afbeelding en dramatisch bij vijftig.
from openai import AsyncOpenAI
import asyncio
import os
async_client = AsyncOpenAI(
api_key=os.getenv("XAI_API_KEY"),
base_url="https://api.x.ai/v1"
)
async def generate_image(prompt):
"""Genereert asynchroon een afbeelding."""
response = await async_client.images.generate(
model="grok-imagine-image",
prompt=prompt,
extra_body={"resolution": "1k"},
)
return response.data[0].url
async def main():
url = await generate_image("A lighthouse on a cliff, watercolor style")
print(url)
asyncio.run(main())
Parallelle verzoeken met asyncio.gather
asyncio.gather start alle verzoeken en wacht vervolgens tot de set voltooid is. De totale duur wordt die van het langzaamste verzoek, niet de som van alle verzoeken—dat is het hele verschil, en u ziet dit al bij slechts drie of vier afbeeldingen.
async def generate_batch(prompts):
"""Genereert afbeeldingen voor meerdere prompts parallel."""
tasks = [generate_image(prompt) for prompt in prompts]
results = await asyncio.gather(*tasks)
return results
async def main():
prompts = [
"Portrait of an engineer, corporate style",
"Panoramic view of a futuristic city",
"Isometric diagram of a data center",
"Abstract blue and silver logo",
"Illustration of a team in a meeting"
]
urls = await generate_batch(prompts)
for prompt, url in zip(prompts, urls):
print(f"{prompt[:40]}... → {url}")
asyncio.run(main())
Met vijf prompts hoeft u niet te wachten tot elk verzoek is voltooid voordat u het volgende start; alle vijf afbeeldingen worden tegelijkertijd berekend: de totale tijd benadert die van het langzaamste verzoek.
Parallelisme beperken
Zonder limiet start gather alles tegelijk—en vijftig gelijktijdige verzoeken op een model dat op het instapniveau is beperkt tot 6 verzoeken per seconde, veroorzaken een lawine van 429-fouten die u meer tijd kost dan sequentiële uitvoering. De semaphore is daarom geen optionele voorzorgsmaatregel: het is wat parallelisme bruikbaar maakt. Kalibreer deze op de snelheidslimiet van het model, nooit op de capaciteit van uw machine.
async def generate_with_limit(prompts, max_concurrent=5):
"""Genereert afbeeldingen met een maximum aantal parallelle verzoeken."""
semaphore = asyncio.Semaphore(max_concurrent)
async def limited_generate(prompt):
async with semaphore:
return await generate_image(prompt)
tasks = [limited_generate(prompt) for prompt in prompts]
return await asyncio.gather(*tasks)
De officiële sheets voor grok-imagine-image en grok-imagine-image-2.0 geven 6 verzoeken per seconde aan op het instapniveau, een limiet die groeit met het niveau van uw team tot 100. Let op: een semaphore begrenst gelijktijdige verzoeken, niet de doorvoer. Met max_concurrent=5 blijft u onder de 6 verzoeken per seconde zolang elke generatie langer dan één seconde duurt; als uw antwoorden sneller binnenkomen, spreid de inzendingen dan ook uit. Controleer de limieten van uw team in de xAI-console voordat u deze verhoogt.
Volledige Async-pipeline
Deze pipeline koppelt de drie bewerkingen die samengaan: genereren, direct downloaden—URL’s verlopen—en fouten isoleren. Bij een grote batch maakt dit derde punt het verschil tussen een incident en een totaal verlies.
import aiohttp
import aiofiles
async def download_image(session, url, filepath):
"""Downloadt asynchroon een afbeelding."""
async with session.get(url) as resp:
if resp.status == 200:
async with aiofiles.open(filepath, "wb") as f:
await f.write(await resp.read())
return filepath
return None
async def pipeline(prompts, output_dir="output"):
"""Volledige pipeline: generatie + download."""
os.makedirs(output_dir, exist_ok=True)
# Stap 1: genereer alle afbeeldingen parallel
urls = await generate_with_limit(prompts, max_concurrent=5)
# Stap 2: download alle afbeeldingen parallel
async with aiohttp.ClientSession() as session:
download_tasks = []
for i, url in enumerate(urls):
if url:
# Standaard JPEG (image/jpeg), tenzij de kwaliteitsinstelling PNG produceert
filepath = os.path.join(output_dir, f"image_{i:03d}.jpg")
download_tasks.append(download_image(session, url, filepath))
saved_files = await asyncio.gather(*download_tasks)
count = sum(1 for f in saved_files if f)
print(f"{count}/{len(prompts)} afbeeldingen gegenereerd en opgeslagen")
Vergelijking: Synchroon versus Asynchroon
De winst is op papier te berekenen. Als één generatie T seconden duurt, kosten twintig afbeeldingen die na elkaar worden aangevraagd ongeveer 20 × T. Met vijf gelijktijdige verzoeken gaan ze in golven van vijf: ongeveer 4 × T, een winst dicht bij vijf, het aantal gelijktijdige verzoeken—op voorwaarde dat u onder de doorvoerlimiet blijft. Meet T op uw eigen account voordat u een deadline belooft: de afbeeldingspagina’s van xAI geven geen generatietijd op, en deze varieert per model, resolutie en belasting.
Foutafhandeling
Het standaardgedrag van gather is hard: een uitzondering in één taak laat de fout doorstromen en u verliest de resultaten van de andere, inclusief die waarvoor al is betaald. return_exceptions=True verandert dat—elke taak retourneert либо zijn resultaat óf zijn uitzondering, en u beslist wat u met mislukkingen doet zonder successen op te offeren.
async def safe_generate(prompt):
"""Genereert een afbeelding met foutafhandeling."""
try:
return await generate_image(prompt)
except Exception as e:
print(f"Fout voor '{prompt[:30]}...' : {e}")
return None
Belangrijkste punten
- De
AsyncOpenAI-client maakt parallelle verzoeken mogelijk viaasyncio - Gebruik
asyncio.gatherom meerdere generaties gelijktijdig te starten - Beperk gelijktijdigheid met een semaphore om snelheidslimieten te respecteren
- De winst benadert het aantal gelijktijdige verzoeken, binnen de toegestane doorvoerlimiet (6 verzoeken per seconde op het instapniveau)
- Handel fouten individueel af om te voorkomen dat de hele batch verloren gaat