Asynchroner Client und Leistung
Auf dieser Seite
Aktualisiert am 3. November 2026 basierend auf der xAI-Seite zu Rate Limits und der Referenz für die Images API: Die Limits des Imagine-Modells werden pro Sekunde gezählt – 6 beim Einstiegs-Tarif und 100 beim höchsten Tarif – und nicht als „30 pro Minute”. Ein Semaphore begrenzt die gleichzeitigen Anfragen, nicht den Durchsatz. Bilder werden standardmäßig als JPEG ausgegeben. Die spezifischen Zeitangaben der alten Version, die auf keiner veröffentlichten Messung basierten, weichen einer Berechnung. Quellen: Rate Limits · Images API.
Leistung mit Asynchronie optimieren
Wenn Sie viele Bilder generieren oder bearbeiten müssen, werden sequenzielle Aufrufe zum Flaschenhals. Der asynchrone Client der xAI API ermöglicht es Ihnen, mehrere Anfragen parallel auszuführen und die gesamte Verarbeitungszeit erheblich zu verkürzen.
Der AsyncOpenAI-Client
Asynchronie macht eine einzelne Generierung nicht schneller: Eine einzelne Bildanfrage dauert exakt so lange wie zuvor. Was sie eliminiert, ist das unnötige Warten zwischen den Anfragen – während das erste Bild auf dem Server berechnet wird, kann Ihr Programm zehn weitere anfordern, statt blockiert zu bleiben. Deshalb ist der Gewinn bei einem Bild null, aber bei fünfzig Bildern dramatisch.
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):
"""Generiert ein Bild asynchron."""
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())
Parallele Anfragen mit asyncio.gather
asyncio.gather startet alle Anfragen und wartet darauf, dass die Menge abgeschlossen ist. Die Gesamtdauer entspricht der des langsamensten Vorgangs, nicht der Summe aller – das ist der gesamte Unterschied, und Sie sehen ihn bereits mit drei oder vier Bildern.
async def generate_batch(prompts):
"""Generiert Bilder für mehrere Prompts parallel."""
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())
Bei fünf Prompts warten Sie nicht, bis jede Anfrage abgeschlossen ist, bevor Sie die nächste starten. Alle fünf Bilder werden gleichzeitig berechnet: Die Gesamtzeit nähert sich der Dauer des langsamsten Vorgangs.
Parallelität steuern
Ohne Limitierung startet gather alles auf einmal – und fünfzig gleichzeitige Anfragen bei einem Modell, das am Einstiegs-Tarif auf 6 Anfragen pro Sekunde begrenzt ist, produzieren eine Lawine von 429-Fehlern, die Ihnen mehr Zeit kostet als eine sequenzielle Ausführung. Der Semaphore ist daher keine optionale Vorsichtsmaßnahme: Er macht Parallelität erst nutzbar. Kalibrieren Sie ihn an das Modells-Rate Limit, niemals an die Kapazität Ihrer Maschine.
async def generate_with_limit(prompts, max_concurrent=5):
"""Generiert Bilder mit einer maximalen Anzahl paralleler Anfragen."""
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)
Die offiziellen Tabellen für grok-imagine-image und grok-imagine-image-2.0 geben 6 Anfragen pro Sekunde am Einstiegs-Tarif an, ein Limit, das mit dem Tarif Ihres Teams bis zu 100 wächst. Hinweis: Ein Semaphore begrenzt gleichzeitige Anfragen, nicht den Durchsatz. Bei max_concurrent=5 bleiben Sie unter 6 Anfragen pro Sekunde, solange jede Generierung länger als eine Sekunde dauert; wenn Ihre Antworten schneller eintreffen, verteilen Sie die Einreichungen ebenfalls. Prüfen Sie die Limits Ihres Teams in der xAI-Konsole, bevor Sie diese erhöhen.
Kompletter asynchroner Pipeline
Diese Pipeline verknüpft die drei Operationen, die zusammengehören: Generieren, sofortiges Herunterladen – URLs verfallen – und Isolierung von Fehlern. Bei einem großen Batch macht dieser dritte Punkt den Unterschied zwischen einem Vorfall und einem Totalverlust.
import aiohttp
import aiofiles
async def download_image(session, url, filepath):
"""Lädt ein Bild asynchron herunter."""
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"):
"""Komplette Pipeline: Generierung + Download."""
os.makedirs(output_dir, exist_ok=True)
# Schritt 1: Alle Bilder parallel generieren
urls = await generate_with_limit(prompts, max_concurrent=5)
# Schritt 2: Alle Bilder parallel herunterladen
async with aiohttp.ClientSession() as session:
download_tasks = []
for i, url in enumerate(urls):
if url:
# Standardmäßig JPEG (image/jpeg), es sei denn, die Qualitätseinstellung erzeugt ein 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)} Bilder generiert und gespeichert")
Synchron vs. Asynchron: Vergleich
Der Gewinn berechnet sich auf dem Papier. Wenn eine Generierung T Sekunden dauert, benötigen 20 nacheinander angeforderte Bilder etwa 20 × T. Mit fünf gleichzeitigen Anfragen gehen sie in Wellen von fünf: etwa 4 × T, ein Gewinn, der der Anzahl der gleichzeitigen Anfragen nahe kommt – sofern Sie unter dem Durchsatzlimit bleiben. Messen Sie T auf Ihrem eigenen Konto, bevor Sie eine Frist zusichern: Die Bildseiten von xAI geben keine Generierungszeit an, und diese variiert je nach Modell, Auflösung und Last.
Fehlerbehandlung
Das Standardverhalten von gather ist brutal: Eine Ausnahme in einer Aufgabe lässt den Fehler aufsteigen und Sie verlieren die Ergebnisse der anderen, einschließlich der bereits bezahlten. return_exceptions=True ändert dies – jede Aufgabe gibt entweder ihr Ergebnis oder ihre Ausnahme zurück, und Sie entscheiden, was Sie mit den Fehlern tun, ohne die Erfolge zu opfern.
async def safe_generate(prompt):
"""Generiert ein Bild mit Fehlerbehandlung."""
try:
return await generate_image(prompt)
except Exception as e:
print(f"Error for '{prompt[:30]}...' : {e}")
return None
Kernaussagen
- Der
AsyncOpenAI-Client ermöglicht parallele Anfragen überasyncio. - Verwenden Sie
asyncio.gather, um mehrere Generierungen gleichzeitig zu starten. - Begrenzen Sie die Parallelität mit einem Semaphore, um Rate Limits zu respektieren.
- Der Gewinn nähert sich der Anzahl der gleichzeitigen Anfragen, innerhalb des autorisierten Durchsatzlimits (6 Anfragen pro Sekunde am Einstiegs-Tarif).
- Behandeln Sie Fehler einzeln, um den gesamten Batch nicht zu verlieren.