Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Klientas asinchroniniam darbui ir našumas

Paskaita 10 iš 14 Atnaujinta 2026 m. lapkričio 3 d. Pradedantisiems
Šiame puslapyje
  1. Našumo optimizavimas naudojant asinchroninį režimą
  2. „AsyncOpenAI“ klientas
  3. Lygiagrečios užklausos naudojant „asyncio.gather“
  4. Lygiagretumo valdymas
  5. Pilna asinchroninė grandinė
  6. Sinchroninio ir asinchroninio režimo palyginimas
  7. Klaidų valdymas
  8. Svarbiausi punktai

Atnaujinta 2026 m. lapkričio 3 d. remiantis xAI Rate limits puslapiu ir „Images API“ nuoroda: „Imagine“ modelio limitai skaičiuojami kaip užklausos per sekundę – 6 pradiniame lygmenyje, 100 aukščiausiame lygmenyje, o ne „30 per minutę“; semaforas riboja vienu metu vykdomas užklausas, o ne pralaidumą; vaizdai pagal nutylėjimą išvedami JPEG formatu; konkretūs senosios versijos laikmačiai, kurie nebuvo pagrįsti jokiais paskelbtais matavimais, pakeisti skaičiavimu. Šaltiniai: Rate limits · Images API.

Našumo optimizavimas naudojant asinchroninį režimą

Kai reikia sugeneruoti arba redaguoti daug vaizdų, nuoseklūs kvietimai tampa „butelio kakleliu“. xAI API asinchroninis klientas leidžia vienu metu vykdyti kelias užklausas, taip žymiai sutrumpinant bendrą apdorojimo laiką.

„AsyncOpenAI“ klientas

Asinchroninis režimas nepagreitina vieno generavimo: vieno vaizdo užklausa trunka lygiai tiek pat laiko. Tai, ką jis pašalina, yra nereikalingas laukimas tarp užklausų – kol serveris apskaičiuoja pirmąjį vaizdą, jūsų programa gali prašyti dar dešimties, užuot likusi užblokuota. Štai kodėl dirbant su vienu vaizdu naudos nėra, o dirbant su penkiasdešimčia – ji yra didžiulė.

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):
    """Generuoja vaizdą asinchroniniu būdu."""
    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())

Lygiagrečios užklausos naudojant „asyncio.gather“

asyncio.gather paleidžia visas užklausas ir tada laukia, kol visa grupė bus baigta. Bendra trukmė tampa lygi lėčiausios užklausos trukmei, o ne visų užklausų sumai – tai ir yra esminis skirtumas, kurį pastebėsite jau dirbdami su trimis ar keturiais vaizdais.

async def generate_batch(prompts):
    """Generuoja vaizdus kelioms užuominoms lygiagrečiai."""
    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())

Turint penkias užuominas, užuot laukus, kol kiekviena užklausa bus baigta prieš paleidžiant kitą, visi penki vaizdai apskaičiuojami vienu metu: bendras laikas artėja prie lėčiausios užklausos trukmės.

Lygiagretumo valdymas

Be ribojimo, gather paleidžia viską vienu metu – o penkiasdešimt vienu metu vykdomų užklausų modeliui, kurio pradinis limitas yra 6 užklausos per sekundę, sukels 429 klaidų laviną, kuri kainuos jums daugiau laiko nei nuoseklus vykdymas. Todėl semaforas nėra tik papildoma atsargumo priemonė: būtent jis daro lygiagretumą panaudojamu. Derinkite jį prie modelio užklausų ribos, o ne prie savo kompiuterio pajėgumų.

async def generate_with_limit(prompts, max_concurrent=5):
    """Generuoja vaizdus su maksimaliu lygiagrečių užklausų skaičiumi."""
    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)

