Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Itereerimine: millal mudelit uuesti peenhäälestada

Õppetund 13 / 16 Värskendatud 2. november 2026 Edasijõudnutele
Sellel lehel
  1. Peenhäälestus on iteratiivne protsess
  2. Analüüsi vigu enne nende parandamist
  3. Millal iteratsiooni teha
  4. Rikasta, mitte ära alusta nullist
  5. Pidev peenhäälestus ja selle piirangud
  6. Täistsükkel
  7. Dokumenteeri iga iteratsioon
  8. Peamised punktid

Uuendus 2. november 2026 — Peenhäälestuse kättesaadavus. OpenAI iseteeninduslik peenhäälestus kaotatakse järk-järgult: alates 7. maist 2026 ei saa organisatsioonid, mis pole kunagi varem peenhäälestustööd käivitanud, uut luua; alates 2. juulist peab olema viimase 60 päeva jooksul kasutatud peenhäälestatud mudelit; ja alates 6. jaanuarist 2027 ei saa ükski klient uusi töid käivitada. Juba treenitud mudeleid saab kasutada seni, kuni nende baasmudel on kasutuselt kõrvaldatud. See kursus on endiselt kasulik olemasoleva mudeli mõistmiseks ja rakendamiseks; uute projektide puhul seada esikohale vihjeinsenerindus (prompt engineering), RAG ja hindamine.

Peenhäälestus on iteratiivne protsess

Su esimene peenhäälestuskord on harva täiuslik. Areng tuleb korduvatest tsüklitest: analüüsi vigu, rikasta oma andmeid, treeni uuesti ja hinda tulemust. See õppetund õpetab sind tuvastama, millal ja kuidas iteratiivselt tegutseda – ning sama olulisena, kuidas ära tunda olukordi, kus ümberõpe oleks mõttetu.

Analüüsi vigu enne nende parandamist

Loomulik refleks pärast pettumust valmistavat hindamist on juhuslikult näiteid lisada, lootes, et maht probleemi lahendab. See on kiireim viis põletada oma treeningueelarvet ilma edusamme tegemata. Alusta iga ebaõnnestumise sorteerimisest kategooriasse: vale vormindus, sobimatu toon, faktiline viga, puudulik vastus, teemast kõrvalekaldumine või puhas hallutsinatsioon. Saadud jaotus näitab, kuhu oma jõupingutused suunata, ja paljastab sageli üllatuse – see, mida pidasid stiiliprobleemiks, osutub tegelikult täielikkuse probleemiks.

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

Seejärel vaata sama kategooria juhtumeid üle, et leida ühine nimetaja. Küsi endalt iga kord samu küsimusi: kas mudel ebaõnnestub kindlat tüüpi küsimuste puhul, kas vead kuhjuvad teatud teemade ümber ja kas probleem tuleneb andmetest või hüperparameetritest? Kõigil teemadel hajutatud, kuid sama iseloomuga ebaõnnestumised viitavad näidete puudumisele; ühte valdkonda koondunud vead näitavad katvuse lünka; ja vastused, mis jäävad sõltumata küsimusest liiga tihedalt sinu treeningnäidete külge, annavad märku ülesobitumisest (overfitting), mida tuleb epohhide poolelt korrigeerida.

Millal iteratsiooni teha

Teatud signaalid nõuavad üheselt uut versiooni ja igaüks neist vajab erinevat reaktsiooni. Mudelit, mis teatud teemal hallutsineerib, ei paranda sellele teemale rohkem õigeid vastuseid näitamine, vaid õpetades seda viisakalt keelduma, kui ta ei tea.

SignaalTegevus
Korduvad vormistusveadLisa rohkem näiteid õige vorminguga
Mudel hallutsineerib teatud teemadelLisa näiteid, kus ta viisakalt keeldub
Tuvastatud ülesobitumine (overfitting)Vähenda epohhe, mitmekesista andmeid
Uued kasutusjuhtumid, mida kattaLisa nende juhtumite jaoks näiteid
Sihipärane negatiivne kasutajatagasisideMuuda tagasiside parandatud näideteks

