Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Ustvari paketno opravilo, spremljaj stanje in prenesi rezultate

Lekcija 3 od 16 Posodobljeno 3. november 2026 Napredni
Na tej strani
  1. Od datoteke JSONL do rezultatov: Celoten življenjski cikel
  2. Ustvari paketno opravilo
  3. Stanja paketnega opravila
  4. Spremljaj napredek
  5. Prenesi rezultate
  6. Seznam in upravljanje tvojih opravil
  7. Delovni tok od začetka do konca
  8. Ključne ugotovitve

Posodobljeno 3. novembra 2026: Dodatek za 3. november: files.download vrne HTTP odgovor (httpx2.Response); njegovo vsebino preberi z .read() pred klicem .decode(). Nalaganje pričakuje file={"file_name": …, "content": …}. Ključ API ni več trdno kodiran.

Od datoteke JSONL do rezultatov: Celoten življenjski cikel

Tvoja datoteka JSONL je pripravljena in naložena, imaš pa tudi file_id. Naslednji korak je pretvorba te mirujoče datoteke v uporabne rezultate: ustvari paketno opravilo, spremljaj njegov napredek v minutah ali urah, kolikor traja obdelava, nato pa pridobi in uskladi odgovore. Ta lekcija te popelje skozi kodo Python od začetka do konca v točnem vrstnem redu, kot jo boš zapisal.

Ustvari paketno opravilo

Za ustvarjanje zadostuje en sam klic. Določiš izvorno datoteko, model in ciljno končno točko:

from mistralai.client import Mistral
import time

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

# Create the batch job
job = client.batch.jobs.create(
    input_files=[batch_file.id],   # ID of the uploaded file
    model="mistral-small-latest",
    endpoint="/v1/chat/completions",
    metadata={"project": "document-analysis", "version": "1.0"}
)

print(f"Job created: {job.id}")
print(f"Initial status: {job.status}")

Vsak parameter zasluži opombo:

  • input_files – Seznam ID-jev naloženih datotek. Enemu opravilu lahko posreduješ več datotek.
  • model – Model Mistral, ki ga želiš uporabiti. Na paketno opravilo lahko vežeš le en model.
  • endpoint – Ciljna končna točka API (morajo se ujemati s formatom body v tvoji datoteki JSONL).
  • metadata – Izbirni slovar s prilagojenimi metapodatki za organizacijo in iskanje tvojih opravil.

Omejitev enega modela na opravilo določa način razdelitve dela: če želiš na istem korpusu primerjati dva modela, predloži dve ločeni opravili, ki kažeta na isto datoteko. Kar zadeva metapodatke, se morda zdijo nepomembni, dokler nimaš v zgodovini trideset opravil; takrat ti par projekt/različica, kot je prikazan zgoraj, omogoči, da v treh sekundah najdeš paket, ki je proizvedel vprašljive podatke.

Stanja paketnega opravila

Paketno opravilo med svojim življenjskim ciklom preide skozi več stanj:

StanjeOpis
QUEUEDV čakalni vrsti, še ni začeto
RUNNINGObdelava v teku
SUCCESSUspešno zaključeno
FAILEDObdelava ni uspela
TIMEOUT_EXCEEDEDČasovna omejitev izvajanja presežena
CANCELLATION_REQUESTEDZahtevana preklic
CANCELLEDPreklicano

Štiri od teh sedmih stanj so končna – SUCCESS, FAILED, TIMEOUT_EXCEEDED in CANCELLED – in prav ta razlika poganja zanko za spremljanje: dokler stanje ni v tem naboru, je opravilo še živo in moraš počakati. CANCELLATION_REQUESTED še posebej ni ustavljeno stanje, temveč prehodno; koda, ki bi ga obravnavala kot končno, bi zanko prezgodaj zaključila.

Spremljaj napredek

Spodnji vzorec anketiranja točno zajema to logiko, z varovalko za največje trajanje, ki preprečuje, da bi pozabljen skript tekel v nedogled:

def wait_for_batch(client, job_id, poll_interval=10, max_wait=3600):
    """Wait for a batch job to complete using 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} still running after {max_wait}s")

# Usage
completed_job = wait_for_batch(client, job.id)
print(f"Final result: {completed_job.status}")

Desetsekundni interval deluje za paket, ki traja nekaj minut; za čeznočno obdelavo več sto tisoč vrstic ga povečaj na minuto ali več. Večja natančnost anketiranja tam ne prinaša vrednosti in le kopiči nepotrebne klice API.

Prenesi rezultate

Ko stanje doseže SUCCESS, opravilo razkrije output_file, ki ga preneseš in parsiraš vrstico za vrstico:

import json

if completed_job.status == "SUCCESS":
    # Get the output file ID
    output_file_id = completed_job.output_file

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

    # Parse JSONL results
    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

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

Datoteka z rezultati je prav tako v formatu JSONL in vsaka vrstica poleg polnega odgovora modela vsebuje izvirni custom_id. Tu se obrestuje trud poimenovanja iz prejšnje lekcije: indeksiranje po custom_id v slovarju zadostuje za usklajevanje odgovorov z izvornimi dokumenti, ne glede na vrstni red njihovega vračanja. Prikaz prvih treh vnosov, skrajšanih na 200 znakov, je koristen hiter preverjanje preden začneš pisati v svojo bazo podatkov.

Seznam in upravljanje tvojih opravil

Seznam opravil lahko filtriraš po stanju, kar ti omogoča, da kadarkoli vidiš, kaj se dejansko izvaja na tvojem računu:

# List all currently running jobs
running_jobs = client.batch.jobs.list(status="RUNNING")
for j in running_jobs.data:
    print(f"Job {j.id} - Model: {j.model} - Created: {j.created_at}")

In ko se opravilo zavleče ali po predložitvi opaziš napako v pozivu, s preklicem preprečiš plačevanje neuporabne obdelave:

# Cancel a job that is taking too long
client.batch.jobs.cancel(job_id="job-abc123")

Preklic je asinhron: stanje se najprej spremeni v CANCELLATION_REQUESTED, nato pa v CANCELLED, ko je ustavitev dejanska. Vira ne štej za sproščenega takoj ob vrnitvi klica.

Delovni tok od začetka do konca

Sestavljeno ti štirje koraki tvorijo kratek skript, ki ga lahko neposredno namestiš v načrtovalnik:

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

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

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

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

# 3. Wait for completion
completed = wait_for_batch(client, job.id)

# 4. Download and parse results
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 failed: {completed.status}")

To ogrodje ponovno uporabi na svojem korpusu z le desetimi vrsticami: v nekaj minutah boš preveril celotno verigo, preden se zavežeš polnemu obsegu.

Ključne ugotovitve

  • Paketno opravilo ustvariš s client.batch.jobs.create(), kjer določiš datoteko, model in končno točko
  • Sedem možnih stanj, vključno s tremi končnimi: SUCCESS, FAILED, CANCELLED
  • Anketiranje z intervalom je standardni vzorec za spremljanje napredka
  • Rezultati so v formatu JSONL, povezani z zahtevami prek custom_id
  • Svoja opravila lahko kadarkoli našteješ, pregledaš in prekličeš