Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Opret et batch-job, spor status, og download resultater

Lektion 3 af 16 Opdateret 3. november 2026 Avanceret
På denne side
  1. Fra JSONL-fil til resultater: Den komplette livscyklus
  2. Opret et batch-job
  3. Batch-job-statusser
  4. Spor fremdriften
  5. Download resultater
  6. List og administrer dine jobs
  7. End-to-end workflow
  8. Vigtige pointer

Opdateret 3. november 2026: Tillæg til 3. november: files.download returnerer et HTTP-svar (httpx2.Response); læs indholdet med .read() før du kalder .decode(). Upload forventer file={"file_name": …, "content": …}. API-nøglen er ikke længere hardcodet.

Fra JSONL-fil til resultater: Den komplette livscyklus

Din JSONL-fil er klargjort og uploadet, og du har et file_id. Næste skridt er at omdanne den hvilende fil til brugbare resultater: Opret batch-jobbet, overvåg dets fremdrift i løbet af de minutter eller timer, behandlingen tager, og hent derefter resultaterne for at afstemme dem. Denne lektion guider dig gennem den end-to-end Python-kode i præcis den rækkefølge, du vil skrive den.

Opret et batch-job

Oprettelse kræver kun ét kald. Du angiver kildefilen, modellen og mål-endpointet:

from mistralai.client import Mistral
import time

client = Mistral(api_key="your-api-key")

# Opret batch-jobbet
job = client.batch.jobs.create(
    input_files=[batch_file.id],   # ID på den uploadede fil
    model="mistral-small-latest",
    endpoint="/v1/chat/completions",
    metadata={"project": "document-analysis", "version": "1.0"}
)

print(f"Job oprettet: {job.id}")
print(f"Indledende status: {job.status}")

Hver parameter fortjener en bemærkning:

  • input_files — En liste over ID’er på uploadede filer. Du kan sende flere filer til et enkelt job.
  • model — Den Mistral-model, der skal bruges. Kun én model pr. batch-job.
  • endpoint — Mål-API-endpointet (skal matche body-formatet i din JSONL).
  • metadata — En valgfri ordbog med brugerdefinerede metadata til at organisere og hente dine jobs.

Begrænsningen om én model pr. job strukturerer, hvordan du opdeler dit arbejde: Hvis du vil sammenligne to modeller på det samme korpus, skal du indsende to separate jobs, der peger på den samme fil. Hvad angår metadata, kan det virke uvæsentligt, indtil du har tredive jobs i din historik; så vil projekt/version-parret vist ovenfor lade dig finde det batch, der producerede tvivlsomme data, på tre sekunder fladt.

Batch-job-statusser

Et batch-job gennemgår flere tilstande i sin livscyklus:

StatusBeskrivelse
QUEUEDI kø, endnu ikke startet
RUNNINGBehandling i gang
SUCCESSGennemført succesfuldt
FAILEDBehandling mislykkedes
TIMEOUT_EXCEEDEDEksekveringstid overskredet
CANCELLATION_REQUESTEDAnnullering anmodet
CANCELLEDAnnulleret

Fire af disse syv tilstande er terminale – SUCCESS, FAILED, TIMEOUT_EXCEEDED og CANCELLED – og denne sondring styrer overvågningsløkken: Så længe statussen ikke er i dette sæt, er jobbet stadig i live, og du skal vente. CANCELLATION_REQUESTED er især ikke en stoppet tilstand, men en overgangstilstand; kode, der behandler den som terminal, ville afslutte løkken for tidligt.

Spor fremdriften

Polling-mønsteret nedenfor indkapsler netop denne logik med en maksimal varighedsbegrænsning for at forhindre, at et glemt script kører i det uendelige:

def wait_for_batch(client, job_id, poll_interval=10, max_wait=3600):
    """Vent på, at et batch-job bliver færdigt ved hjælp af polling."""
    elapsed = 0
    terminal_states = {"SUCCESS", "FAILED", "TIMEOUT_EXCEEDED", "CANCELLED"}

    while elapsed < max_wait:
        job = client.batch.jobs.get(job_id=job_id)
        print(f"[{elapsed}s] Status: {job.status}")

        if job.status in terminal_states:
            return job

        time.sleep(poll_interval)
        elapsed += poll_interval

    raise TimeoutError(f"Job {job_id} kører stadig efter {max_wait}s")

