Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Asynchronní klient a výkon

Lekce 10 z 14 Aktualizováno 3. listopadu 2026 Začátečník
Na této stránce
  1. Optimalizace výkonu pomocí asynchronního volání
  2. Klient AsyncOpenAI
  3. Paralelní požadavky s asyncio.gather
  4. Řízení paralelismu
  5. Kompletní asynchronní pipeline
  6. Porovnání synchronního a asynchronního přístupu
  7. Zpracování chyb
  8. Klíčové poznatky

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 AsyncOpenAI umožňuje paralelní požadavky prostřednictvím asyncio
  • Použij asyncio.gather ke 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