Overvågning af træning
På denne side
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