Oficialiose grok-imagine-image ir grok-imagine-image-2.0 lentelėse nurodyta 6 užklausos per sekundę pradiniame lygmenyje; šis limitas didėja priklausomai nuo jūsų komandos lygmens iki 100. Pastaba: semaforas riboja vienu metu vykdomas užklausas, o ne pralaidumą. Nustačius max_concurrent=5, neviršysite 6 užklausų per sekundę ribos, tol, kol kiekvienas generavimas trunka ilgiau nei vieną sekundę; jei atsakymai ateina greičiau, taip pat reikia didinti intervalus tarp pateikimų. Prieš didindami ribas, patikrinkite savo komandos limitus xAI konsolėje.

Pilna asinchroninė grandinė

Ši grandinė sujungia tris operacijas, kurios turi vykti kartu: generavimas, neatidėliotinas atsisiuntimas (nuorodos galioja ribotą laiką) ir klaidų izoliavimas. Dirbant su didelėmis grupėmis, šis trečiasis punktas lemia skirtumą tarp nedidelio incidento ir visiško duomenų praradimo.

import aiohttp
import aiofiles

async def download_image(session, url, filepath):
    """Atsisiunčia vaizdą asinchroniniu būdu."""
    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"):
    """Pilna grandinė: generavimas + atsisiuntimas."""
    os.makedirs(output_dir, exist_ok=True)

    # 1 žingsnis: lygiagrečiai sugeneruoti visus vaizdus
    urls = await generate_with_limit(prompts, max_concurrent=5)

    # 2 žingsnis: lygiagrečiai atsisiųsti visus vaizdus
    async with aiohttp.ClientSession() as session:
        download_tasks = []
        for i, url in enumerate(urls):
            if url:
                # Pagal nutylėjimą JPEG (image/jpeg), nebent kokybės nustatymas sukuria 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)} vaizdų sugeneruota ir išsaugota")

Sinchroninio ir asinchroninio režimo palyginimas

Naudą galima apskaičiuoti popieriuje. Jei vienas generavimas trunka T sekundžių, dvidešimt vaizdų, prašomų vienas po kito, užtruks apie 20 × T. Vykdant penkias lygiagrečias užklausas, jos eina bangomis po penkis: apie 4 × T, tai yra beveik penkiskart didesnis našumas, lygus vienu metu vykdomų užklausų skaičiui – su sąlyga, kad neviršijate leidžiamo pralaidumo ribos. Prieš žadėdami terminus, išmatuokite T savo paskyroje: xAI vaizdų puslapiuose nenurodomas generavimo laikas, jis kinta priklausomai nuo modelio, skiriamosios gebos ir apkrovos.

Klaidų valdymas

Numatytoji gather elgsena yra griežta: vienos užduoties išimtis („exception“) pakelia klaidą aukštyn ir jūs prarandate kitų užduočių rezultatus, įskaitant tuos, už kuriuos jau sumokėjote. return_exceptions=True tai pakeičia – kiekviena užduotis grąžina arba savo rezultatą, arba savo išimtį, o jūs patys nusprendžiate, ką daryti su nesėkmėmis, neaukodami sėkmingų rezultatų.

async def safe_generate(prompt):
    """Generuoja vaizdą su klaidų valdymu."""
    try:
        return await generate_image(prompt)
    except Exception as e:
        print(f"Klaida užuominai '{prompt[:30]}...' : {e}")
        return None

Svarbiausi punktai

  • AsyncOpenAI klientas leidžia vykdyti lygiagrečias užklausas naudojant asyncio
  • Naudokite asyncio.gather, kad vienu metu paleistumėte kelis generavimus
  • Ribokite lygiagretumą naudodami semaforą, kad laikytumėtės užklausų ribų
  • Nauda artėja prie vienu metu vykdomų užklausų skaičiaus, neviršijant leidžiamo pralaidumo ribos (6 užklausos per sekundę pradiniame lygmenyje)
  • Valdykite klaidas individualiai, kad išvengtumėte visos grupės praradimo