Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Overvågning af træning

Lektion 7 af 16 Opdateret 2. november 2026 Avanceret
På denne side
  1. Hvorfor overvåge træning
  2. De to metriker, du skal læse
  3. Sporing af begivenheder via API’et
  4. Checkpoints og mellemresultater
  5. At vide, hvornår man skal stoppe
  6. En sammenfattende rapport per kørsel
  7. Vigtige pointer

Opdatering 2. november 2026 — Tilgængelighed af finjustering. OpenAIs selvbetjente finjustering udfases: siden 7. maj 2026 kan organisationer, der aldrig har brugt tjenesten, ikke længere oprette jobs; siden 2. juli skal du have brugt en finjusteret model inden for de sidste 60 dage; og fra 6. januar 2027 vil ingen kunder kunne starte nye jobs. Allerede trænede modeller forbliver brugbare, indtil deres basismodel udgår. Dette kursus er stadig nyttigt til at forstå og udnytte en eksisterende model; til nye projekter bør du prioritere prompt engineering, RAG og evalueringer.

Hvorfor overvåge træning

Hvis du starter et finjusteringsjob og glemmer alt om det, står du med et fait accompli: En time senere opdager du en model uden at vide, hvad der skete i mellemtiden. Ved at observere metriker, mens træningen kører, fanger du problemer tidligt, beslutter at justere hyperparametre, før du brænder hele dit budget af, og frem for alt forstår du, hvorfor én kørsel præsterede bedre end en anden. Overvågning omdanner en række forsøg til en ingeniørmæssig disciplin.

De to metriker, du skal læse

Træningstab (Training loss) måler, hvor forkert modellen er på træningsdataene – netop de data, den lige nu indtager. Det skal falde over tid (steps): det er tegnet på, at læring finder sted. Et tab, der stagnerer eller begynder at stige igen, indikerer et problem, typisk en dårligt kalibreret læringshastighed eller et korpus, der er for heterogent.

Valideringstab (Validation loss) måler ydeevnen på data, som modellen aldrig har set under træningen – den fil, du lagde til side under opdelingen. Dette er den mest pålidelige metrik til at evaluere din models faktiske kvalitet, fordi det er den eneste, modellen ikke kan forbedre ved at memorere. Det er deres fælles udvikling, der giver diagnosen.

Træningstab Valideringstab Diagnose
Faldende Faldende Alt godt, fortsæt
Faldende Stigende Overfitting – reducer epochs
Stagnerende Stagnerende Underfitting – øg læringshastighed
Oscillerende Oscillerende Ustabilitet – reducer læringshastighed

Den anden række er den, der koster dyrest i produktion: et træningstab, der fortsætter med at falde, mens valideringstabet stiger igen, beskriver en model, der lærer dine eksempler udenad. På papiret ser alt ud til at blive bedre; i virkeligheden forringer hvert ekstra step dens evne til at besvare et spørgsmål, den aldrig har set før.

Sporing af begivenheder via API’et

API’et sender ikke push-notifikationer: du skal poll’e jobbet med jævne mellemrum. Løkken nedenfor henter nye begivenheder, viser dem i kronologisk rækkefølge uden at vise dem, der allerede er set, og returnerer kontrollen, så snart jobbet når en terminal tilstand.

from openai import OpenAI
import time

client = OpenAI()

def monitor_job(job_id: str):
    """Overvåger et job i realtid."""
    last_event = None

    while True:
        job = client.fine_tuning.jobs.retrieve(job_id)

        # Hent nye begivenheder
        events = client.fine_tuning.jobs.list_events(
            fine_tuning_job_id=job_id,
            limit=50
        )

        for event in reversed(events.data):
            if last_event and event.id == last_event:
                continue
            print(f"[{event.created_at}] {event.message}")

        if events.data:
            last_event = events.data[0].id

        if job.status in ("succeeded", "failed", "cancelled"):
            print(f"\nJob finished: {job.status}")
            if job.status == "succeeded":
                print(f"Model: {job.fine_tuned_model}")
            return job

        time.sleep(30)

# Brug
job = monitor_job("ftjob-xxxxxxxxxxxxxxxx")

