asyncio.gather voor batchverwerking
Op deze pagina
Parallelle verzoeken orchestreren
asyncio.gather is de kernfunctie om meerdere coroutines parallel uit te voeren en alle resultaten te verzamelen. In combinatie met een semaphore kunt u batches met verzoeken efficiënt verwerken terwijl u de API-limieten respecteert.
Basis syntaxis
import asyncio
requests = ["Question 1", "Question 2", "Question 3"]
tasks = [process_request(r) for r in requests]
responses = await asyncio.gather(*tasks)
asyncio.gather accepteert een variabel aantal coroutines (vandaar de *tasks om de lijst uit te pakken) en retourneert een lijst met resultaten in dezelfde volgorde als de ingediende taken. Dit is een belangrijk punt: zelfs als vraag 3 eerder klaar is dan vraag 1, zal responses[0] altijd het resultaat voor vraag 1 bevatten.
Volledig patroon: Batch met semaphore
Dit is het patroon dat u het vaakst in productie zult gebruiken:
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)
Dit patroon kapselt de semaphore in binnen de batchfunctie. U hoeft alleen maar process_batch(prompts) aan te roepen om de lijst met antwoorden op te halen.
Foutafhandeling in een batch
Standaard annuleert asyncio.gather alles en propageert het de fout als één coroutine een uitzondering veroorzaakt. De parameter return_exceptions=True verandert dit gedrag:
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
# Gebruik
results = await safe_batch(mes_prompts)
for i, result in enumerate(results):
if isinstance(result, Exception):
print(f"Error on prompt {i}: {result}")
else:
print(f"Result {i}: {result[:100]}...")
Met return_exceptions=True worden fouten vastgelegd als waarden in de resultatenlijst. U kunt vervolgens mislukte verzoeken identificeren en opnieuw proberen.
Opsplitsen in sub-batches (chunking)
Bij zeer grote volumes is het beter om op te splitsen in sub-batches in plaats van duizenden taken tegelijk te 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"Processing batch {i//chunk_size + 1} ({len(chunk)} prompts)")
results = await process_batch(chunk, max_concurrent)
all_results.extend(results)
return all_results
Chunking biedt verschillende voordelen: u kunt voortgang weergeven, tussenresultaten opslaan en het geheugengebruik beperken. Als één sub-batch mislukt, raakt u de resultaten van eerdere sub-batches niet kwijt.
Voortgangsmonitoring
Voor grote batches is een voortgangsindicator nuttig:
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} completed", end="", flush=True)
return response.choices[0].message.content
tasks = [single_request(p) for p in prompts]
results = await asyncio.gather(*tasks)
print() # nieuwe regel na voortgang
return results
Belangrijkste punten
asyncio.gather(*tasks)voert coroutines parallel uit en retourneert resultaten in de oorspronkelijke volgordereturn_exceptions=Truevoorkomt dat één enkele fout de hele batch doet mislukken- Chunking stelt u in staat zeer grote volumes te verwerken zonder het geheugen te overbelasten
- Combineer
gatheraltijd met een semaphore om snelheidslimieten te respecteren - Voeg voortgangsmonitoring toe voor processen die lang duren