Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Monitoring van de training

Les 7 van 16 Bijgewerkt op 2 november 2026 Gevorderd
Op deze pagina
  1. Waarom training monitoren
  2. De twee metrics om te lezen
  3. Gebeurtenissen volgen via de API
  4. Checkpoints en tussenresultaten
  5. Weten wanneer u moet stoppen
  6. Een samenvattend rapport per run
  7. Belangrijkste punten

Update 2 november 2026 — Beschikbaarheid van fine-tuning. De self-service fine-tuning van OpenAI wordt gefaseerd afgebouwd: sinds 7 mei 2026 kunnen organisaties die er nog nooit gebruik van hebben gemaakt geen taken meer starten; sinds 2 juli moet u binnen de laatste 60 dagen een fine-tuned model hebben gebruikt; en vanaf 6 januari 2027 kan geen enkele klant nieuwe taken lanceren. Reeds getrainde modellen blijven bruikbaar totdat hun basismodel wordt uitgefaseerd. Deze cursus blijft nuttig om een bestaand model te begrijpen en benutten; voor nieuwe projecten geeft u prioriteit aan prompt engineering, RAG en evaluaties.

Waarom training monitoren

Als u een fine-tuning-taak start en deze vervolgens vergeet, staat u later voor een voldongen feit: een uur later ontdekt u een model zonder te weten wat er in de tussentijd is gebeurd. Door metrics te observeren terwijl de training draait, signaleert u problemen vroeg, kunt u hyperparameters aanpassen voordat uw volledige budget op is, en begrijpt u vooral waarom de ene run beter presteerde dan de andere. Monitoring maakt van een reeks proeven een engineeringdiscipline.

De twee metrics om te lezen

Trainingsverlies meet hoe fout het model is op de trainingsdata—dezelfde data die het op dat moment verwerkt. Dit moet afnemen naarmate de stappen vorderen: dat is het teken dat er leren plaatsvindt. Een verlies dat stagneert of weer stijgt, wijst op een probleem, meestal een slecht gekalibreerde leersnelheid of een corpus dat te heterogeen is.

Validatieverlies meet de prestaties op data die het model tijdens de training nooit heeft gezien—het bestand dat u tijdens de splitsing apart hebt gehouden. Dit is de betrouwbaarste metric om de werkelijke kwaliteit van uw model te evalueren, omdat het de enige is die het model niet kan verbeteren door simpelweg te memoriseren. Het is de gezamenlijke evolutie hiervan die de diagnose mogelijk maakt.

Trainingsverlies Validatieverlies Diagnose
Afnemend Afnemend Alles goed, doorgaan
Afnemend Toenemend Overfitting — verminder epochs
Stagnerend Stagnerend Underfitting — verhoog leersnelheid
Oscillerend Oscillerend Instabiliteit — verlaag leersnelheid

De tweede rij is degene die in productie het duurste uitpakt: een trainingsverlies dat blijft dalen terwijl het validatieverlies weer stijgt, beschrijft een model dat uw voorbeelden uit het hoofd leert. Op papier lijkt alles te verbeteren; in werkelijkheid verslechtert elke extra stap het vermogen om een vraag te beantwoorden die het nog nooit heeft gezien.

Gebeurtenissen volgen via de API

De API verstuurt geen meldingen: u moet de taak met regelmatige tussenpozen peilen (pollen). De onderstaande lus haalt nieuwe gebeurtenissen op, toont ze in chronologische volgorde zonder reeds geziene opnieuw weer te geven, en geeft de controle terug zodra de taak een eindstatus bereikt.

from openai import OpenAI
import time

client = OpenAI()

def monitor_job(job_id: str):
    """Monitort een taak in real-time."""
    last_event = None

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

        # Haal nieuwe gebeurtenissen op
        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"\nTaak voltooid: {job.status}")
            if job.status == "succeeded":
                print(f"Model: {job.fine_tuned_model}")
            return job

        time.sleep(30)

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

Gebeurtenissen bevatten niet alleen tekstberichten: ze dragen ook verlieswaarden bij elke stap. Door deze te extraheren, kunt u een curve uitzetten in plaats van logregels te lezen, en op een curve spot u een piek in het validatieverlies in één oogopslag.

def extract_metrics(job_id: str) -> dict:
    """Extraheert verlies-metrics van een voltooide taak."""
    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 en tussenresultaten

OpenAI slaat checkpoints op tijdens de training. Als de taak mislukt of u deze annuleert, kunt u soms een bruikbaar tussenliggend checkpoint herstellen—met andere woorden, een onderbroken run is niet per se een verloren run. Dit is ook een waardevolle uitweg bij late overfitting: het checkpoint dat is genomen vóór de piek in het validatieverlies kan beter zijn dan het uiteindelijke model.

# Lijst checkpoints voor een taak op
checkpoints = client.fine_tuning.jobs.checkpoints.list(
    fine_tuning_job_id=job.id
)

for cp in checkpoints.data:
    print(f"Stap {cp.step_number}")
    print(f"  Model: {cp.fine_tuned_model_checkpoint}")
    if cp.metrics:
        print(f"  Trainingsverlies: {cp.metrics.train_loss:.4f}")
        if hasattr(cp.metrics, "valid_loss"):
            print(f"  Validatieverlies: {cp.metrics.valid_loss:.4f}")

Weten wanneer u moet stoppen

Drie signalen rechtvaardigen het onderbreken van een lopende training. Het eerste is een validatieverlies dat al meerdere stappen stijgt, niet slechts één: een geïsoleerde waarde is ruis, een trend over vijf punten is overfitting. Het tweede is een trainingsverlies dicht bij nul, wat betekent dat het model uw voorbeelden letterlijk reproduceert en er niets meer van kan leren. Het derde is prozaïscher: uw tests verbeteren niet van het ene checkpoint naar het andere, en elke extra stap drijft alleen de kosten op.

# Als u een probleem detecteert, annuleer de taak dan
client.fine_tuning.jobs.cancel(job.id)
print("Taak geannuleerd. Pas uw data of hyperparameters aan en start opnieuw.")

Een samenvattend rapport per run

Sluit elke trainingssessie af door een actieverslag op te stellen. De volgende functie verzamelt in één output de taak-ID, het basismodel, de gebruikte epochs, het aantal getrainde tokens en de metrics van het laatste checkpoint. Plak deze rapporten in uw run-logboek: over een maand vertellen ze u waarom u deze versie hebt behouden en een andere niet.

def job_report(job_id: str):
    """Genereert een samenvattend rapport voor de taak."""
    job = client.fine_tuning.jobs.retrieve(job_id)

    print("=" * 50)
    print(f"Taak: {job.id}")
    print(f"Basismodel: {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"Getrainde tokens: {job.trained_tokens}")

    if job.status == "failed":
        print(f"Fout: {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"Laatste checkpoint: stap {latest.step_number}")
        if latest.metrics:
            print(f"  Trainingsverlies: {latest.metrics.train_loss:.4f}")

    print("=" * 50)

job_report("ftjob-xxxxxxxxxxxxxxxx")

Belangrijkste punten

  • Monitor altijd het validatieverlies—dit is uw ware kwaliteitsindicator
  • Als het validatieverlies stijgt, heeft u te maken met overfitting: verminder de epochs
  • Met checkpoints kunt u een tussenliggende staat herstellen
  • Automatiseer monitoring voor langdurige taken
  • Documenteer metrics van elke run om uw iteraties te vergelijken