Klients asinhronajam režīmam un veiktspēja
Šajā lapā
Atjaunināts 2026. gada 3. novembrī, pamatojoties uz xAI Rate limits lapu un attēlu API atsauces dokumentāciju: Imagine modeļa limiti tiek skaitīti kā pieprasījumi sekundē — 6 ievades līmenī, 100 augstākajā līmenī — nevis “30 minūtē”; semaforis ierobežo vienlaicīgos pieprasījumus, nevis caurlaidspēju; attēli pēc noklusējuma tiek ģenerēti JPEG formātā; un konkrētie laiki no vecās versijas, kas nebija balstīti uz publicētiem mērījumiem, tiek aizstāti ar aprēķinu. Avoti: Rate limits · Images API.
Veiktspējas optimizēšana ar asinhrono režīmu
Kad tev jāģenerē vai jārediģē daudz attēlu, secīgi izsaukumi kļūst par šauru vietu. xAI API asinhronais klients ļauj paralēli izpildīt vairākus pieprasījumus, ievērojami samazinot kopējo apstrādes laiku.
AsyncOpenAI klients
Asinhronais režīms nepaātrina vienu ģenerēšanu: viena attēla pieprasījums aizņem tieši tikpat daudz laika. Tas, ko tas novērš, ir lieka gaidīšana starp pieprasījumiem — kamēr serveris aprēķina pirmo attēlu, tava programma var pieprasīt vēl desmit citus, nevis palikt bloķēta. Tāpēc ieguvums vienam attēlam ir nulle, bet piecdesmit attēliem — dramatisks.
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):
"""Ģenerē attēlu asinhroni."""
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())
Paralēli pieprasījumi ar asyncio.gather
asyncio.gather palaiž visus pieprasījumus un tad gaida, līdz visa kopa ir pabeigta. Kopējais ilgums kļūst vienāds ar lēnākā pieprasījuma ilgumu, nevis visu summu — tieši šī ir galvenā atšķirība, ko pamanīsi jau ar trim vai četriem attēliem.
async def generate_batch(prompts):
"""Ģenerē attēlus vairākiem uzvedņiem paralēli."""
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())
Ar pieciem uzvedņiem, tā vietā, lai gaidītu katra pieprasījuma pabeigšanu pirms nākamā uzsākšanas, visi pieci attēli tiek aprēķināti vienlaicīgi: kopējais laiks tuvojas lēnākā pieprasījuma ilgumam.
Paralēlisma kontrole
Bez ierobežojuma gather palaiž visu uzreiz — un piecdesmit vienlaicīgi pieprasījumi modelim, kura ievades līmeņa limits ir 6 pieprasījumi sekundē, radīs 429 kļūdu lavīnu, kas tev izmaksās vairāk laika nekā secīga izpilde. Tāpēc semaforis nav tikai brīvprātīga piesardzība: tas ir tas, kas padara paralēlismu lietojamu. Kalibrē to atbilstoši modeļa pieprasījumu limitam, nevis savas mašīnas jaudai.
async def generate_with_limit(prompts, max_concurrent=5):
"""Ģenerē attēlus ar maksimālo paralēlo pieprasījumu skaitu."""
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)
Oficiālās lapas priekš grok-imagine-image un grok-imagine-image-2.0 norāda 6 pieprasījumus sekundē ievades līmenī; šis limits pieaug līdz ar tavas komandas līmeni līdz pat 100. Piezīme: semaforis ierobežo vienlaicīgos pieprasījumus, nevis caurlaidspēju. Ar max_concurrent=5 tu paliec zem 6 pieprasījumiem sekundē, kamēr katra ģenerēšana ilgst vairāk par vienu sekundi; ja atbildes pienāk ātrāk, arī iesniegšanu vajag izvietot retāk. Pirms limita palielināšanas pārbaudi savas komandas limitus xAI konsolē.
Pilnīga asinhronā cauruļvada sistēma
Šī cauruļvada sistēma savieno trīs operācijas, kurām jānotiek kopā: ģenerēšana, tūlītēja lejupielāde (URL adreses beidzas) un kļūdu izolēšana. Lielā datu kopā šis trešais punkts nosaka atšķirību starp incidentu un pilnīgu zaudējumu.
import aiohttp
import aiofiles
async def download_image(session, url, filepath):
"""Lejupielādē attēlu asinhroni."""
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"):
"""Pilnīga cauruļvada sistēma: ģenerēšana + lejupielāde."""
os.makedirs(output_dir, exist_ok=True)
# 1. solis: ģenerēt visus attēlus paralēli
urls = await generate_with_limit(prompts, max_concurrent=5)
# 2. solis: lejupielādēt visus attēlus paralēli
async with aiohttp.ClientSession() as session:
download_tasks = []
for i, url in enumerate(urls):
if url:
# Pēc noklusējuma JPEG (image/jpeg), ja vien kvalitātes iestatījums neizveido 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)} attēli ģenerēti un saglabāti")
Sinhronā un asinhronā režīma salīdzinājums
Ieguvumu var aprēķināt uz papīra. Ja viena ģenerēšana aizņem T sekundes, divdesmit attēli, kas pieprasīti viens pēc otra, aizņems aptuveni 20 × T. Ar pieciem vienlaicīgiem pieprasījumiem tie notiek viļņos pa pieciem: aptuveni 4 × T, kas nozīmē ieguvumu, kas tuvinās pieciem — vienlaicīgo pieprasījumu skaitam — ar nosacījumu, ka tiek ievērots caurlaidspējas limits. Izmēri T savā kontā, pirms solīji termiņu: xAI attēlu lapās nav norādīts ģenerēšanas laiks, un tas mainās atkarībā no modeļa, izšķirtspējas un slodzes.
Kļūdu apstrāde
gather noklusējuma uzvedība ir brutāla: izņēmums vienā uzdevumā paceļ kļūdu augšup, un tu zaudē pārējo rezultātus, tostarp tos, par kuriem jau samaksāts. return_exceptions=True to maina — katrs uzdevums atgriež vai nu savu rezultātu, vai savu izņēmumu, un tu pats lemj, ko darīt ar kļūdām, upurējot veiksmīgos rezultātus.
async def safe_generate(prompt):
"""Ģenerē attēlu ar kļūdu apstrādi."""
try:
return await generate_image(prompt)
except Exception as e:
print(f"Kļūda priekš '{prompt[:30]}...' : {e}")
return None
Galvenās atziņas
AsyncOpenAIklients ļauj veikt paralēlus pieprasījumus, izmantojotasyncio- Izmanto
asyncio.gather, lai vienlaicīgi uzsāktu vairākas ģenerēšanas - Ierobežo vienlaicīgumu ar semaforu, lai ievērotu pieprasījumu limitus
- Ieguvums tuvojas vienlaicīgo pieprasījumu skaitam, ievērojot atļauto caurlaidspējas limitu (6 pieprasījumi sekundē ievades līmenī)
- Apstrādā kļūdas individuāli, lai izvairītos no visas kopas zaudēšanas