Odjemalec asinhrono in zmogljivost
Na tej strani
Posodobljeno 3. novembra 2026 na podlagi strani xAI Rate limits in referenčne dokumentacije API-ja za slike: omejitve modela Imagine se štejejo kot zahtevke na sekundo—6 na osnovni ravni, 100 na najvišji ravni—ne “30 na minuto”; semafor omejuje sočasne zahtevke, ne prepustnosti; slike so privzeto izhodne kot JPEG; specifični časi iz stare različice, ki niso temeljili na nobeni objavljeni meritvi, so nadomeščeni z izračunom. Viri: Rate limits · Images API.
Optimizacija zmogljivosti z asinhronostjo
Ko moraš ustvariti ali urediti veliko slik, zaporedni klici postanejo ozko grlo. Asinhroni odjemalec API-ja xAI ti omogoča vzporedno izvajanje več zahtevkov, kar bistveno skrajša skupni čas obdelave.
Odjemalec AsyncOpenAI
Asinhronost ne pospeši posameznega ustvarjanja: zahtevek za eno sliko traja točno toliko časa kot prej. Kar odpravi, je nepotrebno čakanje med zahtevki—medtem ko strežnik izračunava prvo sliko, lahko tvoj program zahteva še deset drugih, namesto da bi ostal blokiran. Zato je pri eni sliki dobiček ničelen, pri petdesetih pa dramatičen.
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):
"""Asinhrono ustvari sliko."""
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())
Vzporedni zahtevki z asyncio.gather
asyncio.gather sproži vse zahtevke hkrati, nato pa počaka, da se celoten niz konča. Skupno trajanje postane enako trajanju najpočasnejšega zahtevka, ne vsoti vseh—v tem je bistvena razlika, ki jo opaziš že pri treh ali štirih slikah.
async def generate_batch(prompts):
"""Vzporedno ustvari slike za več pozivov."""
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())
Pri petih pozivih se namesto čakanja na zaključek vsakega zahtevka pred sprožitvijo naslednjega, vseh pet slik izračuna hkrati: skupni čas se približa času najpočasnejšega zahtevka.
Nadzor vzporednosti
Brez omejitve gather sproži vse hkrati—petdeset sočasnih zahtevkov na modelu, omejenem na 6 zahtevkov na sekundo na osnovni ravni, povzroči plaz napak 429, ki te stane več časa kot zaporedno izvajanje. Semafor zato ni izbirni previdnostni ukrep: je tisto, kar naredi vzporednost uporabno. Prilagodi ga omejitvi hitrosti modela, nikoli zmogljivosti svojega stroja.
async def generate_with_limit(prompts, max_concurrent=5):
"""Ustvari slike z največjim številom vzporednih zahtevkov."""
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)
Uradni listi za grok-imagine-image in grok-imagine-image-2.0 navajajo 6 zahtevkov na sekundo na osnovni ravni, omejitev pa narašča z ravnjo tvoje ekipe do 100. Opomba: semafor omejuje sočasne zahtevke, ne prepustnosti. Z max_concurrent=5 ostaneš pod 6 zahtevki na sekundo, dokler vsako ustvarjanje traja več kot eno sekundo; če odgovori prispejo hitreje, moraš oddajo zahtevkov tudi razmakniti. Pred povečanjem preveri omejitve svoje ekipe v konzoli xAI.
Celoten asinhroni potek dela
Ta potek povezuje tri operacije, ki morajo delovati skupaj: ustvarjanje, takojšnji prenos (URL-ji potečejo) in izolacija napak. Pri velikem nizu je ta tretja točka tista, ki odloča med manjšim incidentom in popolno izgubo.
import aiohttp
import aiofiles
async def download_image(session, url, filepath):
"""Asinhrono prenese sliko."""
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"):
"""Celoten potek: ustvarjanje + prenos."""
os.makedirs(output_dir, exist_ok=True)
# 1. korak: vzporedno ustvari vse slike
urls = await generate_with_limit(prompts, max_concurrent=5)
# 2. korak: vzporedno prenesi vse slike
async with aiohttp.ClientSession() as session:
download_tasks = []
for i, url in enumerate(urls):
if url:
# Privzeto JPEG (image/jpeg), razen če nastavitev kakovosti proizvede 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)} slik ustvarjenih in shranjenih")
Primerjava sinhrono proti asinhrono
Dobiček je mogoče izračunati na papirju. Če eno ustvarjanje traja T sekund, dvajset slik, zahtevanih ena za drugo, traja približno 20 × T. S petimi sočasnimi zahtevki potekajo v valovih po pet: približno 4 × T, kar pomeni dobiček blizu pet, kar je število sočasnih zahtevkov—pod pogojem, da ostaneš znotraj omejitve prepustnosti. Izmeri T na svojem računu, preden obljubiš rok: strani za slike xAI ne navajajo časa ustvarjanja, ta pa se spreminja glede na model, ločljivost in obremenitev.
Obravnava napak
Privzeto vedenje gather je surovo: izjema v eni nalogi prenese napako navzgor in izgubiš rezultate drugih, vključno s tistimi, za katere si že plačal. return_exceptions=True to spremeni—vsaka naloga vrne bodisi svoj rezultat bodisi svojo izjemo, ti pa se odločiš, kaj storiti z napakami, ne da bi žrtvoval uspehe.
async def safe_generate(prompt):
"""Ustvari sliko z obravnavo napak."""
try:
return await generate_image(prompt)
except Exception as e:
print(f"Napaka za '{prompt[:30]}...' : {e}")
return None
Ključne ugotovitve
- Odjemalec
AsyncOpenAIomogoča vzporedne zahtevke prekasyncio - Uporabi
asyncio.gatherza sočasno sprožitev več ustvarjanj - Omeji vzporednost s semaforjem, da spoštuješ omejitve hitrosti
- Dobiček se približa številu sočasnih zahtevkov, znotraj dovoljene omejitve prepustnosti (6 zahtevkov na sekundo na osnovni ravni)
- Napake obravnavaj posamično, da se izogneš izgubi celotnega niza