Client asincron și performanță
Pe această pagină
Actualizat la 3 noiembrie 2026 pe baza paginii Rate limits de la xAI și a referinței API Images: limitele modelului Imagine se numără ca cereri pe secundă—6 la nivelul de intrare, 100 la cel mai înalt nivel—nu „30 pe minut“; un semafor limitează cererile concurente, nu debitul; imaginile sunt generate implicit ca JPEG; iar temporizările specifice din versiunea veche, care nu proveneau din nicio măsurătoare publicată, sunt înlocuite de un calcul. Surse: Rate limits · Images API.
Optimizarea performanței cu Async
Când trebuie să generați sau să editați multe imagini, apelurile secvențiale devin un blocaj. Clientul asincron al API-ului xAI vă permite să executați mai multe cereri în paralel, reducând semnificativ timpul total de procesare.
Clientul AsyncOpenAI
Asincronizarea nu face o singură generare mai rapidă: o cerere pentru o singură imagine durează exact același timp. Ceea ce elimină este așteptarea inutilă între cereri—în timp ce prima imagine este calculată pe server, programul dumneavoastră poate solicita alte zece în loc să rămână blocat. De aceea câștigul este zero pentru o imagine și dramatic pentru cincizeci.
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):
"""Generează o imagine în mod asincron."""
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())
Cereri paralele cu asyncio.gather
asyncio.gather lansează toate cererile, apoi așteaptă ca setul să se termine. Durata totală devine cea a celei mai lente cereri, nu suma tuturor—aceasta este întreaga diferență, pe care o observați deja cu doar trei sau patru imagini.
async def generate_batch(prompts):
"""Generează imagini pentru mai multe prompturi în paralel."""
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())
Cu cinci prompturi, în loc să așteptați ca fiecare cerere să se termine înainte de a o lansa pe următoarea, toate cele cinci imagini sunt calculate simultan: timpul total se apropie de cel al celei mai lente cereri.
Controlul paralelismului
Fără o limită, gather lansează totul deodată—iar cincizeci de cereri concurente pe un model limitat la 6 cereri pe secundă la nivelul de intrare produc o avalanșă de erori 429 care vă costă mai mult timp decât execuția secvențială. Semaforul nu este deci o precauție opțională: este ceea ce face paralelismul utilizabil. Calibrați-l la limita de rată a modelului, niciodată la capacitatea mașinii dumneavoastră.
async def generate_with_limit(prompts, max_concurrent=5):
"""Generează imagini cu un număr maxim de cereri paralele."""
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)
Fișele oficiale pentru grok-imagine-image și grok-imagine-image-2.0 indică 6 cereri pe secundă la nivelul de intrare, o limită care crește odată cu nivelul echipei dumneavoastră până la 100. Notă: un semafor limitează cererile concurente, nu debitul. Cu max_concurrent=5, rămâneți sub 6 cereri pe secundă atâta timp cât fiecare generare durează mai mult de o secundă; dacă răspunsurile sosesc mai repede, espațiați și trimiterile. Verificați limitele echipei dumneavoastră în consola xAI înainte de a le mări.
Pipeline asincron complet
Acest pipeline înlănțuiește cele trei operațiuni care trebuie să meargă împreună: generare, descărcare imediată—URL-urile expiră—și izolarea erorilor. La un lot mare, acest al treilea punct face diferența dintre un incident și o pierdere totală.
import aiohttp
import aiofiles
async def download_image(session, url, filepath):
"""Descarcă o imagine în mod asincron."""
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"):
"""Pipeline complet: generare + descărcare."""
os.makedirs(output_dir, exist_ok=True)
# Pasul 1: generarea tuturor imaginilor în paralel
urls = await generate_with_limit(prompts, max_concurrent=5)
# Pasul 2: descărcarea tuturor imaginilor în paralel
async with aiohttp.ClientSession() as session:
download_tasks = []
for i, url in enumerate(urls):
if url:
# JPEG implicit (image/jpeg), cu excepția cazului în care setarea calității produce 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)} imagini generate și salvate")
Comparație între Sincron și Asincron
Câștigul se calculează pe hârtie. Dacă o generare durează T secunde, douăzeci de imagini cerute una după alta durează aproximativ 20 × T. Cu cinci cereri concurente, ele merg în valuri de câte cinci: aproximativ 4 × T, un câștig apropiat de cinci, numărul de cereri concurente—cu condiția să rămâneți sub limita de debit. Măsurați T pe propriul cont înainte de a promite un termen limită: paginile de imagini xAI nu oferă niciun timp de generare, iar acesta variază în funcție de model, rezoluție și încărcare.
Gestionarea erorilor
Comportamentul implicit al lui gather este brutal: o excepție într-o sarcină propaga eroarea și pierdeți rezultatele celorlalte, inclusiv pe cele deja plătite. return_exceptions=True schimbă acest lucru—fiecare sarcină returnează fie rezultatul său, fie excepția sa, iar dumneavoastră decideți ce să faceți cu eșecurile fără a sacrifica succesele.
async def safe_generate(prompt):
"""Generează o imagine cu gestionarea erorilor."""
try:
return await generate_image(prompt)
except Exception as e:
print(f"Eroare pentru '{prompt[:30]}...' : {e}")
return None
Puncte cheie
- Clientul
AsyncOpenAIpermite cereri paralele prinasyncio - Utilizați
asyncio.gatherpentru a lansa mai multe generări simultan - Limitați concurența cu un semafor pentru a respecta limitele de rată
- Câștigul se apropie de numărul de cereri concurente, în limita debitului autorizat (6 cereri pe secundă la nivelul de intrare)
- Gestionați erorile individual pentru a evita pierderea întregului lot