Salt la conținutul principal
Română— Alege o limbă
Meniu

Client asincron și performanță

Lecția 10 din 14 Actualizată 3 noiembrie 2026 Începător
Pe această pagină
  1. Optimizarea performanței cu Async
  2. Clientul AsyncOpenAI
  3. Cereri paralele cu asyncio.gather
  4. Controlul paralelismului
  5. Pipeline asincron complet
  6. Comparație între Sincron și Asincron
  7. Gestionarea erorilor
  8. Puncte cheie

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 AsyncOpenAI permite cereri paralele prin asyncio
  • Utilizați asyncio.gather pentru 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