Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Asünkroonne klient ja jõudlus

Õppetund 10 / 14 Värskendatud 3. november 2026 Algajatele
Sellel lehel
  1. Jõudluse optimeerimine asünkroonsusega
  2. AsyncOpenAI klient
  3. Paralleelsed taotlused koos asyncio.gather-iga
  4. Paralleelsuse kontrollimine
  5. Täielik asünkroonne torustik
  6. Sünkroonse ja asünkroonse võrdlus
  7. Veakäsitlus
  8. Peamised punktid

Uuendatud 3. novembril 2026, tuginedes xAI kasutuspiirangute lehele ja piltide API referentsile: Imagine mudeli piirangud loetakse taotlusteks sekundis – 6 sisemisel tasemel, 100 kõrgeimal tasemel – mitte „30 minutis“; semafor piirab samaaegseid taotlusi, mitte läbilaskevõimet; pildid väljastatakse vaikimisi JPEG-vormingus; ja vana versiooni konkreetsed ajastused, mis ei põhinenud avaldatud mõõtmistel, asendatakse arvutusega. Allikad: Kasutuspiirangud · Piltide API.

Jõudluse optimeerimine asünkroonsusega

Kui sul on vaja genereerida või redigeerida palju pilte, muutuvad järjestikused väljakutsed kitsaskohaks. xAI API asünkroonne klient võimaldab sul käivitada mitu taotlust paralleelselt, vähendades oluliselt üldist töötlemisaega.

AsyncOpenAI klient

Asünkroonsus ei tee üksikut genereerimist kiiremaks: ühe pildi taotlus võtab täpselt sama palju aega. See, mida see kõrvaldab, on tarbetu ootamine taotluste vahel – samal ajal kui server arvutab esimest pilti, saab sinu programm taotleda kümnet teist, selle asemel et blokeeritud olekus seista. Seetõttu on kasu ühe pildi puhul null, kuid viiekümne puhul tohutu.

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):
    """Genereerib pildi asünkroonselt."""
    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())

Paralleelsed taotlused koos asyncio.gather-iga

asyncio.gather käivitab kõik taotlused ja ootab seejärel komplekti lõpetamist. Kogukestus võrdub aeglaseima taotluse ajaga, mitte kõigi summa – selles seisnebki kogu erinevus, mida märkad juba kolme või nelja pildi puhul.

async def generate_batch(prompts):
    """Genereerib pilte mitme vihje jaoks paralleelselt."""
    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())

Viie vihje korral ei oodata iga taotluse lõppemist enne järgmise käivitamist; kõik viis pilti arvutatakse samaaegselt: koguaeg läheneb aeglaseima taotluse ajale.

Paralleelsuse kontrollimine

Piiranguta käivitab gather kõik korraga – ja viiskümmend samaaegset taotlust mudelile, mille sisemine tase on piiratud 6 taotlusega sekundis, tekitab 429 vea laviini, mis maksab sulle rohkem aega kui järjestikune täitmine. Semafor ei ole seega valikuline ettevaatusabinõu: just see teeb paralleelsuse kasutatavaks. Kalibreeri see mudeli kasutuspiirangu järgi, mitte kunagi oma masina võimsuse järgi.

async def generate_with_limit(prompts, max_concurrent=5):
    """Genereerib pilte maksimaalse paralleelsete taotluste arvuga."""
    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)

grok-imagine-image ja grok-imagine-image-2.0 ametlikud lehed näitavad sisemisel tasemel 6 taotlust sekundis, mis kasvab koos sinu meeskonna tasemega kuni 100-ni. Märkus: semafor piirab samaaegseid taotlusi, mitte läbilaskevõimet. Seades max_concurrent=5, jääd alla 6 taotluse sekundis, kui iga genereerimine kestab üle ühe sekundi; kui vastused saabuavad kiiremini, tuleb esitamiste vahele jätta rohkem ruumi. Enne suurendamist kontrolli oma meeskonna piiranguid xAI konsoolist.

Täielik asünkroonne torustik

See torustik ühendab kolm operatsiooni, mis peavad koos toimima: genereerimine, kohene allalaadimine (URL-id aeguvad) ja vigade isoleerimine. Suure partii puhul teeb see kolmas punkt vahet intsidenti ja täieliku kaotuse vahel.

import aiohttp
import aiofiles

async def download_image(session, url, filepath):
    """Laadib pildi asünkroonselt alla."""
    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"):
    """Täielik torustik: genereerimine + allalaadimine."""
    os.makedirs(output_dir, exist_ok=True)

    # 1. samm: genereeri kõik pildid paralleelselt
    urls = await generate_with_limit(prompts, max_concurrent=5)

    # 2. samm: laadi kõik pildid paralleelselt alla
    async with aiohttp.ClientSession() as session:
        download_tasks = []
        for i, url in enumerate(urls):
            if url:
                # Vaikimisi JPEG (image/jpeg), välja arvatud kui kvaliteediseade toodab 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)} pilti genereeritud ja salvestatud")

Sünkroonse ja asünkroonse võrdlus

Kasu on arvutatav paberil. Kui üks genereerimine võtab T sekundit, võtab kakskümmend üksteise järel taotletud pilti umbes 20 × T. Viie samaaegse taotlusega liiguvad need viiekaupa lainetena: umbes 4 × T, mis annab kasu ligikaudu viiekordselt, võrdne samaaegsete taotluste arvuga – eeldusel, et püsidad läbilaskevõime piiri sees. Mõõda T oma kontol enne tähtaja lubamist: xAI piltide lehed ei anna genereerimisaega ja see varieerub sõltuvalt mudelist, eraldusvõimest ja koormusest.

Veakäsitlus

gatheri vaikimisi käitumine on brutaalne: erind ühes ülesandes tõstab vea üles ja kaotad teiste tulemused, sealhulgas need, mille eest on juba makstud. return_exceptions=True muudab seda – iga ülesanne tagastab kas oma tulemuse või erindi ning sina otsustad, mida vigadega ette võtta, ilma et ohverdaksid õnnestumisi.

async def safe_generate(prompt):
    """Genereerib pildi veakäsitlusega."""
    try:
        return await generate_image(prompt)
    except Exception as e:
        print(f"Viga '{prompt[:30]}...' puhul: {e}")
        return None

Peamised punktid

  • Klient AsyncOpenAI võimaldab paralleelseid taotlusi asyncio kaudu
  • Kasuta asyncio.gather mitme genereerimise samaaegseks käivitamiseks
  • Piira samaaegsust semaforiga, et austada kasutuspiiranguid
  • Kasu läheneb samaaegsete taotluste arvule, jäädes lubatud läbilaskevõime piiridesse (6 taotlust sekundis sisemisel tasemel)
  • Käitle vigu individuaalselt, et vältida kogu partii kaotamist