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

Spremljanje usposabljanja

Lekcija 7 od 16 Posodobljeno 2. november 2026 Napredni
Na tej strani
  1. Zakaj spremljati usposabljanje
  2. Dve metrike, ki ju morate brati
  3. Sledenje dogodkom prek API-ja
  4. Kontrolne točke in vmesni rezultati
  5. Vedeti, kdaj ustaviti
  6. Povzetno poročilo za vsak tek
  7. Ključne ugotovitve

Posodobitev 2. novembra 2026 — Razpoložljivost prilagajanja. Samostojno prilagajanje (fine-tuning) podjetja OpenAI se postopoma ukinja: organizacije, ki ga še niso uporabljale, od 7. maja 2026 ne morejo več ustvarjati opravil; od 2. julija morate prilagojen model uporabiti 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, arhitekturi RAG in evalvacijam.

Zakaj spremljati usposabljanje

Če zaženete opravilo prilagajanja in ga pozabite, se soočite z dejstvom: uro kasneje odkrijete model, ne da bi vedeli, kaj se je zgodilo vmes. Z opazovanjem metrik med tekom usposabljanja težave odkrijete zgodaj, se odločite za prilagoditev hiperparametrov, preden porabite celoten proračun, in kar je najpomembneje, razumete, zakaj je bil en tek uspešnejši od drugega. Spremljanje niz poskusov spremeni v inženirsko disciplino.

Dve metrike, ki ju morate brati

Izguba pri usposabljanju (training loss) meri, kako zelo se model moti na podatkih za usposabljanje – torej na podatkih, ki jih trenutno zauživa. Ta vrednost bi se morala skozi korake zmanjševati: to je znak, da se učenje dogaja. Izguba, ki zastane ali se ponovno dvigne, kaže na težavo, običajno slabo umerjeno stopnjo učenja ali preveč heterogen korpus.

Validacijska izguba (validation loss) meri zmogljivost na podatkih, ki jih model med usposabljanjem še ni videl – datoteka, ki ste jo odložili med razdelitvijo. To je najbolj zanesljiva metrika za oceno dejanske kakovosti vašega modela, saj je edina, ki je model ne more izboljšati s pomnjenjem. Prav njuno skupno gibanje omogoča diagnozo.

Izguba pri usposabljanju Validacijska izguba Diagnoza
Padajoča Padajoča Vse v redu, nadaljujte
Padajoča Naraščajoča Prekomerno prilagajanje – zmanjšajte število epoh
Zastajanje Zastajanje Premalo prilagajanja – povečajte stopnjo učenja
Nihanje Nihanje Nestabilnost – zmanjšajte stopnjo učenja

Druga vrstica je tista, ki v proizvodnji stane največ: izguba pri usposabljanju, ki stalno pada, medtem ko validacijska izguba narašča, opisuje model, ki se vaše primere nauči dobesedno na pamet. Na papirju se zdi, da se vse izboljšuje; v resnici vsak dodaten korak poslabša njegovo sposobnost odgovarjanja na vprašanja, ki jih še ni videl.

Sledenje dogodkom prek API-ja

API ne pošilja obvestil: opravilo morate redno poizvedovati (polling). Spodnja zanka pridobi nove dogodke, jih prikaže v kronološkem vrstnem redu, pri čemer se izogne ponovnemu prikazu že videnih, in vrne nadzor, takoj ko opravilo doseže končno stanje.

from openai import OpenAI
import time

client = OpenAI()

def monitor_job(job_id: str):
    """Monitors a job in real time."""
    last_event = None

    while True:
        job = client.fine_tuning.jobs.retrieve(job_id)

        # Fetch new events
        events = client.fine_tuning.jobs.list_events(
            fine_tuning_job_id=job_id,
            limit=50
        )

        for event in reversed(events.data):
            if last_event and event.id == last_event:
                continue
            print(f"[{event.created_at}] {event.message}")

        if events.data:
            last_event = events.data[0].id

        if job.status in ("succeeded", "failed", "cancelled"):
            print(f"\nJob finished: {job.status}")
            if job.status == "succeeded":
                print(f"Model: {job.fine_tuned_model}")
            return job

        time.sleep(30)

# Usage
job = monitor_job("ftjob-xxxxxxxxxxxxxxxx")

