Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Képzés figyelése

7. lecke 16 közül Frissítve 2026. november 2. Haladó
Ezen az oldalon
  1. Miért érdemes figyelni a képzést
  2. A két olvasandó metrika
  3. Események nyomon követése az API-n keresztül
  4. Ellenőrzőpontok és közbenső eredmények
  5. Mikor állj le
  6. Összefoglaló jelentés futtatásonként
  7. Főbb megállapítások

Frissítés: 2026. november 2. — Fine-tuning elérhetőség. Az OpenAI saját kiszolgálású fine-tuning szolgáltatását fokozatosan megszüntetik: 2026. május 7. óta azok a szervezetek, amelyek még soha nem használták, már nem hozhatnak létre feladatokat; július 2. óta az elmúlt 60 napban használnod kellett egy finomhangolt modellt; és 2027. január 6-tól egyetlen ügyfél sem indíthat új feladatokat. A már betanított modellek addig használhatók maradnak, amíg az alapmodelljük nyugdíjazásra nem kerül. Ez a tanfolyam továbbra is hasznos egy meglévő modell megértéséhez és kiaknázásához; új projektek esetén a prompt mérnökséget, a RAG-ot és az értékeléseket helyezd előtérbe.

Miért érdemes figyelni a képzést

Ha elindítasz egy fine-tuning feladatot, és elfelejted, az egy fait accompli-hoz vezet: egy óra múlva rájössz, hogy van egy modelled, de fogalmad sincs, mi történt közben. Ha a képzés futása közben megfigyeled a metrikákat, időben észleled a problémákat, döntést hozhatsz a hiperparaméterek módosításáról, mielőtt elégetnéd a teljes költségkereted, és ami a legfontosabb: megérted, miért teljesített jobban az egyik futtatás, mint a másik. A figyelés a kísérletek sorozatát mérnöki fegyelemmé alakítja.

A két olvasandó metrika

A tanulási veszteség (training loss) azt méri, mennyire téved a modell a tanítóadatokon – azon az adathalmazon, amelyet éppen most fogyaszt. Ennek az értékeknek a lépések során csökkennie kell: ez a jele annak, hogy történik tanulás. Ha a veszteség megáll vagy újra növekszik, az problémára utal, általában rosszul beállított tanulási rátára vagy túl heterogén korpuszra.

A validációs veszteség (validation loss) a teljesítményt méri olyan adatokon, amelyeket a modell a képzés során soha nem látott – ez az a fájl, amelyet a felosztáskor félretettél. Ez a legmegbízhatóbb metrika a modelled tényleges minőségének értékelésére, mert ez az egyetlen, amelyet a modell nem javíthat memorizálással. E kettő együttes evolúciója adja meg a diagnózist.

Tanulási veszteség Validációs veszteség Diagnózis
Csökkenő Csökkenő Minden rendben, folytasd
Csökkenő Növekvő Túltanulás (overfitting) — csökkentsd az epochokat
Megállt Megállt Alultanulás (underfitting) — növeld a tanulási rátát
Oszcilláló Oszcilláló Instabilitás — csökkentsd a tanulási rátát

A második sor az, amelyik a legtöbbbe kerül éles környezetben: egy folyamatosan csökkenő tanulási veszteség, miközben a validációs veszteség újra növekszik, egy olyan modellt ír le, amely szó szerint megtanulta a példáidat. Papíron minden javulni látszik; a valóságban azonban minden egyes további lépés rontja annak a képességét, hogy olyan kérdésre válaszoljon, amelyet még sosem látott.

Események nyomon követése az API-n keresztül

Az API nem küld értesítéseket: neked kell rendszeres időközönként lekérdezned (polling) a feladatot. Az alábbi ciklus lekéri az új eseményeket, időrendi sorrendben jeleníti meg őket, elkerülve a már látottak újbóli megjelenítését, és visszaadja az irányítást, amint a feladat végállapotba kerül.

from openai import OpenAI
import time

client = OpenAI()

def monitor_job(job_id: str):
    """Valós idejű feladatfigyelés."""
    last_event = None

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

        # Új események lekérése
        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"\nFeladat befejeződött: {job.status}")
            if job.status == "succeeded":
                print(f"Modell: {job.fine_tuned_model}")
            return job

        time.sleep(30)

# Használat
job = monitor_job("ftjob-xxxxxxxxxxxxxxxx")

