Премини към основното съдържание
Български— Изберете език
Меню

Асинхронен клиент и производителност

Урок 10 от 14 Обновен 3 ноември 2026 г. Начинаещ
На тази страница
  1. Оптимизиране на производителността с асинхронност
  2. Клиентът AsyncOpenAI
  3. Паралелни заявки с asyncio.gather
  4. Контрол на паралелизма
  5. Пълен асинхронен конвейер
  6. Сравнение между синхронно и асинхронно изпълнение
  7. Обработка на грешки
  8. Ключови изводи

Обновено на 3 ноември 2026 г. въз основа на страницата Rate limits на xAI и справочника за Images API: Лимитите на модела Imagine се броят като заявки в секунда – 6 за началното ниво, 100 за най-високото ниво, а не „30 в минута“; семафорът ограничава едновременните заявки, а не пропускателната способност; изображенията се генерират по подразбиране като JPEG; и конкретните тайминги от старата версия, които не произлизаха от публикувани измервания, отстъпват място на изчисление. Източници: Rate limits · Images API.

Оптимизиране на производителността с асинхронност

Когато трябва да генерирате или редактирате много изображения, последователните извиквания се превръщат в тясно място. Асинхронният клиент на xAI API Ви позволява да изпълнявате множество заявки паралелно, което значително намалява общото време за обработка.

Клиентът AsyncOpenAI

Асинхронността не прави едно единствено генериране по-бързо: една заявка за изображение отнема точно същото количество време. Това, което елиминира, е ненужното чакане между заявките – докато първото изображение се изчислява на сървъра, Вашата програма може да поиска още десет, вместо да остане блокирана. Ето защо печалбата е нулева за едно изображение и драматична за петдесет.

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):
    """Generates an image asynchronously."""
    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())

Паралелни заявки с asyncio.gather

asyncio.gather стартира всички заявки и след това изчаква наборът да приключи. Общата продължителност става тази на най-бавната, а не сумата от всички – това е цялата разлика и ще я видите дори само с три или четири изображения.

async def generate_batch(prompts):
    """Generates images for multiple prompts in parallel."""
    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())

С пет подкана, вместо да чакате всяка заявка да приключи, преди да стартирате следващата, всичките пет изображения се изчисляват едновременно: общото време се доближава до това на най-бавната заявка.

Контрол на паралелизма

Без ограничение, gather стартира всичко наведнъж – и петдесет едновременни заявки към модел, ограничен до 6 заявки в секунда на началното ниво, произвеждат лавина от грешки 429, която Ви струва повече време от последователното изпълнение. Следователно семафорът не е по желание предпазна мярка: той е това, което прави паралелизма използваем. Калибрирайте го спрямо лимита на скоростта на модела, никога спрямо капацитета на Вашата машина.

async def generate_with_limit(prompts, max_concurrent=5):
    """Generates images with a maximum number of parallel requests."""
    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 и grok-imagine-image-2.0 показват 6 заявки в секунда за началното ниво, лимит, който нараства с нивото на Вашия екип до 100. Забележка: семафорът ограничава едновременните заявки, а не пропускателната способност. С max_concurrent=5, оставате под 6 заявки в секунда, стига всяко генериране да отнема повече от една секунда; ако отговорите пристигат по-бързо, разпределете подаването на заявки също така. Проверете лимитите на Вашия екип в конзолата на xAI, преди да ги увеличите.

Пълен асинхронен конвейер

Този конвейер свързва трите операции, които трябва да вървят заедно: генериране, незабавно изтегляне (URL адресите изтичат) и изолиране на грешките. При голям пакет тази трета точка прави разликата между един инцидент и пълна загуба.

import aiohttp
import aiofiles

async def download_image(session, url, filepath):
    """Downloads an image asynchronously."""
    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"):
    """Complete pipeline: generation + download."""
    os.makedirs(output_dir, exist_ok=True)

    # Step 1: generate all images in parallel
    urls = await generate_with_limit(prompts, max_concurrent=5)

    # Step 2: download all images in parallel
    async with aiohttp.ClientSession() as session:
        download_tasks = []
        for i, url in enumerate(urls):
            if url:
                # JPEG by default (image/jpeg), unless quality setting produces 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)} images generated and saved")

Сравнение между синхронно и асинхронно изпълнение

Печалбата се изчислява на хартия. Ако едно генериране отнема T секунди, двадесет изображения, поискани едно след друго, отнемат около 20 × T. С пет едновременни заявки те вървят на вълни от по пет: около 4 × T, печалба, близка до пет, броят на едновременните заявки – при условие че оставате под лимита на пропускателната способност. Измерете T във Вашия собствен акаунт, преди да поемете срок: страниците с изображения на xAI не посочват време за генериране и то варира в зависимост от модела, резолюцията и натоварването.

Обработка на грешки

Стандартното поведение на gather е брутално: изключение в една задача изхвърля грешката нагоре и губите резултатите от другите, включително тези, за които вече сте платили. return_exceptions=True променя това – всяка задача връща или своя резултат, или своето изключение, и Вие решавате какво да правите с неуспехите, без да жертвате успехите.

async def safe_generate(prompt):
    """Generates an image with error handling."""
    try:
        return await generate_image(prompt)
    except Exception as e:
        print(f"Error for '{prompt[:30]}...' : {e}")
        return None

Ключови изводи

  • Клиентът AsyncOpenAI позволява паралелни заявки чрез asyncio
  • Използвайте asyncio.gather, за да стартирате множество генерирания едновременно
  • Ограничете едновременността със семафор, за да спазвате лимитите на скоростта
  • Печалбата се доближава до броя на едновременните заявки, в рамките на разрешения лимит на пропускателната способност (6 заявки в секунда за началното ниво)
  • Обработвайте грешките индивидуално, за да избегнете загубата на целия пакет