Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

asyncio.gather voor batchverwerking

Les 5 van 12 Bijgewerkt op 30 juli 2026 Gevorderd
Op deze pagina
  1. Parallelle verzoeken orchestreren
  2. Basis syntaxis
  3. Volledig patroon: Batch met semaphore
  4. Foutafhandeling in een batch
  5. Opsplitsen in sub-batches (chunking)
  6. Voortgangsmonitoring
  7. Belangrijkste punten

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 volgorde
  • return_exceptions=True voorkomt 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 gather altijd met een semaphore om snelheidslimieten te respecteren
  • Voeg voortgangsmonitoring toe voor processen die lang duren