Övervakning av träning
På denna sida
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