Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Odjemalec asinhrono in zmogljivost

Lekcija 10 od 14 Posodobljeno 3. november 2026 Začetnik
Na tej strani
  1. Optimizacija zmogljivosti z asinhronostjo
  2. Odjemalec AsyncOpenAI
  3. Vzporedni zahtevki z asyncio.gather
  4. Nadzor vzporednosti
  5. Celoten asinhroni potek dela
  6. Primerjava sinhrono proti asinhrono
  7. Obravnava napak
  8. Ključne ugotovitve

Posodobljeno 3. novembra 2026 na podlagi strani xAI Rate limits in referenčne dokumentacije API-ja za slike: omejitve modela Imagine se štejejo kot zahtevke na sekundo—6 na osnovni ravni, 100 na najvišji ravni—ne “30 na minuto”; semafor omejuje sočasne zahtevke, ne prepustnosti; slike so privzeto izhodne kot JPEG; specifični časi iz stare različice, ki niso temeljili na nobeni objavljeni meritvi, so nadomeščeni z izračunom. Viri: Rate limits · Images API.

Optimizacija zmogljivosti z asinhronostjo

Ko moraš ustvariti ali urediti veliko slik, zaporedni klici postanejo ozko grlo. Asinhroni odjemalec API-ja xAI ti omogoča vzporedno izvajanje več zahtevkov, kar bistveno skrajša skupni čas obdelave.

Odjemalec AsyncOpenAI

Asinhronost ne pospeši posameznega ustvarjanja: zahtevek za eno sliko traja točno toliko časa kot prej. Kar odpravi, je nepotrebno čakanje med zahtevki—medtem ko strežnik izračunava prvo sliko, lahko tvoj program zahteva še deset drugih, namesto da bi ostal blokiran. Zato je pri eni sliki dobiček ničelen, pri petdesetih pa dramatičen.

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):
    """Asinhrono ustvari sliko."""
    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())

Vzporedni zahtevki z asyncio.gather

asyncio.gather sproži vse zahtevke hkrati, nato pa počaka, da se celoten niz konča. Skupno trajanje postane enako trajanju najpočasnejšega zahtevka, ne vsoti vseh—v tem je bistvena razlika, ki jo opaziš že pri treh ali štirih slikah.

async def generate_batch(prompts):
    """Vzporedno ustvari slike za več pozivov."""
    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 petih pozivih se namesto čakanja na zaključek vsakega zahtevka pred sprožitvijo naslednjega, vseh pet slik izračuna hkrati: skupni čas se približa času najpočasnejšega zahtevka.

Nadzor vzporednosti

Brez omejitve gather sproži vse hkrati—petdeset sočasnih zahtevkov na modelu, omejenem na 6 zahtevkov na sekundo na osnovni ravni, povzroči plaz napak 429, ki te stane več časa kot zaporedno izvajanje. Semafor zato ni izbirni previdnostni ukrep: je tisto, kar naredi vzporednost uporabno. Prilagodi ga omejitvi hitrosti modela, nikoli zmogljivosti svojega stroja.

async def generate_with_limit(prompts, max_concurrent=5):
    """Ustvari slike z največjim številom vzporednih zahtevkov."""
    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)

Uradni listi za grok-imagine-image in grok-imagine-image-2.0 navajajo 6 zahtevkov na sekundo na osnovni ravni, omejitev pa narašča z ravnjo tvoje ekipe do 100. Opomba: semafor omejuje sočasne zahtevke, ne prepustnosti. Z max_concurrent=5 ostaneš pod 6 zahtevki na sekundo, dokler vsako ustvarjanje traja več kot eno sekundo; če odgovori prispejo hitreje, moraš oddajo zahtevkov tudi razmakniti. Pred povečanjem preveri omejitve svoje ekipe v konzoli xAI.

Celoten asinhroni potek dela

Ta potek povezuje tri operacije, ki morajo delovati skupaj: ustvarjanje, takojšnji prenos (URL-ji potečejo) in izolacija napak. Pri velikem nizu je ta tretja točka tista, ki odloča med manjšim incidentom in popolno izgubo.

import aiohttp
import aiofiles

async def download_image(session, url, filepath):
    """Asinhrono prenese sliko."""
    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"):
    """Celoten potek: ustvarjanje + prenos."""
    os.makedirs(output_dir, exist_ok=True)

    # 1. korak: vzporedno ustvari vse slike
    urls = await generate_with_limit(prompts, max_concurrent=5)

    # 2. korak: vzporedno prenesi vse slike
    async with aiohttp.ClientSession() as session:
        download_tasks = []
        for i, url in enumerate(urls):
            if url:
                # Privzeto JPEG (image/jpeg), razen če nastavitev kakovosti 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)} slik ustvarjenih in shranjenih")

Primerjava sinhrono proti asinhrono

Dobiček je mogoče izračunati na papirju. Če eno ustvarjanje traja T sekund, dvajset slik, zahtevanih ena za drugo, traja približno 20 × T. S petimi sočasnimi zahtevki potekajo v valovih po pet: približno 4 × T, kar pomeni dobiček blizu pet, kar je število sočasnih zahtevkov—pod pogojem, da ostaneš znotraj omejitve prepustnosti. Izmeri T na svojem računu, preden obljubiš rok: strani za slike xAI ne navajajo časa ustvarjanja, ta pa se spreminja glede na model, ločljivost in obremenitev.

Obravnava napak

Privzeto vedenje gather je surovo: izjema v eni nalogi prenese napako navzgor in izgubiš rezultate drugih, vključno s tistimi, za katere si že plačal. return_exceptions=True to spremeni—vsaka naloga vrne bodisi svoj rezultat bodisi svojo izjemo, ti pa se odločiš, kaj storiti z napakami, ne da bi žrtvoval uspehe.

async def safe_generate(prompt):
    """Ustvari sliko z obravnavo napak."""
    try:
        return await generate_image(prompt)
    except Exception as e:
        print(f"Napaka za '{prompt[:30]}...' : {e}")
        return None

Ključne ugotovitve

  • Odjemalec AsyncOpenAI omogoča vzporedne zahtevke prek asyncio
  • Uporabi asyncio.gather za sočasno sprožitev več ustvarjanj
  • Omeji vzporednost s semaforjem, da spoštuješ omejitve hitrosti
  • Dobiček se približa številu sočasnih zahtevkov, znotraj dovoljene omejitve prepustnosti (6 zahtevkov na sekundo na osnovni ravni)
  • Napake obravnavaj posamično, da se izogneš izgubi celotnega niza