Itereren: wanneer u opnieuw moet fine-tunen
Op deze pagina
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 nog nooit een fine-tuning-taak hebben uitgevoerd, geen nieuwe meer aanmaken; sinds 2 juli moet u binnen de laatste 60 dagen een gefine-tuned model hebben gebruikt; en vanaf 6 januari 2027 kan geen enkele klant nog nieuwe taken starten. Reeds getrainde modellen blijven bruikbaar totdat hun basismodel wordt stopgezet. Deze cursus blijft nuttig om een bestaand model te begrijpen en benutten; voor nieuwe projecten geeft u prioriteit aan prompt engineering, RAG en evaluaties.
Fine-tuning is een iteratief proces
Uw eerste fine-tuning-run zal zelden perfect zijn. Verbetering komt voort uit iteratieve cycli: analyseer fouten, verrijk uw data, hertrain en evalueer opnieuw. Deze les leert u hoe u effectief kunt bepalen wanneer en hoe u moet itereren — en, minstens zo belangrijk, hoe u situaties herkent waarin hertraining zinloos zou zijn.
Analyseer fouten voordat u ze oplost
De natuurlijke reflex na een teleurstellende evaluatie is om willekeurig voorbeelden toe te voegen, in de hoop dat volume het probleem oplost. Dat is de snelste manier om uw trainingsbudget te verbranden zonder vooruitgang te boeken. Begin met het sorteren van elke mislukking in een categorie: incorrecte opmaak, ongepaste toon, feitelijke fout, onvolledig antwoord, antwoord naast de kwestie of pure hallucinatie. De resulterende verdeling vertelt u waar u uw inspanningen moet concentreren, en onthult vaak een verrassing: wat u dacht dat een stijlprobleem was, blijkt een probleem met volledigheid te zijn.
def analyze_errors(results: list[dict]) -> dict:
"""Categorizes errors from the fine-tuned model."""
categories = {
"format": [], # Incorrect response format
"tone": [], # Inappropriate tone
"factual": [], # Incorrect information
"incomplete": [], # Response too short or missing elements
"off_topic": [], # Does not answer the question
"hallucination": [] # Invents information
}
for r in results:
if r.get("score", 5) < 3:
# Classify the error (can be done manually or by an LLM)
category = classify_error(r)
categories[category].append(r)
print("Error distribution:")
for cat, errors in categories.items():
if errors:
print(f" {cat}: {len(errors)} cases")
return categories
Bekijk vervolgens gevallen binnen dezelfde categorie om een gemeenschappelijke noemer te vinden. Stel uzelf telkens dezelfde vragen: faalt het model bij een specifiek type vraag, clusteren fouten rond bepaalde onderwerpen, en komt het probleem voort uit de data of de hyperparameters? Fouten die verspreid zijn over alle onderwerpen maar altijd van dezelfde aard wijzen op een gebrek aan voorbeelden; fouten die geconcentreerd zijn in één domein duiden op een dekkingsgat; en antwoorden die te dicht bij uw trainingsvoorbeelden blijven, ongeacht de vraag, signaleren overfitting die correctie vereist aan de kant van de epochs.
Herkennen wanneer u moet itereren
Bepaalde signalen vragen ondubbelzinnig om een nieuwe versie, en elk vereist een andere reactie. Een model dat hallucineert over een onderwerp lost u niet op door het meer correcte antwoorden over dat onderwerp te tonen, maar door het te leren beleefd af te wijzen wanneer het iets niet weet.
| Signaal | Actie |
|---|---|
| Terugkerende opmaakfouten | Voeg meer voorbeelden toe met de correcte opmaak |
| Model hallucineert over bepaalde onderwerpen | Voeg voorbeelden toe waarin het beleefd afwijst |
| Overfitting gedetecteerd | Verminder epochs, diversifieer data |
| Nieuwe use cases om te dekken | Voeg voorbeelden toe voor deze cases |
| Gerichte negatieve gebruikersfeedback | Zet feedback om in gecorrigeerde voorbeelden |
Omgekeerd zijn er verschillende situaties die u moeten weerhouden van hertraining. Wanneer fouten zeldzaam en niet-systematisch zijn, lost een aanpassing van de prompt ze sneller en goedkoper op. Wanneer klachten gaan over latentie of wachttijden, ligt het probleem bij uw infrastructuur, en geen enkele hoeveelheid training zal dat oplossen. Wanneer u sinds de laatste versie slechts een handvol nieuwe voorbeelden heeft verzameld, zal het verwachte rendement de kosten van de run niet dekken. En wanneer een nieuw basismodel beschikbaar komt, test het dan eerst zoals het is: soms bereikt het op eigen kracht, zonder training, wat uw vorige versie moeite had te leveren.
Verrijk in plaats van opnieuw te beginnen
Incrementele iteratie betekent dat u gerichte voorbeelden toevoegt aan een bestaande dataset zonder de rest aan te raken. Dit is de meest frequente en eenvoudigste bewerking: u laadt het huidige bestand, voegt de nieuwe cases samen en herschrijft alles in JSONL-formaat. Het eindtotaal dient als uw controle — een totaal dat niet overeenkomt met de verwachte som wijst op een leesfout in het bestand of verloren regels.
import json
def enrich_dataset(
existing_dataset: str,
new_examples: list[dict],
output: str
):
"""Adds new examples to the existing dataset."""
# Load existing data
with open(existing_dataset, "r") as f:
existing = [json.loads(l) for l in f]
# Merge
combined = existing + new_examples
# Save
with open(output, "w") as f:
for ex in combined:
f.write(json.dumps(ex, ensure_ascii=False) + "\n")
print(f"Enriched dataset: {len(existing)} + {len(new_examples)} = {len(combined)}")
Correctieve iteratie is nog waardevoller omdat het uw mislukkingen omzet in grondstof. Elke fout die in productie wordt ontdekt, levert een echte vraag op; u hoeft alleen het antwoord te schrijven dat u had willen zien, en het paar wordt een trainingsvoorbeeld. Merk op dat het slechte antwoord niet in het definitieve example terechtkomt: het helpt om de case te documenteren en te beslissen of de correctie de moeite waard is, maar het model leert alleen van de correcte versie.
def error_to_example(
question: str,
bad_response: str,
good_response: str,
system_msg: str
) -> dict:
"""Transforms an error into a training example."""
return {
"messages": [
{"role": "system", "content": system_msg},
{"role": "user", "content": question},
{"role": "assistant", "content": good_response}
]
}
# Transform a batch of errors
corrections = []
for error in detected_errors:
correction = error_to_example(
question=error["question"],
bad_response=error["model_response"],
good_response=error["corrected_response"],
system_msg=SYSTEM_PROMPT
)
corrections.append(correction)
Continue fine-tuning en de beperkingen ervan
Niets houdt u tegen om een reeds gefine-tuned model opnieuw te fine-tunen: geef gewoon de volledige ID op in de parameter model in plaats van de naam van het basismodel. De operatie is verleidelijk omdat er alleen op de nieuwe data wordt getraind.
# Fine-tune from an already fine-tuned model
job_v2 = client.fine_tuning.jobs.create(
training_file=new_file.id,
model="ft:gpt-5.6-luna:org::suffix-v1:xxxxxxxx", # v1 model as base
suffix="my-assistant-v2"
)
Waarschuwing: continue fine-tuning stapelt biases op. Na 2–3 opeenvolgende iteraties is het vaak beter om opnieuw te beginnen vanaf het basismodel met een complete, verrijkte dataset. Elke laag versterkt de eigenaardigheden van de vorige, inclusief die welke u niet bedoelde, en het model eindigt met het geven van antwoorden met een rigiditeit die niemand het expliciet heeft geleerd.
De volledige cyclus
De onderstaande stappen vormen de lus die u voor elke versie zult herhalen. Als u de meest voorkomende fouten eerst aanpakt, zal de volgende versie meetbare winst laten zien op uw testset; als u ze in willekeurige volgorde aanpakt, levert dat slechts diffuse verbetering op die moeilijk te verdedigen is tegenover uw team.
Fouten verzamelen
Identificeer cases waarin het model faalt in productie of tijdens evaluatie.
Categoriseren en prioriteren
Classificeer fouten per type en pak de meest voorkomende eerst aan.
Correctieve voorbeelden maken
Zet elke fout om in een trainingsvoorbeeld met het correcte antwoord.
Hertrainen en opnieuw evalueren
Train de nieuwe versie en vergelijk deze met de vorige op dezelfde testset.
Documenteer elke iteratie
Na vier of vijf versies herinnert niemand zich meer wat v2 onderscheidde van v3 of waarom v4 werd opgegeven. Het systematisch vastleggen van elke run — de samenstelling van de dataset, de bron van nieuwe voorbeelden, hyperparameters, resultaten en de genomen beslissing — geeft u deze informatie wanneer een regressie u dwingt om stappen terug te zetten. Besteed bijzondere aandacht aan de bron van nieuwe voorbeelden: alleen dat zal u maanden later vertellen of de degradatie kwam door een slecht gekozen databatch.
iteration_log = {
"version": "v3",
"date": "2026-04-02",
"base_model": "gpt-5.6-luna",
"dataset": {
"train": 350,
"validation": 45,
"new_examples": 50,
"new_examples_source": "production errors week 12"
},
"hyperparameters": {
"n_epochs": 3,
"learning_rate_multiplier": "auto",
"batch_size": "auto"
},
"results": {
"validation_loss": 0.42,
"precision_test": 0.91,
"avg_csat": 4.3,
"improvement_vs_v2": "+5% precision, +0.2 CSAT"
},
"decision": "Deployed to production on 2026-04-03"
}
Belangrijkste punten
- Fine-tuning is iteratief — plan meerdere cycli in
- Categoriseer fouten voordat u ze in de data oplost
- Zet gebruikersfeedback om in trainingsvoorbeelden
- Start na 2–3 opeenvolgende iteraties opnieuw vanaf het basismodel
- Documenteer elke iteratie om een heldere geschiedenis te behouden