Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Batch API: Massiv asynkron behandling

Lektion 6 af 20 Opdateret 3. november 2026 Avanceret
På denne side
  1. Byt ventetid mod omkostninger
  2. Byg og start en batch
  3. Planlæg for delvise fejl
  4. Gang dine besparelser
  5. Vigtige pointer

Opdateret 3. november 2026 baseret på guiden til Batch API og svarstrukturen i Responses API: Aflæsning af resultater antager ikke længere, at det første element i output er beskeden (et ræsonnementselement kan gå forud), og nøglen til fejlkode, skrevet uden anførselstegn, udløste en NameError. Kilde: Batch API.

Byt ventetid mod omkostninger

Batch API hviler på et simpelt markedsprincip: Du accepterer, at dine forespørgsler behandles asynkront inden for et vindue på op til 24 timer, og til gengæld betaler du 50 % mindre. Alt, der ikke kræver, at et menneske sidder og venter på resultatet foran skærmen, falder i denne kategori. I stor skala er dette ikke en mikrooptimering; det halverer dit budget.

Den vane, du skal opbygge i teamet, er at spørge for hver ny behandlingsopgave, om nogen venter på resultatet. Analyse af en lagerbeholdning af kontrakter, generering af produktblade til et katalog, kørsel af benchmarks på tusindvis af testcases, klassificering af en seks måneder gammel backlog af tickets eller udtræk af felter fra en bunke fakturaer: I alle disse tilfælde lander svaret i et dashboard eller en database, ikke i en samtalegrænseflade. Forsinkelsen er usynlig, men besparelsen er det ikke.

Byg og start en batch

Inputformatet er en JSONL-fil: én linje pr. forespørgsel, hvor hver linje er et komplet, uafhængigt objekt. Feltet custom_id er det, der giver dig mulighed for at kæde hvert svar tilbage til den oprindelige forespørgsel, da intet garanterer rækkefølgen i outputfilen. Vælg et ID, der er stabilt og meningsfuldt – et dokument-ID fra din database frem for et iterationsnummer – ellers bliver genforeningsfasen et mareridt.

import json

requests = [
    {
        "custom_id": f"doc-{i}",
        "method": "POST",
        "url": "/v1/responses",
        "body": {
            "model": "gpt-5.6-luna",
            "input": f"Opsummer dette dokument i 3 hovedpunkter: {doc}",
            "max_output_tokens": 500,
        },
    }
    for i, doc in enumerate(documents_list)
]

# Skriv JSONL-filen
with open("batch_input.jsonl", "w") as f:
    for request in requests:
        f.write(json.dumps(request) + "\n")

Filen uploades derefter og refereres til, når batchen oprettes. Metadata har intet teknisk formål, men det redder dig, når tre batches kører parallelt, og du skal finde ud af, hvilken der svarer til hvilken prompt-version.

import openai

client = openai.OpenAI()

# Upload filen
file_obj = client.files.create(
    file=open("batch_input.jsonl", "rb"),
    purpose="batch",
)

# Opret batchen
batch = client.batches.create(
    input_file_id=file_obj.id,
    endpoint="/v1/responses",
    completion_window="24h",
    metadata={"project": "contract-analysis", "version": "2.1"},
)

print(f"Batch oprettet: {batch.id}")
print(f"Status: {batch.status}")

Overvågning indebærer at poller batchen, indtil den forlader tilstanden „in-progress”, og derefter downloade outputfilen, som også er i JSONL-format. Løkken nedenfor skelner mellem tre afsluttende udfald – failed, expired, cancelled – og udløser en undtagelse for hver: En udløbet batch er en, hvor 24-timers vinduet er løbet ud, før alt var behandlet, og at behandle det som en stille delvis succes ville være den værste løsning.

import time