# Brug
completed_job = wait_for_batch(client, job.id)
print(f"Endeligt resultat: {completed_job.status}")

Et interval på ti sekunder fungerer til et batch, der varer få minutter; til en natkørsel, der behandler flere hundrede tusind linjer, bør du øge det til et minut eller mere. Større polling-præcision tilfører ingen værdi der og akkumulerer kun unødvendige API-kald.

Download resultater

Når statussen når SUCCESS, eksponerer jobbet en output_file, som du downloader og parser linje for linje:

import json

if completed_job.status == "SUCCESS":
    # Hent output-filens ID
    output_file_id = completed_job.output_file

    # Download indholdet
    result_data = client.files.download(file_id=output_file_id)

    # Parse JSONL-resultater
    results = {}
    for line in result_data.read().decode("utf-8").strip().split("\n"):
        entry = json.loads(line)
        custom_id = entry["custom_id"]
        response = entry["response"]
        results[custom_id] = response

    # Vis et eksempel
    for cid, resp in list(results.items())[:3]:
        content = resp["body"]["choices"][0]["message"]["content"]
        print(f"\n--- {cid} ---")
        print(content[:200])

Resultatfilen er også i JSONL-format, og hver linje indeholder det oprindelige custom_id sammen med modellens fulde svar. Her betaler navngivningsindsatsen fra den forrige lektion sig: Indeksering efter custom_id i en ordbog er nok til at afstemme svar med dine kildedokumenter, uanset den rækkefølge, de returneres i. At vise de første tre poster afkortet til 200 tegn er en nyttig sundhedstjek, før du begynder at skrive til din database.

List og administrer dine jobs

Du kan filtrere jobbeholdningen efter status, så du til enhver tid kan se, hvad der faktisk kører på din konto:

# List alle jobs, der kører i øjeblikket
running_jobs = client.batch.jobs.list(status="RUNNING")
for j in running_jobs.data:
    print(f"Job {j.id} - Model: {j.model} - Oprettet: {j.created_at}")

Og når et job trækker ud, eller du opdager en prompt-fejl efter indsendelse, undgår annullering, at du betaler for ubrugelig behandling:

# Annuller et job, der tager for lang tid
client.batch.jobs.cancel(job_id="job-abc123")

Annullering er asynkron: Statussen skifter først til CANCELLATION_REQUESTED og derefter til CANCELLED, når stoppet er effektivt. Betragt ikke ressourcen som frigivet umiddelbart efter kaldets returnering.

End-to-end workflow

Samlet udgør disse fire trin et kort script, som du kan placere direkte i en scheduler:

from mistralai.client import Mistral
import json
import os
import time

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

# 1. Upload filen
with open("batch_requests.jsonl", "rb") as f:
    batch_file = client.files.upload(
        file={"file_name": "batch_requests.jsonl", "content": f},
        purpose="batch"
    )

# 2. Opret jobbet
job = client.batch.jobs.create(
    input_files=[batch_file.id],
    model="mistral-small-latest",
    endpoint="/v1/chat/completions"
)

# 3. Vent på fuldførelse
completed = wait_for_batch(client, job.id)

# 4. Download og parse resultater
if completed.status == "SUCCESS":
    data = client.files.download(file_id=completed.output_file)
    for line in data.read().decode("utf-8").strip().split("\n"):
        entry = json.loads(line)
        print(f"{entry['custom_id']}: OK")
else:
    print(f"Batch mislykkedes: {completed.status}")

Genbrug dette skelet på dit eget korpus med blot ti linjer: Du vil validere hele kæden på få minutter, før du begår dig til det fulde volumen.

Vigtige pointer

  • Opret et batch-job med client.batch.jobs.create() ved at angive fil, model og endpoint
  • Syv mulige statusser, herunder tre terminale: SUCCESS, FAILED, CANCELLED
  • Polling med et interval er standardmønsteret til at spore fremdrift
  • Resultater er i JSONL-format og linket til anmodninger via custom_id
  • Du kan liste, inspicere og annullere dine jobs til enhver tid