Dogodki ne vsebujejo le besedilnih sporočil: nosijo tudi vrednosti izgube pri vsakem koraku. Njihovo ekstrakcija vam omogoča izris krivulje namesto branja vrstic dnevnika, prav na krivulji pa na prvi pogled opazite skok validacijske izgube.

def extract_metrics(job_id: str) -> dict:
    """Extracts loss metrics from a completed job."""
    events = client.fine_tuning.jobs.list_events(
        fine_tuning_job_id=job_id,
        limit=200
    )

    training_losses = []
    validation_losses = []

    for event in events.data:
        data = event.data
        if data and "train_loss" in str(data):
            training_losses.append(data)
        if data and "valid_loss" in str(data):
            validation_losses.append(data)

    return {
        "training": training_losses,
        "validation": validation_losses
    }

Kontrolne točke in vmesni rezultati

OpenAI med usposabljanjem shranjuje kontrolne točke. Če opravilo odpove ali ga prekličete, lahko včasih obnovite uporabno vmesno kontrolno točko – z drugimi besedami, prekinjen tek ni nujno izgubljen tek. To je tudi dragocena možnost v primeru poznega prekomernega prilagajanja: kontrolna točka, zajeta pred skokom validacijske izgube, je lahko boljša od končnega modela.

# List checkpoints for a job
checkpoints = client.fine_tuning.jobs.checkpoints.list(
    fine_tuning_job_id=job.id
)

for cp in checkpoints.data:
    print(f"Step {cp.step_number}")
    print(f"  Model: {cp.fine_tuned_model_checkpoint}")
    if cp.metrics:
        print(f"  Training loss: {cp.metrics.train_loss:.4f}")
        if hasattr(cp.metrics, "valid_loss"):
            print(f"  Validation loss: {cp.metrics.valid_loss:.4f}")

Vedeti, kdaj ustaviti

Trije signali upravičujejo prekinitev tekočega usposabljanja. Prvi je validacijska izguba, ki narašča že več korakov, ne le enega: osamljena vrednost je šum, trend skozi pet točk pa je prekomerno prilagajanje. Drugi signal je izguba pri usposabljanju, ki je blizu ničle, kar pomeni, da model vaše primere reproducira dobesedno in se od njih nima kaj več naučiti. Tretji signal je bolj prozaičen: vaši testi se iz ene kontrolne točke v drugo ne izboljšujejo, vsak dodaten korak pa le povečuje račun.

# If you detect a problem, cancel the job
client.fine_tuning.jobs.cancel(job.id)
print("Job cancelled. Adjust your data or hyperparameters and relaunch.")

Povzetno poročilo za vsak tek

Vsako sejo usposabljanja zaključite z izdelavo uporabnega zapisa. Naslednja funkcija v en izhod združi ID opravila, osnovni model, uporabljene epohe, število usposobljenih žetonov in metrike zadnje kontrolne točke. Ta poročila prilepite v svoj dnevnik tekov: čez mesec dni vam bodo povedala, zakaj ste obdržali to različico in ne druge.

def job_report(job_id: str):
    """Generates a summary report for the job."""
    job = client.fine_tuning.jobs.retrieve(job_id)

    print("=" * 50)
    print(f"Job: {job.id}")
    print(f"Base model: {job.model}")
    print(f"Status: {job.status}")
    print(f"Epochs: {job.hyperparameters.n_epochs}")

    if job.status == "succeeded":
        print(f"Fine-tuned model: {job.fine_tuned_model}")
        print(f"Trained tokens: {job.trained_tokens}")

    if job.status == "failed":
        print(f"Error: {job.error}")

    # Checkpoints
    checkpoints = client.fine_tuning.jobs.checkpoints.list(
        fine_tuning_job_id=job_id
    )
    if checkpoints.data:
        latest = checkpoints.data[0]
        print(f"Latest checkpoint: step {latest.step_number}")
        if latest.metrics:
            print(f"  Train loss: {latest.metrics.train_loss:.4f}")

    print("=" * 50)

job_report("ftjob-xxxxxxxxxxxxxxxx")

Ključne ugotovitve

  • Vedno spremljajte validacijsko izgubo – to je vaš pravi pokazatelj kakovosti
  • Če validacijska izguba narašča, prihaja do prekomernega prilagajanja: zmanjšajte število epoh
  • Kontrolne točke vam omogočajo obnovitev vmesnega stanja
  • Avtomatizirajte spremljanje za dolgotrajna opravila
  • Dokumentirajte metrike vsakega teka, da lahko primerjate svoje iteracije