Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Asynchrónny klient a výkon

Lekcia 10 z 14 Aktualizované 3. novembra 2026 Začiatočník
Na tejto strane
  1. Optimalizácia výkonu pomocou asynchrónnosti
  2. Klient AsyncOpenAI
  3. Paralelné požiadavky s asyncio.gather
  4. Kontrola paralelizmu
  5. Kompletný asynchrónny pipeline
  6. Porovnanie synchrónneho a asynchrónneho prístupu
  7. Ošetrenie chýb
  8. Kľúčové poznatky

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 AsyncOpenAI umožňuje paralelné požiadavky prostredníctvom asyncio
  • Použi asyncio.gather na 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