Async kliens és teljesítmény
Ezen az oldalon
Frissítve: 2026. november 3. az xAI Rate limits (sebességkorlátok) oldala és a Képek API referenciája alapján: Az Imagine modell korlátai másodpercenkénti kérésekként (requests per second) számítandók – 6 a belépő szinten, 100 a legmagasabb szinten –, nem „percenként 30“-ként; a szemafór (semaphore) az egyidejű kéréseket korlátozza, nem az átviteli sebességet; a képek alapértelmezetten JPEG formátumban jelennek meg; és a régi verzió specifikus időzítései, amelyek nem publikált mérésekből származtak, helyet adnak egy számítási alapú megközelítésnek. Források: Rate limits · Images API.
Teljesítményoptimalizálás aszinkron műveletekkel
Ha sok képet kell generálnod vagy szerkesztened, a szekvenciális hívások szűk keresztmetszetté válnak. Az xAI API aszinkron kliense lehetővé teszi több kérés párhuzamos futtatását, ami jelentősen csökkenti a teljes feldolgozási időt.
Az AsyncOpenAI kliens
Az aszinkron működés nem gyorsítja fel az egyes generálásokat: egy kép kérése pontosan ugyanannyi ideig tart. Amit megszüntet, az a kérések közötti felesleges várakozás – miközben az első kép számolása zajlik a szerveren, a programod tíz további kérést is indíthat ahelyett, hogy blokkolva maradna. Ezért nulla a nyereség egyetlen képnél, de drámai ötvennél.
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):
"""Generál egy képet aszinkron módon."""
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())
Párhuzamos kérések az asyncio.gather segítségével
Az asyncio.gather elindítja az összes kérést, majd megvárja a készlet befejezését. A teljes időtartam a leglassabb kérés ideje lesz, nem az összes összege – ez a teljes különbség, amit már három-négy képnél is látsz.
async def generate_batch(prompts):
"""Generál képeket több prompt alapján párhuzamosan."""
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())
Öt prompt esetén ahelyett, hogy megvárnád az egyes kérések befejezését a következő indítása előtt, mind az öt kép egyszerre készül el: a teljes idő megközelíti a leglassabb kérés idejét.
A párhuzamosítás szabályozása
Korlát nélkül a gather mindent egyszerre indít el – és ötven egyidejű kérés egy olyan modellen, amelynek belépő szinten másodpercenként 6 a korlátja, 429-es hibák lavináját okozza, ami több időbe kerül, mint a szekvenciális végrehajtás. A szemafór ezért nem opcionális óvintézkedés: ez teszi használhatóvá a párhuzamosítást. Hangold a modell sebességkorlátjához, soha ne a géped kapacitásához.
async def generate_with_limit(prompts, max_concurrent=5):
"""Generál képeket a párhuzamos kérések maximális számának korlátozásával."""
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)
A grok-imagine-image és a grok-imagine-image-2.0 hivatalos táblázatai másodpercenként 6 kérést jeleznek belépő szinten; ez a korlát a csapatod szintjével együtt 100-ig növekszik. Megjegyzés: a szemafór az egyidejű kéréseket korlátozza, nem az átviteli sebességet (throughput). Ha max_concurrent=5, akkor másodpercenként 6 kérés alatt maradsz, feltéve, hogy minden generálás több mint egy másodpercig tart; ha a válaszaid gyorsabban érkeznek, akkor időzítsd el a beküldéseket is. Mielőtt növelnéd a számot, ellenőrizd a csapatod korlátait az xAI konzolban.
Teljes aszinkron folyamat (Pipeline)
Ez a folyamat láncolja össze azt a három műveletet, amelyeknek együtt kell futniuk: generálás, azonnali letöltés (mivel az URL-ek lejárnak) és a hibák izolálása. Nagy kötegeknél ez a harmadik pont dönti el a különbséget egy incidens és a teljes adatvesztés között.
import aiohttp
import aiofiles
async def download_image(session, url, filepath):
"""Letölt egy képet aszinkron módon."""
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"):
"""Teljes folyamat: generálás + letöltés."""
os.makedirs(output_dir, exist_ok=True)
# 1. lépés: összes kép generálása párhuzamosan
urls = await generate_with_limit(prompts, max_concurrent=5)
# 2. lépés: összes kép letöltése párhuzamosan
async with aiohttp.ClientSession() as session:
download_tasks = []
for i, url in enumerate(urls):
if url:
# Alapértelmezetten JPEG (image/jpeg), hacsak a minőségi beállítás nem PNG-t eredményez
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)} kép generálva és elmentve")
Szinkron és aszinkron összehasonlítás
A nyereség papíron kiszámolható. Ha egy generálás T másodpercig tart, húsz kép egymás után kérve körülbelül 20 × T időt vesz igénybe. Öt párhuzamos kéréssel hullámokban haladnak (ötösével): körülbelül 4 × T, ami közel ötszörös nyereség – ez a párhuzamos kérések száma –, feltéve, hogy az engedélyezett átviteli sebességkorláton belül maradsz. Mérd meg a T értéket a saját fiókodon, mielőtt határidőt ígérsz: az xAI képekkel foglalkozó oldalai nem közölnek generálási időt, és ez változik a modell, a felbontás és a terhelés függvényében.
Hibakezelés
A gather alapértelmezett viselkedése brutális: ha egy feladat kivételt dob, az hiba felfelé terjed, és elveszíted a többi eredményét is, beleértve azokat is, amelyekért már fizettél. A return_exceptions=True ezt megváltoztatja – minden feladat vagy az eredményt, vagy a kivételt adja vissza, és te döntöd el, hogyan kezeled a hibákat a sikerek feláldozása nélkül.
async def safe_generate(prompt):
"""Generál egy képet hibakezeléssel."""
try:
return await generate_image(prompt)
except Exception as e:
print(f"Hiba ennél: '{prompt[:30]}...' : {e}")
return None
Főbb megállapítások
- Az
AsyncOpenAIkliens lehetővé teszi a párhuzamos kéréseket azasynciosegítségével - Használd az
asyncio.gatherfunkciót több generálás egyidejű elindításához - Korlátozd az egyidejűséget egy szemafórral a sebességkorlátok betartása érdekében
- A nyereség megközelíti az egyidejű kérések számát, az engedélyezett átviteli sebességkorláton belül (belépő szinten másodpercenként 6 kérés)
- Kezeld a hibákat egyenként, hogy elkerüld az egész köteg elvesztését