Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Async kliens és teljesítmény

10. lecke 14 közül Frissítve 2026. november 3. Kezdő
Ezen az oldalon
  1. Teljesítményoptimalizálás aszinkron műveletekkel
  2. Az AsyncOpenAI kliens
  3. Párhuzamos kérések az asyncio.gather segítségével
  4. A párhuzamosítás szabályozása
  5. Teljes aszinkron folyamat (Pipeline)
  6. Szinkron és aszinkron összehasonlítás
  7. Hibakezelés
  8. Főbb megállapítások

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 AsyncOpenAI kliens lehetővé teszi a párhuzamos kéréseket az asyncio segítségével
  • Használd az asyncio.gather funkció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