Vastupidi, on mitu olukorda, mis peaksid sind ümberõppest hoidma. Kui vead on haruldased ja mitte süsteemsed, lahendab need kiiremini ja odavamalt vihje (prompt) kohandamine. Kui kaebused puudutavad latentsust või ooteaegu, peitub probleem sinu taristus ja ükski treening seda ei paranda. Kui oled alates viimasest versioonist kogunud vaid peotäie uusi näiteid, ei kata oodatav kasu käivitamise kulu. Ja kui saadaval on uus baasmudel, testi seda esmalt sellisena, nagu ta on: mõnikord saavutab ta ise, ilma treeninguta, seda, mida sinu eelmine versioon vaevaga pakkus.

Rikasta, mitte ära alusta nullist

Inkrementaalne iteratsioon tähendab sihipäraste näidete lisamist olemasolevale andmestikule, puutumata ülejäänusse. See on kõige sagedasem ja lihtsam toiming: laadid praeguse faili, liidad uued juhtumid ja kirjutad kõik ümber JSONL-vormingusse. Lõplik arv toimib sinu kontrollina – summa, mis ei vasta oodatule, viitab faili lugemisveale või kadunud ridadele.

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

Korrektiivne iteratsioon on veelgi väärtuslikum, sest see muudab sinu ebaõnnestumised toormaterjaliks. Iga tootmises tuvastatud viga pakub reaalse küsimuse; sul tuleb lihtalt kirjutada vastus, mida oleksid soovinud näha, ja paarist saab treeningnäide. Pane tähele, et halb vastus ei lähe lõplikku näitesse: see aitab juhtumit dokumenteerida ja otsustada, kas parandus on vaeva väärt, kuid mudel õpib ainult õigest versioonist.

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)

Pidev peenhäälestus ja selle piirangud

Midagi ei takista sul peenhäälestamast juba peenhäälestatud mudelit: edasta lihtsalt selle täielik ID parameetris model baasmudeli nime asemel. Operatsioon on ahvatlev, kuna see treenib ainult uutel andmetel.

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

Hoiatus: pidev peenhäälestus kuhjab kallutusi. Pärast 2–3 järjestikust iteratsiooni on sageli parem alustada otsast peale baasmudeliga, kasutades täielikku, rikastatud andmestikku. Iga kiht võimendab eelmise veidrusi, ka neid, mida sa ei kavatsenud, ja mudel lõpetab jäigalt vastamisega, mida keegi talle otseselt õpetanud pole.

Täistsükkel

Alltoodud sammud moodustavad tsükli, mida kordad iga versiooni jaoks. Kui tegeled kõige sagedasemate vigadega esmalt, näitab järgmine versioon mõõdetavat kasvu sinu testkomplektis; nende lahendamine vales järjekorras toob kaasa ainult hajutatud paranemise, mida on raske oma meeskonnale põhjendada.

1

Kogu vead kokku

Tuvasta juhtumid, kus mudel ebaõnnestub tootmises või hindamise käigus.

2

Liigita ja sea prioriteedid

Liigita vead tüübi järgi ja tegele kõige sagedasematega esmalt.

3

Loo korrektiivsed näited

Muuda iga viga treeningnäiteks, kasutades õiget vastust.

4

Treeni uuesti ja hinda

Treeni uus versioon ja võrdle seda eelmisega samal testkomplektil.

Dokumenteeri iga iteratsioon

Pärast nelja või viit versiooni ei mäleta keegi, mis eristas v2-t v3-st või miks v4 maha jäeti. Iga käigu süstemaatiline dokumenteerimine – andmestiku koostis, uute näidete allikas, hüperparameetrid, tulemused ja tehtud otsus – annab sulle selle teabe kätte, kui regressioon sunnib sind samme tagasi astuma. Pööra erilist tähelepanu uute näidete allikale: ainult see ütleb sulle kuidagi hiljem, kas halvenemine tulenes halvasti valitud andmepartiist.

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

Peamised punktid

  • Peenhäälestus on iteratiivne – planeeri mitu tsüklit
  • Liigita vead enne, kui parandad neid andmetes
  • Muuda kasutajatagasiside treeningnäideteks
  • Pärast 2–3 järjestikust iteratsiooni alusta otsast peale baasmudeliga
  • Dokumenteeri iga iteratsioon, et säilitada selge ajalugu