Asynchronní klient a výkon
Na této stránce
Aktualizováno 3. listopadu 2026 na základě stránky xAI Rate limits a reference Images API: Limity modelu Imagine se počítají jako požadavky za sekundu – 6 na vstupní úrovni, 100 na nejvyšší úrovni – nikoliv „30 za minutu“; semafor omezuje souběžné požadavky, nikoliv propustnost; obrázky se ve výchozím nastavení ukládají jako JPEG; a konkrétní časování ze staré verze, která neměla oporu ve zveřejněných měřeních, jsou nahrazena výpočtem. Zdroje: Rate limits · Images API.
Optimalizace výkonu pomocí asynchronního volání
Když potřebuješ generovat nebo upravovat mnoho obrázků, sekvenční volání se stávají úzkým hrdlem. Asynchronní klient xAI API ti umožňuje spustit více požadavků paralelně, což výrazně zkracuje celkový čas zpracování.
Klient AsyncOpenAI
Asynchronnost nezrychlí samotné generování jednoho obrázku: jeden požadavek na obrázek trvá přesně stejně dlouho. Co eliminuje, je zbytečné čekání mezi požadavky – zatímco server počítá první obrázek, tvůj program může požádat o deset dalších, místo aby zůstal blokován. Proto je u jednoho obrázku zisk nulový, ale u padesáti dramatický.
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):
"""Generuje obrázek asynchronně."""
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())
Paralelní požadavky s asyncio.gather
asyncio.gather spustí všechny požadavky a poté čeká na dokončení celé sady. Celková doba trvání odpovídá době nejpomalejšího požadavku, nikoliv součtu všech – v tom spočívá celý rozdíl, který poznáš již u tří nebo čtyř obrázků.
async def generate_batch(prompts):
"""Generuje obrázky pro více promptů paralelně."""
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())
U pěti promptů se místo čekání na dokončení každého požadavku před spuštěním dalšího všech pět obrázků počítá současně: celkový čas se blíží času nejpomalejšího požadavku.
Řízení paralelismu
Bez omezení gather spustí vše najednou – a padesát souběžných požadavků na model s limitem 6 požadavků za sekundu na vstupní úrovni vyvolá lavinu chyb 429, která tě stojí více času než sekvenční provádění. Semafor tedy není volitelnou opatrností: je to právě on, co činí paralelismus použitelným. Kalibruj jej podle limitu rychlosti modelu, nikdy podle kapacity tvého stroje.
async def generate_with_limit(prompts, max_concurrent=5):
"""Generuje obrázky s maximálním počtem paralelních požadavků."""
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)
Oficiální listy pro grok-imagine-image a grok-imagine-image-2.0 uvádějí 6 požadavků za sekundu na vstupní úrovni, přičemž tento limit roste s úrovní tvého týmu až na 100. Poznámka: semafor omezuje souběžné požadavky, nikoliv propustnost. S max_concurrent=5 zůstaneš pod 6 požadavky za sekundu, pokud každé generování trvá déle než jednu sekundu; pokud odpovědi přicházejí rychleji, musíš odesílání také rozložit v čase. Před zvýšením limitu si ověř limity svého týmu v konzoli xAI.
Kompletní asynchronní pipeline
Tato pipeline řetězí tři operace, které musí jít ruku v ruce: generování, okamžité stažení – URL adresy expirují – a izolaci chyb. U velké dávky dělá tento třetí bod rozdíl mezi drobným incidentem a totální ztrátou.
import aiohttp
import aiofiles
async def download_image(session, url, filepath):
"""Stáhne obrázek asynchronně."""
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"):
"""Kompletní pipeline: generování + stahování."""
os.makedirs(output_dir, exist_ok=True)
# Krok 1: generování všech obrázků paralelně
urls = await generate_with_limit(prompts, max_concurrent=5)
# Krok 2: stahování všech obrázků paralelně
async with aiohttp.ClientSession() as session:
download_tasks = []
for i, url in enumerate(urls):
if url:
# Ve výchozím nastavení JPEG (image/jpeg), pokud nastavení kvality nevytvoří PNG
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)} obrázků vygenerováno a uloženo")
Porovnání synchronního a asynchronního přístupu
Zisk lze vypočítat na papíře. Pokud jedno generování trvá T sekund, dvacet obrázků požadovaných po sobě zabere přibližně 20 × T. S pěti souběžnými požadavky jdou ve vlnách po pěti: přibližně 4 × T, což je zisk blízký pěti, tedy počtu souběžných požadavků – za předpokladu, že zůstaneš v rámci limitu propustnosti. Změř si T na svém vlastním účtu, než slíbíš termín: stránky xAI pro obrázky neuvádějí dobu generování a ta se liší podle modelu, rozlišení a zatížení.
Zpracování chyb
Výchozí chování gather je brutální: výjimka v jednom úkolu vynoří chybu nahoru a ty přijdeš o výsledky ostatních, včetně těch, za které jsi již zaplatil. return_exceptions=True to mění – každý úkol vrátí buď svůj výsledek, nebo svou výjimku, a ty se rozhodneš, co s chybami uděláš, aniž bys obětoval úspěchy.
async def safe_generate(prompt):
"""Generuje obrázek se zpracováním chyb."""
try:
return await generate_image(prompt)
except Exception as e:
print(f"Chyba pro '{prompt[:30]}...' : {e}")
return None
Klíčové poznatky
- Klient
AsyncOpenAIumožňuje paralelní požadavky prostřednictvímasyncio - Použij
asyncio.gatherke spuštění více generování současně - Omez souběžnost pomocí semaforu, abys dodržel limity rychlosti
- Zisk se blíží počtu souběžných požadavků, v rámci povoleného limitu propustnosti (6 požadavků za sekundu na vstupní úrovni)
- Zpracovávej chyby individuálně, abys předešel ztrátě celé dávky