Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Övervakning av träning

Lektion 7 av 16 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Varför du ska övervaka träningen
  2. De två mätvärdena du ska läsa
  3. Spåra händelser via API:t
  4. Kontrollpunkter och mellanliggande resultat
  5. Att veta när man ska stoppa
  6. En sammanfattande rapport per körning
  7. Viktiga punkter

Uppdatering 2 november 2026 — Tillgänglighet för finjustering. OpenAIs självbetjäningslösning för finjustering avvecklas: sedan den 7 maj 2026 kan organisationer som aldrig har använt tjänsten inte längre skapa jobb; sedan den 2 juli måste du ha använt en finjusterad modell under de senaste 60 dagarna; och från och med 6 januari 2027 kommer ingen kund att kunna starta nya jobb. Redan tränade modeller förblir användbara tills deras basmodell tas ur bruk. Denna kurs är fortfarande användbar för att förstå och utnyttja en befintlig modell; för nya projekt bör du prioritera prompt engineering, RAG och utvärderingar.

Varför du ska övervaka träningen

Att starta ett finjusteringsjobb och sedan glömma bort det lämnar dig med ett fait accompli: en timme senare upptäcker du en modell utan att veta vad som hände under tiden. Genom att observera mätvärden medan träningen pågår fångar du problem tidigt, kan besluta att justera hyperparametrar innan du bränner hela din budget, och framför allt förstå varför en körning presterade bättre än en annan. Övervakning förvandlar en serie försök till en ingenjörsdisciplin.

De två mätvärdena du ska läsa

Träningsförlust (training loss) mäter hur felaktig modellen är på träningsdata – alltså den data den just nu bearbetar. Den bör minska över stegen: det är tecknet på att inlärning sker. En förlust som stagnerar eller börjar öka igen indikerar ett problem, oftast en dåligt kalibrerad inlärningshastighet eller ett korpus som är för heterogent.

Valideringsförlust (validation loss) mäter prestanda på data som modellen aldrig har sett under träningen – filen du lade åt sidan vid uppdelningen. Detta är den mest tillförlitliga metrik för att utvärdera din models faktiska kvalitet, eftersom det är den enda som modellen inte kan förbättra genom att memorera. Det är deras gemensamma utveckling som ger diagnosen.

Träningsförlust Valideringsförlust Diagnos
Minskar Minskar Allt bra, fortsätt
Minskar Ökar Överanpassning – minska antal epocher
Stagnerar Stagnerar Underanpassning – öka inlärningshastighet
Oscillerar Oscillerar Instabilitet – minska inlärningshastighet

Den andra raden är den som kostar mest i produktion: en träningsförlust som fortsätter minska medan valideringsförlusten klättrar uppåt beskriver en modell som memorerar dina exempel utantill. På pappret verkar allt förbättras; i verkligheten försämrar varje ytterligare steg dess förmåga att svara på en fråga den aldrig har sett.

Spåra händelser via API:t

API:t skickar inte push-notiser: du måste fråga jobbet med jämna mellanrum. Loopen nedan hämtar nya händelser, visar dem i kronologisk ordning samtidigt som den undviker att visa om de som redan setts, och returnerar kontrollen så snart jobbet når ett slutläge.

from openai import OpenAI
import time

client = OpenAI()

def monitor_job(job_id: str):
    """Övervakar ett jobb i realtid."""
    last_event = None

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

        # Hämta nya händelser
        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"\nJobb avslutat: {job.status}")
            if job.status == "succeeded":
                print(f"Modell: {job.fine_tuned_model}")
            return job

        time.sleep(30)

# Användning
job = monitor_job("ftjob-xxxxxxxxxxxxxxxx")

Händelser innehåller inte bara textmeddelanden: de bär också på förlustvärden vid varje steg. Genom att extrahera dem kan du rita en kurva istället för att läsa loggrader, och det är på en kurva du vid en första anblick upptäcker en topp i valideringsförlusten.

def extract_metrics(job_id: str) -> dict:
    """Extraherar förlustmätvärden från ett avslutat jobb."""
    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
    }

Kontrollpunkter och mellanliggande resultat

OpenAI sparar kontrollpunkter under träningen. Om jobbet misslyckas eller om du avbryter det kan du ibland återställa en användbar mellanliggande kontrollpunkt – med andra ord är en avbruten körning inte nödvändigtvis en förlorad körning. Detta är också en värdefull utväg vid sen överanpassning: kontrollpunkten som togs innan toppen i valideringsförlusten kan vara bättre än den slutgiltiga modellen.

# Lista kontrollpunkter för ett jobb
checkpoints = client.fine_tuning.jobs.checkpoints.list(
    fine_tuning_job_id=job.id
)

for cp in checkpoints.data:
    print(f"Steg {cp.step_number}")
    print(f"  Modell: {cp.fine_tuned_model_checkpoint}")
    if cp.metrics:
        print(f"  Träningsförlust: {cp.metrics.train_loss:.4f}")
        if hasattr(cp.metrics, "valid_loss"):
            print(f"  Valideringsförlust: {cp.metrics.valid_loss:.4f}")

Att veta när man ska stoppa

Tre signaler motiverar att du avbryter en pågående träningskörning. Den första är en valideringsförlust som har klättrat under flera steg, inte bara ett: ett isolerat värde är brus, en trend över fem punkter är överanpassning. Den andra är en träningsförlust nära noll, vilket betyder att modellen reproducerar dina exempel ordagrant och inte har något mer att lära sig av dem. Den tredje är mer prosaisk: dina tester förbättras inte från en kontrollpunkt till nästa, och varje ytterligare steg lägger bara till kostnaden.

# Om du upptäcker ett problem, avbryt jobbet
client.fine_tuning.jobs.cancel(job.id)
print("Jobb avbrutet. Justera din data eller hyperparametrar och starta om.")

En sammanfattande rapport per körning

Avsluta varje träningssession med att producera en handlingsbar dokumentation. Följande funktion samlar i en utmatning jobb-ID, basmodell, använda epocher, antal tränade tokens och mätvärden från den senaste kontrollpunkten. Klistra in dessa rapporter i din körningslogg: om en månad kommer de att berätta för dig varför du behöll denna version snarare än en annan.

def job_report(job_id: str):
    """Genererar en sammanfattningsrapport för jobbet."""
    job = client.fine_tuning.jobs.retrieve(job_id)

    print("=" * 50)
    print(f"Jobb: {job.id}")
    print(f"Basmodell: {job.model}")
    print(f"Status: {job.status}")
    print(f"Epocher: {job.hyperparameters.n_epochs}")

    if job.status == "succeeded":
        print(f"Finjusterad modell: {job.fine_tuned_model}")
        print(f"Tränade tokens: {job.trained_tokens}")

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

    # Kontrollpunkter
    checkpoints = client.fine_tuning.jobs.checkpoints.list(
        fine_tuning_job_id=job_id
    )
    if checkpoints.data:
        latest = checkpoints.data[0]
        print(f"Senaste kontrollpunkt: steg {latest.step_number}")
        if latest.metrics:
            print(f"  Träningsförlust: {latest.metrics.train_loss:.4f}")

    print("=" * 50)

job_report("ftjob-xxxxxxxxxxxxxxxx")

Viktiga punkter

  • Övervaka alltid valideringsförlusten – det är din sanna kvalitetsindikator
  • Om valideringsförlusten ökar har du överanpassat: minska antal epocher
  • Kontrollpunkter låter dig återställa ett mellanliggande tillstånd
  • Automatisera övervakning för långvariga jobb
  • Dokumentera mätvärden från varje körning för att jämföra dina iterationer