Iteration: Hvornår skal du finjustere igen?
På denne side
Opdatering 2. november 2026 — Tilgængelighed af finjustering. OpenAIs selvbetjente finjustering udfases: Siden 7. maj 2026 har organisationer, der aldrig har kørt en finjusteringsopgave, ikke længere mulighed for at oprette en; 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 opgaver. Allerede trænede modeller forbliver brugbare, indtil deres basismodel trækkes tilbage. 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.
Finjustering er en iterativ proces
Din første finjustering vil sjældent være perfekt. Forbedring kommer gennem iterative cyklusser: analysér fejl, berig dine data, træn igen, og evaluér på ny. Denne lektion lærer dig, hvordan du identificerer, hvornår og hvordan du itererer effektivt – og lige så vigtigt, hvordan du genkender situationer, hvor gen træning ville være meningsløs.
Analysér fejl, før du retter dem
Den naturlige refleks efter en skuffende evaluering er tilfældigt at tilføje eksempler i håb om, at volumen løser problemet. Det er den hurtigste måde at brænde dit træningsbudget af uden at gøre fremskridt. Start med at sortere hver fejl i en kategori: forkert formatering, upassende tone, faktuel fejl, ufuldstændigt svar, svar uden for emnet eller ren hallucination. Den resulterende fordeling fortæller dig, hvor du skal fokusere din indsats, og den afslører ofte en overraskelse – det, du troede var et stilproblem, viser sig at være et problem med fuldstændighed.
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
Gennemgå derefter tilfælde inden for samme kategori for at finde en fællesnævner. Stil dig selv de samme spørgsmål hver gang: Fejler modellen på en bestemt type spørgsmål? Ophober fejlene sig omkring bestemte emner? Stammer problemet fra dataene eller hyperparametrene? Fejl spredt på tværs af alle emner, men altid af samme art, peger på mangel på eksempler; fejl koncentreret i ét domæne indikerer et dækningsgab; og svar, der holder sig for tæt på dine træningseksempler uanset spørgsmålet, signalerer overfitting, der skal korrigeres på epochs-siden.
Genkend hvornår du skal iterere
Visse signaler kræver utvetydigt en ny version, og hver kræver en anden reaktion. En model, der hallucinerer om et emne, løses ikke ved at vise den flere korrekte svar om dette emne, men ved at lære den høfligt at afvise, når den ikke ved noget.
| Signal | Handling |
|---|---|
| Tilbagevendende formatfejl | Tilføj flere eksempler med det korrekte format |
| Modellen hallucinerer om bestemte emner | Tilføj eksempler, hvor den høfligt afviser |
| Overfitting opdaget | Reducér epochs, diversificér data |
| Nye brugstilfælde at dække | Tilføj eksempler for disse tilfælde |
| Målrettet negativ brugerfeedback | Omdan feedback til korrigerede eksempler |
Omvendt bør flere situationer få dig til at stoppe med at gen træne. Når fejl er sjældne og ikke-systematiske, håndterer en justering af prompten dem hurtigere og billigere. Når klager vedrører ventetid eller latens, ligger problemet i din infrastruktur, og ingen mængde træning vil løse det. Når du kun har indsamlet en håndfuld nye eksempler siden sidste version, vil den forventede gevinst ikke dække omkostningerne ved kørslen. Og når en ny basismodel bliver tilgængelig, så test den først som den er: Nogle gange opnår den alene, uden træning, det som din tidligere version kæmpede med at levere.
Berig i stedet for at starte forfra
Inkrementel iteration betyder at tilføje målrettede eksempler til et eksisterende datasæt uden at røre resten. Dette er den hyppigste og enkleste operation: Du indlæser den nuværende fil, sammenkæder de nye tilfælde og skriver alt om i JSONL-format. Det endelige antal fungerer som din kontrol – et totaltal, der ikke matcher den forventede sum, indikerer en fejl ved filindlæsning eller mistede linjer.
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)}")
Korrigerende iteration er endnu mere værdifuld, fordi den omdanner dine fejl til råmateriale. Hver fejl opdaget i produktionen giver et rigtigt spørgsmål; du skal bare skrive det svar, du ønskede, du havde set, så bliver parret til et træningseksempel. Bemærk, at det dårlige svar ikke kommer med i det endelige eksempel: Det hjælper med at dokumentere sagen og afgøre, om korrektionen er besværet værd, men modellen lærer kun af den korrekte version.
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)
Kontinuerlig finjustering og dens begrænsninger
Intet hindrer dig i at finjustere en model, der allerede er finjusteret: Du skal bare sende dens fulde ID i parameteren model i stedet for navnet på basismodellen. Operationen er fristende, da den kun træner på de nye data.
# 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"
)
Advarsel: Kontinuerlig finjustering ophober bias. Efter 2–3 successive iterationer er det ofte bedre at starte forfra fra basismodellen med et komplet, beriget datasæt. Hvert lag forstærker ejendommelighederne fra det foregående, inklusive dem du ikke havde til hensigt, og modellen ender med at svare med en stivhed, som ingen eksplicit har lært den.
Den fulde cyklus
Trinnene nedenfor danner den sløjfe, du vil gentage for hver version. Hvis du tackler de hyppigste fejl først, vil næste version vise målbare gevinster på dit testsæt; at tackle dem i forkert rækkefølge giver kun diffuse forbedringer, der er svære at forsvare over for dit team.
Indsaml fejl
Identificér tilfælde, hvor modellen fejler i produktionen eller under evaluering.
Kategorisér og prioritér
Klassificér fejl efter type og adressér de hyppigste først.
Opret korrigerende eksempler
Omdan hver fejl til et træningseksempel med det korrekte svar.
Gen træn og gen-evaluér
Træn den nye version og sammenlign den med den tidligere på samme testsæt.
Dokumentér hver iteration
Efter fire eller fem versioner husker ingen, hvad der adskilte v2 fra v3, eller hvorfor v4 blev opgivet. Ved systematisk at registrere hver kørsel – datasættets sammensætning, kilden til nye eksempler, hyperparametre, resultater og den trufne beslutning – har du disse oplysninger klar, når en regression tvinger dig til at gå tilbage i sporet. Vær særligt opmærksom på kilden til nye eksempler: Kun det vil fortælle dig måneder senere, om forringelsen kom fra en dårligt valgt 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"
}
Vigtige pointer
- Finjustering er iterativ – planlæg flere cyklusser
- Kategorisér fejl, før du retter dem i dataene
- Omdan brugerfeedback til træningseksempler
- Efter 2–3 successive iterationer skal du starte forfra fra basismodellen
- Dokumentér hver iteration for at bevare en klar historik