Spring til hovedindhold
Dansk— Vælg et sprog
Menu

asyncio.gather til batchbehandling

Lektion 5 af 12 Opdateret 30. juli 2026 Avanceret
På denne side
  1. Orkestrering af parallelle anmodninger
  2. Grundlæggende syntaks
  3. Komplet mønster: Batch med semaphore
  4. Håndtering af fejl i en batch
  5. Opdeling i under-batches (Chunking)
  6. Sporing af fremskridt
  7. Vigtige pointer

Orkestrering af parallelle anmodninger

asyncio.gather er kernen i at køre flere coroutines parallelt og indsamle alle resultater. Kombineret med en semaphore kan du behandle batches af anmodninger effektivt, samtidig med at du overholder API-grænser.

Grundlæggende syntaks

import asyncio

requests = ["Question 1", "Question 2", "Question 3"]
tasks = [process_request(r) for r in requests]
responses = await asyncio.gather(*tasks)

asyncio.gather tager et variabelt antal coroutines (derfor bruges *tasks til at udpakke listen) og returnerer en liste med resultater i samme rækkefølge, som opgaverne blev indsendt. Dette er vigtigt: Selvom spørgsmål 3 bliver færdigt før spørgsmål 1, vil responses[0] altid indeholde resultatet for spørgsmål 1.

Komplet mønster: Batch med semaphore

Her er det mønster, du oftest vil bruge i produktion:

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)

Dette mønster kapsler semaphoren inden i batch-funktionen. Du skal blot kalde process_batch(prompts) og hente listen med svar.

Håndtering af fejl i en batch

Som standard annullerer asyncio.gather alt og propagerer fejlen, hvis én enkelt coroutine kaster en undtagelse. Parameteren return_exceptions=True ændrer denne adfærd:

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

# Brug
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]}...")

Med return_exceptions=True fanges fejl som værdier i resultatlisten. Derefter kan du identificere og genforsøge mislykkede anmodninger.

Opdeling i under-batches (Chunking)

Ved meget store mængder er det bedre at opdele i under-batches frem for at starte tusindvis af opgaver samtidigt:

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 tilbyder flere fordele: Du kan vise fremskridt, gemme mellemresultater og begrænse hukommelsesforbruget. Hvis én under-batch fejler, mister du ikke resultaterne fra de tidligere under-batches.

Sporing af fremskridt

Ved store batches er en fremskridtsindikator nyttig:

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()  # ny linje efter fremskridt
    return results

Vigtige pointer

  • asyncio.gather(*tasks) kører coroutines parallelt og returnerer resultater i den oprindelige rækkefølge
  • return_exceptions=True forhindrer, at en enkelt fejl får hele batchen til at fejle
  • Chunking giver dig mulighed for at håndtere meget store mængder uden at mætte hukommelsen
  • Kombiner altid gather med en semaphore for at overholde hastighedsgrænser
  • Tilføj sporing af fremskridt ved langvarige processer