Async-klient og ydeevne
På denne side
Opdateret 3. november 2026 baseret på xAI-siden Rate limits og referencen til Images API: Grænser for Imagine-modellen tæller som anmodninger per sekund – 6 på entry-niveauet, 100 på det højeste niveau – ikke “30 per minut”; en semaphore begrænser samtidige anmodninger, ikke gennemstrømning; billeder outputtes som JPEG som standard; og de specifikke tidsmålinger fra den gamle version, som ikke stammede fra nogen offentliggjort måling, erstattes af en beregning. Kilder: Rate limits · Images API.
Optimer ydeevnen med Async
Når du skal generere eller redigere mange billeder, bliver sekventielle kald til en flaskehals. xAI API’s async-klient lader dig køre flere anmodninger parallelt, hvilket reducerer den samlede behandlingstid markant.
AsyncOpenAI-klienten
Async gør ikke en enkelt generering hurtigere: En enkelt billedanmodning tager præcis lige så lang tid. Det, den eliminerer, er unødvendig ventetid mellem anmodninger – mens det første billede beregnes på serveren, kan dit program anmode om ti andre i stedet for at stå blokeret. Derfor er gevinsten nul ved ét billede og dramatisk ved halvtreds.
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):
"""Genererer et billede asynkront."""
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())
Parallelle anmodninger med asyncio.gather
asyncio.gather starter alle anmodninger og venter derefter på, at sættet bliver færdigt. Den samlede varighed bliver den for den langsomste, ikke summen af alle – det er hele forskellen, og du ser det allerede med tre eller fire billeder.
async def generate_batch(prompts):
"""Genererer billeder for flere prompts parallelt."""
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())
Med fem prompts venter du ikke på, at hver anmodning bliver færdig, før du starter den næste; alle fem billeder beregnes på samme tid: Den samlede tid nærmer sig den for den langsomste anmodning.
Styr parallelismen
Uden en grænse starter gather alt på én gang – og halvtreds samtidige anmodninger på en model, der er begrænset til 6 anmodninger per sekund på entry-niveauet, producerer en lavine af 429-fejl, der koster dig mere tid end sekventiel eksekvering. Semaphoren er derfor ikke en valgfri forholdsregel: Det er det, der gør parallelisme brugbar. Kalibrer den til modellens hastighedsgrænse, aldrig til din maskines kapacitet.
async def generate_with_limit(prompts, max_concurrent=5):
"""Genererer billeder med et maksimalt antal parallelle anmodninger."""
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)
De officielle ark for grok-imagine-image og grok-imagine-image-2.0 angiver 6 anmodninger per sekund på entry-niveauet, en grænse, der vokser med dit teams niveau op til 100. Bemærk: En semaphore begrænser samtidige anmodninger, ikke gennemstrømning. Med max_concurrent=5 holder du dig under 6 anmodninger per sekund, så længe hver generering varer mere end ét sekund; hvis dine svar ankommer hurtigere, skal du også sprede indsendelserne ud. Tjek dit teams grænser i xAI-konsollen, før du øger dem.
Komplet async-pipeline
Denne pipeline kæder de tre operationer sammen, der skal hænge sammen: Generer, download øjeblikkeligt – URLs udløber – og isoler fejl. Ved en stor batch gør dette tredje punkt forskellen mellem en hændelse og et totalt tab.
import aiohttp
import aiofiles
async def download_image(session, url, filepath):
"""Downloader et billede asynkront."""
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"):
"""Komplet pipeline: generering + download."""
os.makedirs(output_dir, exist_ok=True)
# Trin 1: Generer alle billeder parallelt
urls = await generate_with_limit(prompts, max_concurrent=5)
# Trin 2: Download alle billeder parallelt
async with aiohttp.ClientSession() as session:
download_tasks = []
for i, url in enumerate(urls):
if url:
# JPEG som standard (image/jpeg), medmindre kvalitetsindstilling producerer 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)} billeder genereret og gemt")
Sammenligning: Synkron vs. Asynkron
Gevinsten kan beregnes på papiret. Hvis én generering tager T sekunder, tager tyve billeder, der anmodes én efter én, ca. 20 × T. Med fem samtidige anmodninger sker de i bølger på fem: ca. 4 × T, en gevinst tæt på fem, hvilket er antallet af samtidige anmodninger – forudsat at du holder dig under gennemstrømningsgrænsen. Mål T på din egen konto, før du lover en deadline: xAI’s billedsider angiver ingen genereringstid, og den varierer med model, opløsning og belastning.
Håndtering af fejl
gather’s standardadfærd er brutal: En undtagelse i én opgave bobler fejlen op, og du mister resultaterne fra de andre, inklusive dem, du allerede har betalt for. return_exceptions=True ændrer dette – hver opgave returnerer enten sit resultat eller sin undtagelse, og du beslutter, hvad du vil gøre med fejl uden at ofre succeserne.
async def safe_generate(prompt):
"""Genererer et billede med fejlhåndtering."""
try:
return await generate_image(prompt)
except Exception as e:
print(f"Fejl for '{prompt[:30]}...' : {e}")
return None
Vigtige pointer
AsyncOpenAI-klienten muliggør parallelle anmodninger viaasyncio- Brug
asyncio.gathertil at starte flere genereringer samtidigt - Begræns samtidighed med en semaphore for at overholde hastighedsgrænser
- Gevinsten nærmer sig antallet af samtidige anmodninger, inden for den tilladte gennemstrømningsgrænse (6 anmodninger per sekund på entry-niveauet)
- Håndter fejl individuelt for at undgå at miste hele batchen