def wait_for_batch(batch_id: str, interval: int = 60) -> list:
    """Venter på, at en batch bliver færdig, og returnerer resultaterne."""
    while True:
        batch = client.batches.retrieve(batch_id)
        print(
            f"Status: {batch.status} | "
            f"Fuldført: {batch.request_counts.completed}/"
            f"{batch.request_counts.total} | "
            f"Mislykket: {batch.request_counts.failed}"
        )

        if batch.status == "completed":
            break
        elif batch.status in ("failed", "expired", "cancelled"):
            raise RuntimeError(f"Batch mislykkedes: {batch.status}")

        time.sleep(interval)

    # Download resultater
    content = client.files.content(batch.output_file_id)
    results = []
    for line in content.text.strip().split("\n"):
        results.append(json.loads(line))

    return results


results = wait_for_batch(batch.id)

# Behandle resultater
for result in results:
    custom_id = result["custom_id"]
    response = result["response"]
    if response["status_code"] == 200:
        # output kan indeholde andre elementer før beskeden
        # (f.eks. ræsonnement): find tekstens besked
        text = next(
            part["text"]
            for item in response["body"]["output"] if item["type"] == "message"
            for part in item["content"] if part["type"] == "output_text"
        )
        print(f"{custom_id}: {text[:100]}...")
    else:
        print(f"{custom_id}: FEJL {response['status_code']}")

Planlæg for delvise fejl

I en stor batch vil nogle forespørgsler mislykkes: et afkortet dokument, en kontekstoverløb eller en forbigående serverfejl. En batch er derfor aldrig blot „succesfuld” eller „mislykket” – den er delvist succesfuld, og du skal vide, hvordan du isolerer den manglende del. Mønsteret, du skal adoptere, er straks at adskille succeser fra fejl og generere en ny JSONL-fil, der er klar til genstart, i stedet for at grave i logs tre dage senere for at rekonstruere det manglende.

def handle_batch_errors(results: list[dict]) -> tuple[list, list]:
    """Adskiller succeser fra fejl til genbehandling."""
    successes = []
    failures = []

    for r in results:
        if r["response"]["status_code"] == 200:
            successes.append(r)
        else:
            failures.append(r)

    if failures:
        print(f"Advarsel: {len(failures)} mislykkede forespørgsler ud af {len(results)}")
        # Omskriv en JSONL-fil med fejl til genforsøg
        with open("batch_retry.jsonl", "w") as f:
            for failure in failures:
                original_request = {
                    "custom_id": failure["custom_id"],
                    "method": "POST",
                    "url": "/v1/responses",
                    "body": failure["request"]["body"],
                }
                f.write(json.dumps(original_request) + "\n")

    return successes, failures

Gang dine besparelser

Ved en kørsel på ti tusind dokumenter med GPT-5.6 Luna repræsenterer det synkrone API basisomkostningen, Batch API repræsenterer halvdelen heraf, og prompt-caching lægges oveni, da cachelagrede tokens også drager fordel af deres egen reduktion. De to mekanismer konkurrerer ikke: Hvis dine ti tusind forespørgsler deler den samme lange systemprompt, skal du strukturere den som et stabilt præfiks, så du ganger begge effekter.

Endelig er der spørgsmålet om opdeling. En batch bør ikke være uendelig, og det er mere komfortabelt at overvåge flere håndterbare batches end én enkelt monolit, hvis fejl koster en hel dags arbejde. Funktionen nedenfor opdeler en liste over forespørgsler i batches af begrænset størrelse.

def create_optimized_batches(
    requests: list[dict],
    max_size: int = 50_000,
) -> list[list[dict]]:
    """Opdeler i batches af optimal størrelse."""
    batches = []
    current_batch = []

    for request in requests:
        current_batch.append(request)
        if len(current_batch) >= max_size:
            batches.append(current_batch)
            current_batch = []

    if current_batch:
        batches.append(current_batch)

    return batches

Vigtige pointer

  • Batch API tilbyder en reduktion på 50 % til ikke-realtidsbehandling
  • Forbered dine forespørgsler i en JSONL-fil med et unikt custom_id pr. forespørgsel
  • Planlæg en genforsøgsmekanisme for mislykkede forespørgsler
  • Kombiner med prompt-caching for at maksimere besparelser