Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Iterering: När du ska finjustera på nytt

Lektion 13 av 16 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Finjustering är en iterativ process
  2. Analysera fel innan du åtgärdar dem
  3. Känna igen när du ska iterera
  4. Berika istället för att börja om från början
  5. Kontinuerlig finjustering och dess begränsningar
  6. Den fullständiga cykeln
  7. Dokumentera varje iteration
  8. Viktiga punkter

Uppdatering 2 november 2026 — Tillgänglighet för finjustering. OpenAIs självbetjäningstjänst för finjustering avvecklas: sedan den 7 maj 2026 kan organisationer som aldrig har kört ett finjusteringsjobb inte längre skapa ett; sedan den 2 juli måste du ha använt en finjusterad modell under de senaste 60 dagarna; och från och med den 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 promptteknik, RAG och utvärderingar.

Finjustering är en iterativ process

Din första finjustering kommer sällan att bli perfekt. Förbättring kommer genom iterativa cykler: analysera fel, berika din data, träna om och utvärdera på nytt. I denna lektion lär du dig hur du identifierar när och hur du ska iterera effektivt – och, lika viktigt, hur du känner igen situationer där omträning skulle vara meningslös.

Analysera fel innan du åtgärdar dem

Den naturliga reflexen efter en misslyckad utvärdering är att slumpmässigt lägga till exempel i hopp om att volym ska lösa problemet. Det är det snabbaste sättet att bränna din träningsbudget utan att göra framsteg. Börja med att sortera varje misslyckande i en kategori: felaktigt format, olämplig ton, faktamässigt fel, ofullständigt svar, svar som inte hör till frågan, eller ren hallucination. Den resulterande fördelningen berättar var du ska fokusera din energi, och den avslöjar ofta en överraskning – vad du trodde var ett stilproblem visar sig vara ett problem med fullständighet.

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

Granska därefter fallen inom samma kategori för att hitta en gemensam nämnare. Ställ dig samma frågor varje gång: misslyckas modellen med en specifik typ av fråga, klumpas felen kring vissa ämnen, och härrör problemet från datan eller hyperparametrarna? Misslyckanden som är spridda över alla ämnen men alltid av samma natur pekar på brist på exempel; misslyckanden koncentrerade till en domän indikerar ett täckningsgap; och svar som håller sig för nära dina träningsexempel oavsett fråga signalerar överanpassning som behöver korrigeras på epochs-sidan.

Känna igen när du ska iterera

Vissa signaler kräver entydigt en ny version, och varje signal kräver en annan åtgärd. En modell som hallucinerar kring ett ämne fixas inte genom att visa den fler korrekta svar om det ämnet, utan genom att lära den att artigt avböja när den inte vet.

SignalÅtgärd
Återkommande formatfelLägg till fler exempel med korrekt format
Modellen hallucinerar kring vissa ämnenLägg till exempel där den artigt avböjer
Överanpassning upptäcktMinska epochs, diversifiera data
Nya användningsfall att täckaLägg till exempel för dessa fall
Riktad negativ användarfeedbackOmvandla feedback till korrigerade exempel

Å andra sidan finns det flera situationer som bör få dig att avstå från omträning. När fel är sällsynta och icke-systematiska hanterar en justering av prompten dem snabbare och billigare. När klagomål gäller latens eller väntetider ligger problemet i din infrastruktur, och ingen mängd träning kommer att fixa det. När du bara har samlat in en handfull nya exempel sedan den senaste versionen kommer den förväntade vinsten inte att täcka kostnaden för körningen. Och när en ny basmodell blir tillgänglig, testa den först i befintligt skick: ibland uppnår den på egen hand, utan träning, det som din tidigare version kämpade med att leverera.

Berika istället för att börja om från början

Inkrementell iterering innebär att du lägger till riktade exempel i en befintlig datamängd utan att röra resten. Detta är den vanligaste och enklaste operationen: du laddar den aktuella filen, sammanfogar de nya fallen och skriver om allt i JSONL-format. Den slutliga summan fungerar som din kontroll – en total som inte matchar den förväntade summan indikerar ett filläsningsfel eller förlorade rader.

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)}")

Korrigerande iterering är ännu mer värdefull eftersom den omvandlar dina misslyckanden till råmaterial. Varje fel som upptäcks i produktionen ger en riktig fråga; du behöver bara skriva det svar du önskar att du hade sett, så blir paret ett träningsexempel. Observera att det dåliga svaret inte hamnar i det slutliga exemplet: det hjälper till att dokumentera fallet och avgöra om korrigeringen är värd besväret, men modellen lär sig endast från den korrekta versionen.

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 och dess begränsningar

Inget hindrar dig från att finjustera en redan finjusterad modell: skicka bara dess fullständiga ID i parametern model istället för basmodellens namn. Operationen är frestande eftersom den bara tränar på den nya datan.

# 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"
)

Varning: kontinuerlig finjustering ackumulerar bias. Efter 2–3 successiva iterationer är det ofta bättre att börja om från början med basmodellen och en komplett, berikad datamängd. Varje lager förstärker egenskaperna hos det föregående, inklusive de du inte avsåg, och modellen hamnar med att svara med en stelhet som ingen explicit har lärt den.

Den fullständiga cykeln

Stegen nedan bildar den loop du kommer att upprepa för varje version. Om du tar itu med de vanligaste felen först kommer nästa version att visa mätbara vinster på din testmängd; att ta itu med dem i fel ordning ger bara diffus förbättring som är svår att försvara inför ditt team.

1

Samla in fel

Identifiera fall där modellen misslyckas i produktion eller under utvärdering.

2

Kategorisera och prioritera

Klassificera fel efter typ och åtgärda de vanligaste först.

3

Skapa korrigerande exempel

Omvandla varje fel till ett träningsexempel med korrekt svar.

4

Träna om och utvärdera på nytt

Träna den nya versionen och jämför den med den tidigare på samma testmängd.

Dokumentera varje iteration

Efter fyra eller fem versioner kommer ingen ihåg vad som skilde v2 från v3 eller varför v4 övergavs. Genom att systematiskt registrera varje körning – datamängdens sammansättning, källan till nya exempel, hyperparametrar, resultat och det fattade beslutet – får du tillgång till denna information när en regression tvingar dig att spåra tillbaka dina steg. Var särskilt uppmärksam på källan till nya exempel: bara det kommer att berätta för dig, månader senare, om försämringen kom från en dåligt vald 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"
}

Viktiga punkter

  • Finjustering är iterativ – planera för flera cykler
  • Kategorisera fel innan du åtgärdar dem i datan
  • Omvandla användarfeedback till träningsexempel
  • Efter 2–3 successiva iterationer, börja om från basmodellen
  • Dokumentera varje iteration för att behålla en tydlig historik