Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Iteracije: kdaj ponovno prilagoditi model

Lekcija 13 od 16 Posodobljeno 2. november 2026 Napredni
Na tej strani
  1. Prilagajanje je iterativen proces
  2. Pred popravilom analizirajte napake
  3. Prepoznavanje, kdaj iterirati
  4. Obogatitev namesto začetka od nič
  5. Neprekinjeno prilagajanje in njegove omejitve
  6. Celoten cikel
  7. Dokumentirajte vsako iteracijo
  8. Ključne ugotovitve

Posodobitev 2. november 2026 — Razpoložljivost prilagajanja. Samostojno prilagajanje (fine-tuning) podjetja OpenAI se postopoma ukinja: od 7. maja 2026 organizacije, ki še niso zagnale opravila prilagajanja, tega ne morejo več ustvariti; od 2. julija morate prilagojen model uporabiti vsaj enkrat v zadnjih 60 dneh; in od 6. januarja 2027 noben uporabnik ne bo mogel zagnati novih opravil. Že usposobljeni modeli ostanejo uporabni, dokler se njihov osnovni model ne umakne. Ta tečaj je še vedno koristen za razumevanje in izkoriščanje obstoječega modela; za nove projekte dajte prednost inženiringu pozivov (prompt engineering), arhitekturi RAG in evalvacijam.

Prilagajanje je iterativen proces

Vaš prvi poskus prilagajanja redko bo popoln. Izboljšave prihajajo skozi iterativne cikle: analizirajte napake, obogatite svoje podatke, ponovno usposobite model in ga znova ovrednotite. Ta lekcija vas nauči, kako prepoznati, kdaj in kako učinkovito iterirati – in, kar je prav tako pomembno, kako prepoznati situacije, kjer bi bilo ponovno usposabljanje brezpredmetno.

Pred popravilom analizirajte napake

Naravni refleks po razočarajoči evalvaciji je naključno dodajanje primerov v upanju, da bo količina rešila težavo. To je najhitrejši način, da porabite proračun za usposabljanje, ne da bi napredovali. Začnite z razvrščanjem vsake napake v kategorijo: nepravilno oblikovanje, neustrezen ton, dejanska napaka, nepopoln odgovor, odgovor izven teme ali čista halucinacija. Nastala porazdelitev vam pove, kam usmeriti svoj trud, in pogosto razkrije presenečenje – tisto, za kar ste mislili, da je težava s slogom, se izkaže za težavo s popolnostjo odgovora.

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

Nato pregledajte primere znotraj iste kategorije, da najdete skupni imenovalec. Vsakič si zastavite enaka vprašanja: ali model odpove pri določeni vrsti vprašanj, ali se napake kopičijo okoli določenih tem in ali težava izvira iz podatkov ali hiperparametrov? Napake, razpršene po vseh temah, a vedno iste narave, kažejo na pomanjkanje primerov; napake, skoncentrirane v eni domeni, kažejo na vrzel v pokritosti; odgovori, ki se preveč držijo vaših učnih primerov ne glede na vprašanje, pa signalizirajo prekomerno prilagojenost (overfitting), ki jo je treba odpraviti na strani epoh.

Prepoznavanje, kdaj iterirati

Določeni signali nedvoumno zahtevajo novo različico in vsak zahteva drugačen odziv. Modela, ki halucinira o določeni temi, ne popravite tako, da mu pokažete več pravilnih odgovorov o tej temi, temveč tako, da ga naučite vljudno odkloniti odgovor, ko nečesa ne ve.

SignalUkrep
Ponavljajoče se napake v oblikiDodajte več primerov s pravilno obliko
Model halucinira o določenih temahDodajte primere, kjer vljudno odkloni odgovor
Zaznana prekomerna prilagojenost (overfitting)Zmanjšajte število epoh, diverzificirajte podatke
Novi primeri uporabe za pokrivanjeDodajte primere za te primere
Ciljane negativne povratne informacije uporabnikovPovratne informacije pretvorite v popravljene primere

