Asünkroonne klient ja jõudlus
Sellel lehel
Uuendatud 3. novembril 2026, tuginedes xAI kasutuspiirangute lehele ja piltide API referentsile: Imagine mudeli piirangud loetakse taotlusteks sekundis – 6 sisemisel tasemel, 100 kõrgeimal tasemel – mitte „30 minutis“; semafor piirab samaaegseid taotlusi, mitte läbilaskevõimet; pildid väljastatakse vaikimisi JPEG-vormingus; ja vana versiooni konkreetsed ajastused, mis ei põhinenud avaldatud mõõtmistel, asendatakse arvutusega. Allikad: Kasutuspiirangud · Piltide API.
Jõudluse optimeerimine asünkroonsusega
Kui sul on vaja genereerida või redigeerida palju pilte, muutuvad järjestikused väljakutsed kitsaskohaks. xAI API asünkroonne klient võimaldab sul käivitada mitu taotlust paralleelselt, vähendades oluliselt üldist töötlemisaega.
AsyncOpenAI klient
Asünkroonsus ei tee üksikut genereerimist kiiremaks: ühe pildi taotlus võtab täpselt sama palju aega. See, mida see kõrvaldab, on tarbetu ootamine taotluste vahel – samal ajal kui server arvutab esimest pilti, saab sinu programm taotleda kümnet teist, selle asemel et blokeeritud olekus seista. Seetõttu on kasu ühe pildi puhul null, kuid viiekümne puhul tohutu.
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):
"""Genereerib pildi asünkroonselt."""
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())
Paralleelsed taotlused koos asyncio.gather-iga
asyncio.gather käivitab kõik taotlused ja ootab seejärel komplekti lõpetamist. Kogukestus võrdub aeglaseima taotluse ajaga, mitte kõigi summa – selles seisnebki kogu erinevus, mida märkad juba kolme või nelja pildi puhul.
async def generate_batch(prompts):
"""Genereerib pilte mitme vihje jaoks paralleelselt."""
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())
Viie vihje korral ei oodata iga taotluse lõppemist enne järgmise käivitamist; kõik viis pilti arvutatakse samaaegselt: koguaeg läheneb aeglaseima taotluse ajale.
Paralleelsuse kontrollimine
Piiranguta käivitab gather kõik korraga – ja viiskümmend samaaegset taotlust mudelile, mille sisemine tase on piiratud 6 taotlusega sekundis, tekitab 429 vea laviini, mis maksab sulle rohkem aega kui järjestikune täitmine. Semafor ei ole seega valikuline ettevaatusabinõu: just see teeb paralleelsuse kasutatavaks. Kalibreeri see mudeli kasutuspiirangu järgi, mitte kunagi oma masina võimsuse järgi.
async def generate_with_limit(prompts, max_concurrent=5):
"""Genereerib pilte maksimaalse paralleelsete taotluste arvuga."""
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 ja grok-imagine-image-2.0 ametlikud lehed näitavad sisemisel tasemel 6 taotlust sekundis, mis kasvab koos sinu meeskonna tasemega kuni 100-ni. Märkus: semafor piirab samaaegseid taotlusi, mitte läbilaskevõimet. Seades max_concurrent=5, jääd alla 6 taotluse sekundis, kui iga genereerimine kestab üle ühe sekundi; kui vastused saabuavad kiiremini, tuleb esitamiste vahele jätta rohkem ruumi. Enne suurendamist kontrolli oma meeskonna piiranguid xAI konsoolist.
Täielik asünkroonne torustik
See torustik ühendab kolm operatsiooni, mis peavad koos toimima: genereerimine, kohene allalaadimine (URL-id aeguvad) ja vigade isoleerimine. Suure partii puhul teeb see kolmas punkt vahet intsidenti ja täieliku kaotuse vahel.
import aiohttp
import aiofiles
async def download_image(session, url, filepath):
"""Laadib pildi asünkroonselt alla."""
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"):
"""Täielik torustik: genereerimine + allalaadimine."""
os.makedirs(output_dir, exist_ok=True)
# 1. samm: genereeri kõik pildid paralleelselt
urls = await generate_with_limit(prompts, max_concurrent=5)
# 2. samm: laadi kõik pildid paralleelselt alla
async with aiohttp.ClientSession() as session:
download_tasks = []
for i, url in enumerate(urls):
if url:
# Vaikimisi JPEG (image/jpeg), välja arvatud kui kvaliteediseade toodab 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)} pilti genereeritud ja salvestatud")
Sünkroonse ja asünkroonse võrdlus
Kasu on arvutatav paberil. Kui üks genereerimine võtab T sekundit, võtab kakskümmend üksteise järel taotletud pilti umbes 20 × T. Viie samaaegse taotlusega liiguvad need viiekaupa lainetena: umbes 4 × T, mis annab kasu ligikaudu viiekordselt, võrdne samaaegsete taotluste arvuga – eeldusel, et püsidad läbilaskevõime piiri sees. Mõõda T oma kontol enne tähtaja lubamist: xAI piltide lehed ei anna genereerimisaega ja see varieerub sõltuvalt mudelist, eraldusvõimest ja koormusest.
Veakäsitlus
gatheri vaikimisi käitumine on brutaalne: erind ühes ülesandes tõstab vea üles ja kaotad teiste tulemused, sealhulgas need, mille eest on juba makstud. return_exceptions=True muudab seda – iga ülesanne tagastab kas oma tulemuse või erindi ning sina otsustad, mida vigadega ette võtta, ilma et ohverdaksid õnnestumisi.
async def safe_generate(prompt):
"""Genereerib pildi veakäsitlusega."""
try:
return await generate_image(prompt)
except Exception as e:
print(f"Viga '{prompt[:30]}...' puhul: {e}")
return None
Peamised punktid
- Klient
AsyncOpenAIvõimaldab paralleelseid taotlusiasynciokaudu - Kasuta
asyncio.gathermitme genereerimise samaaegseks käivitamiseks - Piira samaaegsust semaforiga, et austada kasutuspiiranguid
- Kasu läheneb samaaegsete taotluste arvule, jäädes lubatud läbilaskevõime piiridesse (6 taotlust sekundis sisemisel tasemel)
- Käitle vigu individuaalselt, et vältida kogu partii kaotamist