asyncio.gather für die Batch-Verarbeitung
Auf dieser Seite
Orchestrierung paralleler Anfragen
asyncio.gather ist die Kernfunktion zum parallelen Ausführen mehrerer Koroutinen und dem Sammeln aller Ergebnisse. In Kombination mit einem Semaphore ermöglicht es die effiziente Verarbeitung von Batch-Anfragen unter Einhaltung der API-Grenzen.
Grundlegende Syntax
import asyncio
requests = ["Frage 1", "Frage 2", "Frage 3"]
tasks = [process_request(r) for r in requests]
responses = await asyncio.gather(*tasks)
asyncio.gather nimmt eine variable Anzahl von Koroutinen entgegen (daher das *tasks zum Entpacken der Liste) und gibt eine Liste von Ergebnissen zurück, die in derselben Reihenfolge wie die eingereichten Aufgaben stehen. Dies ist ein wichtiger Punkt: Selbst wenn Frage 3 vor Frage 1 fertig wird, enthält responses[0] immer das Ergebnis für Frage 1.
Komplettes Muster: Batch mit Semaphore
Dies ist das Muster, das Sie in der Produktion am häufigsten verwenden werden:
import os
from asyncio import Semaphore
from openai import AsyncOpenAI
import httpx
client = AsyncOpenAI(
api_key=os.getenv("XAI_API_KEY"),
base_url="https://api.x.ai/v1",
timeout=httpx.Timeout(3600.0)
)
async def process_batch(prompts: list[str], max_concurrent: int = 5) -> list[str]:
sem = Semaphore(max_concurrent)
async def single_request(prompt: str) -> str:
async with sem:
response = await client.chat.completions.create(
model="grok-4.5",
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content
tasks = [single_request(p) for p in prompts]
return await asyncio.gather(*tasks)
Dieses Muster kapselt den Semaphore innerhalb der Batch-Funktion ein. Sie müssen lediglich process_batch(prompts) aufrufen und die Liste der Antworten abrufen.
Fehlerbehandlung in einem Batch
Standardmäßig führt asyncio.gather bei einer Ausnahme in einer einzelnen Koroutine dazu, dass alles abgebrochen wird und der Fehler propagiert wird. Der Parameter return_exceptions=True ändert dieses Verhalten:
async def safe_batch(prompts: list[str]) -> list[str | Exception]:
sem = Semaphore(5)
async def single_request(prompt: str) -> str:
async with sem:
response = await client.chat.completions.create(
model="grok-4.5",
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content
tasks = [single_request(p) for p in prompts]
results = await asyncio.gather(*tasks, return_exceptions=True)
return results
# Usage
results = await safe_batch(mes_prompts)
for i, result in enumerate(results):
if isinstance(result, Exception):
print(f"Fehler bei Prompt {i}: {result}")
else:
print(f"Ergebnis {i}: {result[:100]}...")
Mit return_exceptions=True werden Fehler als Werte in der Ergebnisliste erfasst. Sie können dann fehlgeschlagene Anfragen identifizieren und erneut versuchen.
Aufteilung in Teilbatches (Chunking)
Bei sehr großen Volumina ist es besser, in Teilbatches aufzuteilen, als tausende Aufgaben gleichzeitig zu starten:
async def chunked_batch(
prompts: list[str],
chunk_size: int = 50,
max_concurrent: int = 5
) -> list[str]:
all_results = []
for i in range(0, len(prompts), chunk_size):
chunk = prompts[i:i + chunk_size]
print(f"Verarbeite Batch {i//chunk_size + 1} ({len(chunk)} Prompts)")
results = await process_batch(chunk, max_concurrent)
all_results.extend(results)
return all_results
Chunking bietet mehrere Vorteile: Sie können den Fortschritt anzeigen, Zwischenergebnisse speichern und den Speicherverbrauch begrenzen. Wenn ein Teilbatch fehlschlägt, verlieren Sie nicht die Ergebnisse vorheriger Teilbatches.
Fortschrittsverfolgung
Bei großen Batches ist ein Fortschrittsanzeige nützlich:
import asyncio
from asyncio import Semaphore
async def batch_with_progress(prompts: list[str], max_concurrent: int = 5) -> list[str]:
sem = Semaphore(max_concurrent)
completed = 0
total = len(prompts)
async def single_request(prompt: str) -> str:
nonlocal completed
async with sem:
response = await client.chat.completions.create(
model="grok-4.5",
messages=[{"role": "user", "content": prompt}]
)
completed += 1
print(f"\r{completed}/{total} abgeschlossen", end="", flush=True)
return response.choices[0].message.content
tasks = [single_request(p) for p in prompts]
results = await asyncio.gather(*tasks)
print() # neue Zeile nach Fortschritt
return results
Kernaussagen
asyncio.gather(*tasks)führt Koroutinen parallel aus und gibt Ergebnisse in der ursprünglichen Reihenfolge zurückreturn_exceptions=Trueverhindert, dass ein einzelner Fehler den gesamten Batch versagt- Chunking ermöglicht die Handhabung sehr großer Volumina ohne Speicherüberlastung
- Kombinieren Sie
gatherimmer mit einem Semaphore, um Rate-Limits einzuhalten - Fügen Sie eine Fortschrittsverfolgung für langlaufende Prozesse hinzu