Begivenheder indeholder ikke kun tekstbeskeder: de bærer også tab-værdier for hvert step. Ved at udtrække dem kan du plotte en kurve i stedet for at læse loglinjer, og det er på en kurve, du ved første øjekast spotter et spike i valideringstabet.

def extract_metrics(job_id: str) -> dict:
    """Udtrækker tabs-metriker fra et afsluttet job."""
    events = client.fine_tuning.jobs.list_events(
        fine_tuning_job_id=job_id,
        limit=200
    )

    training_losses = []
    validation_losses = []

    for event in events.data:
        data = event.data
        if data and "train_loss" in str(data):
            training_losses.append(data)
        if data and "valid_loss" in str(data):
            validation_losses.append(data)

    return {
        "training": training_losses,
        "validation": validation_losses
    }

Checkpoints og mellemresultater

OpenAI gemmer checkpoints under træningen. Hvis jobbet fejler, eller du annullerer det, kan du nogle gange genoprette et brugbart mellemliggende checkpoint – med andre ord er en afbrudt kørsel ikke nødvendigvis en tabt kørsel. Dette er også en værdifuld udvej i tilfælde af sen overfitting: checkpointet taget før spiket i valideringstabet kan være bedre end den endelige model.

# List checkpoints for et job
checkpoints = client.fine_tuning.jobs.checkpoints.list(
    fine_tuning_job_id=job.id
)

for cp in checkpoints.data:
    print(f"Step {cp.step_number}")
    print(f"  Model: {cp.fine_tuned_model_checkpoint}")
    if cp.metrics:
        print(f"  Training loss: {cp.metrics.train_loss:.4f}")
        if hasattr(cp.metrics, "valid_loss"):
            print(f"  Validation loss: {cp.metrics.valid_loss:.4f}")

At vide, hvornår man skal stoppe

Tre signaler berettiger afbrydelse af en igangværende træningskørsel. Det første er et valideringstab, der har steget i flere steps, ikke blot ét: en isoleret værdi er støj, en trend over fem punkter er overfitting. Det andet er et træningstab tæt på nul, hvilket betyder, at modellen gengiver dine eksempler ordret og ikke har mere at lære af dem. Det tredje er mere prosaisk: dine tests bliver ikke bedre fra det ene checkpoint til det næste, og hvert ekstra step lægger blot til regningen.

# Hvis du opdager et problem, så annuller jobbet
client.fine_tuning.jobs.cancel(job.id)
print("Job cancelled. Adjust your data or hyperparameters and relaunch.")

En sammenfattende rapport per kørsel

Afslut hver træningssession med at producere en handlingsorienteret registrering. Følgende funktion samler job-ID, basismodel, brugte epochs, antal trænede tokens og metriker fra det sidste checkpoint i én output. Indsæt disse rapporter i din kørselslog: om en måned vil de fortælle dig, hvorfor du beholdt denne version frem for en anden.

def job_report(job_id: str):
    """Genererer en sammenfattende rapport for jobbet."""
    job = client.fine_tuning.jobs.retrieve(job_id)

    print("=" * 50)
    print(f"Job: {job.id}")
    print(f"Base model: {job.model}")
    print(f"Status: {job.status}")
    print(f"Epochs: {job.hyperparameters.n_epochs}")

    if job.status == "succeeded":
        print(f"Fine-tuned model: {job.fine_tuned_model}")
        print(f"Trained tokens: {job.trained_tokens}")

    if job.status == "failed":
        print(f"Error: {job.error}")

    # Checkpoints
    checkpoints = client.fine_tuning.jobs.checkpoints.list(
        fine_tuning_job_id=job_id
    )
    if checkpoints.data:
        latest = checkpoints.data[0]
        print(f"Latest checkpoint: step {latest.step_number}")
        if latest.metrics:
            print(f"  Train loss: {latest.metrics.train_loss:.4f}")

    print("=" * 50)

job_report("ftjob-xxxxxxxxxxxxxxxx")

Vigtige pointer

  • Overvåg altid valideringstab – det er din sande kvalitetsindikator
  • Hvis valideringstabet stiger, har du overfitting: reducer epochs
  • Checkpoints lader dig genoprette en mellemtilstand
  • Automatiser overvågning for langvarige jobs
  • Dokumenter metriker fra hver kørsel for at sammenligne dine iterationer