Az események nemcsak szöveges üzeneteket tartalmaznak: minden lépésnél veszteségértékeket is hordoznak. Ezek kinyerésével görbét rajzolhatsz a naplósortok olvasása helyett, és egy görbén pillanatok alatt észreveszed a validációs veszteség kiugrását.

def extract_metrics(job_id: str) -> dict:
    """Veszteségmetrikák kinyerése egy befejezett feladatból."""
    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
    }

Ellenőrzőpontok és közbenső eredmények

Az OpenAI ellenőrzőpontokat (checkpoints) ment a képzés során. Ha a feladat megszakad vagy lemondod, néha sikerülhet egy használható közbenső ellenőrzőpontot visszaállítanod – más szóval egy megszakított futtatás nem feltétlenül elveszett futtatás. Ez értékes megoldás akkor is, ha későn észleled a túltanulást: a validációs veszteség kiugrása előtt készített ellenőrzőpont jobb lehet, mint a végső modell.

# Ellenőrzőpontok listázása egy feladathoz
checkpoints = client.fine_tuning.jobs.checkpoints.list(
    fine_tuning_job_id=job.id
)

for cp in checkpoints.data:
    print(f"Lépés: {cp.step_number}")
    print(f"  Modell: {cp.fine_tuned_model_checkpoint}")
    if cp.metrics:
        print(f"  Tanulási veszteség: {cp.metrics.train_loss:.4f}")
        if hasattr(cp.metrics, "valid_loss"):
            print(f"  Validációs veszteség: {cp.metrics.valid_loss:.4f}")

Mikor állj le

Három jel indokolja egy folyamatban lévő képzési futtatás megszakítását. Az első egy olyan validációs veszteség, amely több lépésen át növekszik, nem csak egyen: egy elszigetelt érték zaj, az öt ponton át tartó tendencia viszont túltanulás. A második egy nullához közeli tanulási veszteség, ami azt jelenti, hogy a modell szóról szóra reprodukálja a példáidat, és nincs már mit tanulnia belőlük. A harmadik prózaibb: a tesztjeid nem javulnak egyik ellenőrzőpontról a másikra, és minden egyes további lépés csak növeli a számlát.

# Ha problémát észlelsz, mondd le a feladatot
client.fine_tuning.jobs.cancel(job.id)
print("Feladat lemondva. Igazítsd az adataidat vagy a hiperparamétereket, majd indítsd újra.")

Összefoglaló jelentés futtatásonként

Minden képzési munkamenetet úgy fejezz be, hogy létrehozol egy cselekvésre ösztönző rekordot. Az alábbi függvény egyetlen kimenetbe gyűjti össze a feladat azonosítóját, az alapmodellt, a használt epochok számát, a betanított tokenek mennyiségét és az utolsó ellenőrzőpont metrikáit. Illeszd be ezeket a jelentéseket a futtatási naplódba: egy hónap múlva elárulják majd, miért ezt a verziót tartottad meg egy másik helyett.

def job_report(job_id: str):
    """Összefoglaló jelentés generálása a feladathoz."""
    job = client.fine_tuning.jobs.retrieve(job_id)

    print("=" * 50)
    print(f"Feladat: {job.id}")
    print(f"Alapmodell: {job.model}")
    print(f"Állapot: {job.status}")
    print(f"Epochok: {job.hyperparameters.n_epochs}")

    if job.status == "succeeded":
        print(f"Finomhangolt modell: {job.fine_tuned_model}")
        print(f"Betanított tokenek: {job.trained_tokens}")

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

    # Ellenőrzőpontok
    checkpoints = client.fine_tuning.jobs.checkpoints.list(
        fine_tuning_job_id=job_id
    )
    if checkpoints.data:
        latest = checkpoints.data[0]
        print(f"Legutóbbi ellenőrzőpont: {latest.step_number}. lépés")
        if latest.metrics:
            print(f"  Tanulási veszteség: {latest.metrics.train_loss:.4f}")

    print("=" * 50)

job_report("ftjob-xxxxxxxxxxxxxxxx")

Főbb megállapítások

  • Mindig figyeld a validációs veszteséget – ez az igazi minőségjelződ
  • Ha a validációs veszteség növekszik, túltanulásról van szó: csökkentsd az epochokat
  • Az ellenőrzőpontok lehetővé teszik egy közbenső állapot visszaállítását
  • Automatizáld a figyelést a hosszú ideig futó feladatoknál
  • Dokumentáld minden futtatás metrikáit az iterációid összehasonlításához