Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Klijent asinkronog rada i performanse

Lekcija 10 od 14 Ažurirano 3. studenoga 2026. Početnik
Na ovoj stranici
  1. Optimizacija performansi asinkronim radom
  2. Klijent AsyncOpenAI
  3. Paralelni zahtjevi s asyncio.gather
  4. Kontrola paralelizma
  5. Potpuni asinkroni pipeline
  6. Usporedba sinkronog i asinkronog rada
  7. Rukovanje pogreškama
  8. Ključne točke

Ažurirano 3. studenog 2026. na temelju stranice xAI Rate limits i referenci za Images API: ograničenja modela Imagine broje se kao zahtjevi u sekundi—6 na osnovnoj razini, 100 na najvišoj razini—ne „30 u minuti“; semafor ograničava istodobne zahtjeve, a ne propusnost; slike se prema zadanim postavkama izrađuju kao JPEG; a specifična vremena iz stare verzije, koja nisu proizlazila iz nijednog objavljenog mjerenja, zamijenjena su izračunom. Izvori: Rate limits · Images API.

Optimizacija performansi asinkronim radom

Kada trebaš generirati ili uređivati mnogo slika, sekvencijalni pozivi postaju usko grlo. Asinkroni klijent xAI API-ja omogućuje paralelno izvršavanje više zahtjeva, čime se znatno smanjuje ukupno vrijeme obrade.

Klijent AsyncOpenAI

Asinkronost ne ubrzava pojedinačno generiranje: zahtjev za jednu sliku traje točno isto vrijeme. Ono što eliminira jest nepotrebno čekanje između zahtjeva—dok server izračunava prvu sliku, tvoj program može zatražiti još deset umjesto da ostane blokiran. Zato je dobitak nula za jednu sliku, a dramatičan za pedeset.

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):
    """Generira sliku asinkrono."""
    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())

Paralelni zahtjevi s asyncio.gather

asyncio.gather pokreće sve zahtjeve, a zatim čeka da se skup završi. Ukupno trajanje postaje jednako trajanju najsporijeg zahtjeva, a ne zbroju svih—u tome je cijela razlika, što ćeš vidjeti već s tri ili četiri slike.

async def generate_batch(prompts):
    """Generira slike za više promptova paralelno."""
    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())

S pet promptova, umjesto da čekaš da se svaki zahtjev završi prije pokretanja sljedećeg, svih pet slika izračunava se istovremeno: ukupno vrijeme približava se vremenu najsporijeg zahtjeva.

Kontrola paralelizma

Bez ograničenja, gather pokreće sve odjednom—pedeset istodobnih zahtjeva na modelu s ograničenjem od 6 zahtjeva u sekundi na osnovnoj razini izazvat će lavinu pogrešaka 429 koja će te koštati više vremena od sekvencijalnog izvršavanja. Semafor stoga nije opcioni oprez: on je ono što paralelizam čini upotrebljivim. Kalibriraj ga prema ograničenju brzine modela, nikada prema kapacitetu tvog stroja.

async def generate_with_limit(prompts, max_concurrent=5):
    """Generira slike s maksimalnim brojem paralelnih zahtjeva."""
    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)

Službeni listovi za grok-imagine-image i grok-imagine-image-2.0 navode 6 zahtjeva u sekundi na osnovnoj razini, pri čemu to ograničenje raste s razinom tvog tima do 100. Napomena: semafor ograničava istodobne zahtjeve, a ne propusnost. S max_concurrent=5, ostaješ ispod 6 zahtjeva u sekundi sve dok svako generiranje traje dulje od jedne sekunde; ako odgovori stižu brže, razmakni i podnošenje zahtjeva. Prije povećanja provjeri ograničenja svog tima u xAI konzoli.

Potpuni asinkroni pipeline

Ovaj pipeline povezuje tri operacije koje moraju ići zajedno: generiranje, trenutno preuzimanje—URL-ovi istječu—i izolaciju pogrešaka. Kod velikog batcha, ova treća točka čini razliku između incidenta i totalnog gubitka.

import aiohttp
import aiofiles

async def download_image(session, url, filepath):
    """Preuzima sliku asinkrono."""
    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"):
    """Potpuni pipeline: generiranje + preuzimanje."""
    os.makedirs(output_dir, exist_ok=True)

    # Korak 1: generiraj sve slike paralelno
    urls = await generate_with_limit(prompts, max_concurrent=5)

    # Korak 2: preuzmi sve slike paralelno
    async with aiohttp.ClientSession() as session:
        download_tasks = []
        for i, url in enumerate(urls):
            if url:
                # JPEG prema zadanim postavkama (image/jpeg), osim ako postavka kvalitete ne proizvede 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)} slika generirano i spremljeno")

Usporedba sinkronog i asinkronog rada

Dobitak se može izračunati na papiru. Ako jedno generiranje traje T sekundi, dvadeset slika zatraženih jedna za drugom traje oko 20 × T. S pet istodobnih zahtjeva, one idu u valovima od pet: oko 4 × T, što je dobitak blizu pet, broju istodobnih zahtjeva—pod uvjetom da ostaneš unutar ograničenja propusnosti. Izmjeri T na svom računu prije obećavanja rokova: stranice sa slikama xAI-ja ne navode vrijeme generiranja, a ono varira ovisno o modelu, rezoluciji i opterećenju.

Rukovanje pogreškama

Zadano ponašanje gather je brutalno: iznimka u jednom zadatku prenosi pogrešku dalje i gubiš rezultate ostalih, uključujući one za koje si već platio. return_exceptions=True to mijenja—svaki zadatak vraća ili svoj rezultat ili svoju iznimku, a ti odlučuješ što učiniti s neuspjesima bez žrtvovanja uspjeha.

async def safe_generate(prompt):
    """Generira sliku s rukovanjem pogreškama."""
    try:
        return await generate_image(prompt)
    except Exception as e:
        print(f"Pogreška za '{prompt[:30]}...' : {e}")
        return None

Ključne točke

  • Klijent AsyncOpenAI omogućuje paralelne zahtjeve putem asyncio
  • Koristi asyncio.gather za istodobno pokretanje više generiranja
  • Ograniči istodobnost semaforom kako bi poštovao ograničenja brzine
  • Dobitak se približava broju istodobnih zahtjeva, unutar dopuštene granice propusnosti (6 zahtjeva u sekundi na osnovnoj razini)
  • Rukuj pogreškama pojedinačno kako bi izbjegao gubitak cijelog batcha