Asynchrónny klient a výkon
Na tejto strane
Aktualizované 3. novembra 2026 na základe stránky xAI Rate limits a referencie Images API: Limity modelu Imagine sa počítajú ako požiadavky za sekundu – 6 na vstupnej úrovni, 100 na najvyššej úrovni – nie „30 za minútu“; semafor obmedzuje súbežné požiadavky, nie priepustnosť; obrázky sa predvolene ukladajú ako JPEG a konkrétne časové údaje zo starej verzie, ktoré neboli založené na žiadnom zverejnenom meraní, sú nahradené výpočtom. Zdroje: Rate limits · Images API.
Optimalizácia výkonu pomocou asynchrónnosti
Keď potrebuješ generovať alebo upravovať veľa obrázkov, sekvenčné volania sa stávajú úzkym hrdlom. Asynchrónny klient xAI API ti umožňuje spustiť viacero požiadaviek paralelne, čo výrazne skracuje celkový čas spracovania.
Klient AsyncOpenAI
Asynchrónnosť nezrýchli jednotlivú generáciu: jedna požiadavka na obrázok trvá presne rovnako dlho. To, čo eliminuje, je zbytočné čakanie medzi požiadavkami – kým server počíta prvý obrázok, tvoj program môže požiadať o ďalších desať namiesto toho, aby zostal zablokovaný. Preto je zisk pri jednom obrázku nulový, ale pri päťdesiatich 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ázok asynchrónne."""
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žiadavky s asyncio.gather
asyncio.gather spustí všetky požiadavky a potom čaká na dokončenie celej sady. Celková dĺžka trvania sa rovná dĺžke najpomalšej požiadavky, nie súčtu všetkých – v tom spočíva celý rozdiel, ktorý uvidíš už pri troch alebo štyroch obrázkoch.
async def generate_batch(prompts):
"""Generuje obrázky pre viacero promptov paralelne."""
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())
Pri piatich promptoch sa namiesto čakania na dokončenie každej požiadavky pred spustením ďalšej všetkých päť obrázkov počíta súčasne: celkový čas sa približuje času najpomalšej požiadavky.
Kontrola paralelizmu
Bez obmedzenia gather spustí všetko naraz – a päťdesiat súbežných požiadaviek na model s limitom 6 požiadaviek za sekundu na vstupnej úrovni vyvolá lavínu chýb 429, ktorá ťa bude stáť viac času než sekvenčné vykonávanie. Semafor preto nie je voliteľnou opatrnosťou: je to práve on, čo robí paralelizmus použiteľným. Kalibruj ho podľa limitu rýchlosti modelu, nikdy podľa kapacity svojho stroja.
async def generate_with_limit(prompts, max_concurrent=5):
"""Generuje obrázky s maximálnym počtom paralelných požiadaviek."""
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álne tabuľky pre grok-imagine-image a grok-imagine-image-2.0 uvádzajú 6 požiadaviek za sekundu na vstupnej úrovni, pričom tento limit rastie s úrovňou tvojho tímu až na 100. Poznámka: semafor obmedzuje súbežné požiadavky, nie priepustnosť. Pri max_concurrent=5 zostaneš pod limitom 6 požiadaviek za sekundu, pokiaľ každá generácia trvá viac ako jednu sekundu; ak prídu odpovede rýchlejšie, musíš tiež rozložiť odosielanie požiadaviek. Pred zvýšením limitu si over limity svojho tímu v konzole xAI.
Kompletný asynchrónny pipeline
Tento pipeline spája tri operácie, ktoré musia ísť spolu: generovanie, okamžité sťahovanie (URL adresy expirujú) a izoláciu chýb. Pri veľkej dávke robí tento tretí bod rozdiel medzi incidentom a úplnou stratou.
import aiohttp
import aiofiles
async def download_image(session, url, filepath):
"""Stiahne obrázok asynchrónne."""
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: generovanie + sťahovanie."""
os.makedirs(output_dir, exist_ok=True)
# Krok 1: generovanie všetkých obrázkov paralelne
urls = await generate_with_limit(prompts, max_concurrent=5)
# Krok 2: sťahovanie všetkých obrázkov paralelne
async with aiohttp.ClientSession() as session:
download_tasks = []
for i, url in enumerate(urls):
if url:
# Predvolene JPEG (image/jpeg), pokiaľ nastavenie kvality nevyprodukuje 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ázkov vygenerovaných a uložených")
Porovnanie synchrónneho a asynchrónneho prístupu
Zisk sa dá vypočítať na papieri. Ak jedna generácia trvá T sekúnd, dvadsať obrázkov požadovaných po sebe zaberie približne 20 × T. Pri piatich súbežných požiadavkách idú vo vlnách po piatich: približne 4 × T, čo znamená zisk blízky päťke, teda počtu súbežných požiadaviek – za predpokladu, že zostaneš v rámci limitu priepustnosti. Zmeraj si T na vlastnom účte pred sľubovaním termínu: stránky xAI o obrázkoch neuvádzajú čas generovania a ten sa líši podľa modelu, rozlíšenia a zaťaženia.
Ošetrenie chýb
Predvolené správanie gather je brutálne: výnimka v jednej úlohe vynorí chybu nahor a stratíš výsledky ostatných, vrátane tých, za ktoré si už zaplatil. return_exceptions=True to mení – každá úloha vráti buď svoj výsledok, alebo svoju výnimku a ty sa rozhodneš, čo s chybami urobíš, bez obetovania úspechov.
async def safe_generate(prompt):
"""Generuje obrázok s ošetrením chýb."""
try:
return await generate_image(prompt)
except Exception as e:
print(f"Chyba pre '{prompt[:30]}...' : {e}")
return None
Kľúčové poznatky
- Klient
AsyncOpenAIumožňuje paralelné požiadavky prostredníctvomasyncio - Použi
asyncio.gatherna súčasné spustenie viacerých generácií - Obmedz súbežnosť pomocou semafora, aby si rešpektoval limity rýchlosti
- Zisk sa približuje počtu súbežných požiadaviek v rámci povolenej priepustnosti (6 požiadaviek za sekundu na vstupnej úrovni)
- Ošetruj chyby individuálne, aby si predišiel strate celej dávky