Асинхронен клиент и производителност
На тази страница
Обновено на 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 заявки в секунда за началното ниво)
- Обработвайте грешките индивидуално, за да избегнете загубата на целия пакет