Po drugi strani pa vas morajo nekatere situacije odvrniti od ponovnega usposabljanja. Ko so napake redke in nesistematične, jih prilagoditev poziva (prompt) obravnava hitreje in ceneje. Ko se pritožbe nanašajo na zakasnitev ali čakalne čase, je težava v vaši infrastrukturi in je nobena količina usposabljanja ne bo odpravila. Ko ste od zadnje različice zbrali le peščico novih primerov, pričakovani dobiček ne bo pokril stroškov zagona. In ko postane na voljo nov osnovni model, ga najprej preizkusite takega, kot je: včasih sam doseže tisto, kar se je vaša prejšnja različica trudila doseči, brez potrebe po usposabljanju.

Obogatitev namesto začetka od nič

Inkrementna iteracija pomeni dodajanje ciljanih primerov obstoječemu naboru podatkov, ne da bi se dotaknili ostalega. To je najpogostejša in najpreprostejša operacija: naložite trenutno datoteko, združite nove primere in vse znova zapišete v formatu JSONL. Končno število služi kot kontrola – vsota, ki se ne ujema s pričakovano, kaže na napako pri branju datoteke ali izgubljene vrstice.

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

Korektivna iteracija je še bolj dragocena, ker vaše napake spremeni v surovino. Vsaka napaka, opažena v proizvodnji, predstavlja resnično vprašanje; zapisati morate le odgovor, ki bi ga želeli videti, in par postane učni primer. Upoštevajte, da slab odgovor ne gre v končni primer: pomaga dokumentirati primer in se odločiti, ali je popravek vreden truda, model pa se uči le iz pravilne različice.

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)

Neprekinjeno prilagajanje in njegove omejitve

Nič vam ne preprečuje, da bi prilagodili že prilagojen model: v parameter model preprosto vnesite njegov celoten ID namesto imena osnovnega modela. Operacija je zapeljiva, saj se usposablja le na novih podatkih.

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

Opozorilo: neprekinjeno prilagajanje kopiči pristranskosti. Po 2–3 zaporednih iteracijah je pogosto bolje začeti znova z osnovnim modelom in popolnim, obogatenim naborom podatkov. Vsaka plast ojači posebnosti prejšnje, vključno s tistimi, ki jih niste načrtovali, in model na koncu odgovarja s togostjo, ki ga je nihče ni eksplicitno učil.

Celoten cikel

Spodnji koraki tvorijo zanko, ki jo boste ponavljali za vsako različico. Če se najprej lotite najpogostejših napak, bo naslednja različica pokazala merljive izboljšave na vašem testnem naboru; obravnavanje izven vrstnega reda prinaša le razpršene izboljšave, ki jih je težko zagovarjati pred vašo ekipo.

1

Zbiranje napak

Prepoznajte primere, kjer model odpove v proizvodnji ali med evalvacijo.

2

Kategorizacija in določanje prioritet

Razvrstite napake po vrsti in se najprej lotite najpogostejših.

3

Ustvarjanje korektivnih primerov

Vsako napako pretvorite v učni primer s pravilnim odgovorom.

4

Ponovno usposabljanje in evalvacija

Usposobite novo različico in jo primerjajte s prejšnjo na istem testnem naboru.

Dokumentirajte vsako iteracijo

Po štirih ali petih različicah se nihče ne spomni, kaj je ločevalo v2 od v3 ali zakaj je bila v4 opuščena. Sistematično beleženje vsakega zagona – sestava nabora podatkov, vir novih primerov, hiperparametri, rezultati in sprejeta odločitev – vam zagotovi te informacije, ko vas regresija prisili, da sledite korakom nazaj. Posebno pozornost namenite viru novih primerov: le to vam bo čez mesece povedalo, ali je poslabšanje prišlo zaradi slabo izbrane serije podatkov.

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

Ključne ugotovitve

  • Prilagajanje je iterativno – načrtujte več ciklov
  • Pred popravilom v podatkih kategorizirajte napake
  • Povratne informacije uporabnikov pretvorite v učne primere
  • Po 2–3 zaporednih iteracijah začnite znova z osnovnim modelom
  • Dokumentirajte vsako iteracijo za ohranjanje jasne zgodovine