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

A finomhangolás elindítása az API-n keresztül

5. lecke 16 közül Frissítve 2026. november 2. Haladó
Ezen az oldalon
  1. A folyamat áttekintése
  2. Az SDK telepítése és konfigurálása
  3. Fájlok feltöltése
  4. A finomhangolási feladat létrehozása
  5. A haladás nyomon követése
  6. A finomhangolt modell használata
  7. A feladataid kezelése
  8. Költségek és időtartam
  9. Főbb megállapítások

Frissítés: 2026. november 2. – A finomhangolás elérhetősége. Az OpenAI megszünteti a saját kiszolgálású finomhangolási szolgáltatását: 2026. május 7-től azok a szervezetek, amelyek még sosem futtattak finomhangolási feladatot, már nem hozhatnak létre újat; július 2-tól kezdve 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üket ki nem vonják. Ez a tananyag továbbra is hasznos egy meglévő modell megértéséhez és kiaknázásához; új projektek esetén azonban a prompt mérnökséget, a RAG-ot és az értékeléseket helyezd előtérbe.

A folyamat áttekintése

Az adataid készen állnak, validálva vannak, valamint tanító és ellenőrző készletekre vannak osztva. Maga a betanítási lépés három műveletre redukálódik: töltsd fel az adatfájlt, hozz létre egy finomhangolási feladatot, majd várd meg, amíg a betanítás befejeződik. Minden az hivatalos Python SDK-n keresztül történik, és látni fogod, hogy a kód kb. harminc sorba fér bele – a munka nagy része már upstream megtörtént.

Az SDK telepítése és konfigurálása

A kliens argumentumok nélkül példányosítható: automatikusan beolvassa az OPENAI_API_KEY környezeti változót.

# Telepítés
# pip install openai

from openai import OpenAI

# A kliens automatikusan használja az OPENAI_API_KEY környezeti változót
client = OpenAI()

Győződj meg róla, hogy ez a változó be van állítva a szkript futtatása előtt, különben a példányosítás már az első kérésnél meghiúsul. Éles környezetben soha ne építsd be közvetlenül a kulcsot a kódba: a sima szövegként megírt kulcs bekerül a Git előzményeibe, és utólagos eltávolítása sokkal költségesebb, mint ha már az első naptól a környezetből olvasnád be.

Fájlok feltöltése

A feltöltéshez a purpose="fine-tune" paramétert használd, ami jelzi az OpenAI számára, hogy a fájlt betanításra szánod, és ez elindítja a megfelelő formátumellenőrzéseket. Azonnal töltsd fel az ellenőrző fájlt is: technikailag opcionális, de nélküle a betanítás vakrepülés lesz, mivel nincs olyan validációs veszteségérték, amely a feladat futása közben jelezné a túlillesztést (overfitting).

# Tanító fájl feltöltése
training_file = client.files.create(
    file=open("training_data.jsonl", "rb"),
    purpose="fine-tune"
)

print(f"Fájl ID: {training_file.id}")
print(f"Állapot: {training_file.status}")

# Opcionális: ellenőrző fájl feltöltése
validation_file = client.files.create(
    file=open("validation_data.jsonl", "rb"),
    purpose="fine-tune"
)

print(f"Ellenőrző ID: {validation_file.id}")

A fájl az OpenAI oldalán egy feldolgozási fázison megy keresztül. Várd meg, amíg az állapot processed nem lesz, mielőtt elindítanád a feladatot: egy még feldolgozás alatt álló fájlra létrehozott feladat meghiúsul, és perceket pazarolsz majd egy nem létező ok keresésével a JSONL-edben.

A finomhangolási feladat létrehozása

job = client.fine_tuning.jobs.create(
    training_file=training_file.id,
    validation_file=validation_file.id,  # opcionális, de ajánlott
    model="gpt-5.6-luna",  # vagy "gpt-5.6-luna"
    suffix="my-assistant-v1"  # utótag a modelled azonosításához
)

print(f"Feladat ID: {job.id}")
print(f"Állapot: {job.status}")
print(f"Alapmodell: {job.model}")

A suffix paraméter hozzáfüződik a finomhangolt modelled nevéhez: a "my-assistant-v1" értékkel a kapott modell neve ft:gpt-5.6-luna:your-org::my-assistant-v1:xxxxxxxx lesz. Szoktasd rá magad, hogy ide tedd a használati esetet és egy verziószámot. Amikor három modell coexistál a fiókodban, ez lesz az egyetlen dolog, ami megmondja, melyik mit csinál anélkül, hogy megnyitnád a konzolt.

A haladás nyomon követése

Egy feladat több állapoton megy keresztül sorrendben, és a retrieve hívás bármikor megadja az aktuális állapotot.

# Feladat állapotának lekérése
job = client.fine_tuning.jobs.retrieve(job.id)
print(f"Állapot: {job.status}")
# Lehetséges állapotok: validating_files, queued, running, succeeded, failed, cancelled

Maga az állapot tömör marad. Az események viszont elmesélik a történetet: fájlvalidálás, indítás, lépésről lépésre haladás, befejezés.

# Feladat eseményeinek megtekintése
events = client.fine_tuning.jobs.list_events(
    fine_tuning_job_id=job.id,
    limit=20
)

for event in events.data:
    print(f"[{event.created_at}] {event.message}")

Ahelyett, hogy ötpercenként manuálisan hívnád meg a retrieve függvényt, csomagold a várakozást egy ciklusba, amely visszaveszi az irányítást, amint a feladat elér egy végállapotot. Vegyed figyelembe, hogy a három kilépési esetet külön kezeljük: egy megszakított feladat nem egyenlő egy meghiúsult feladattal, és a naplóidban érdemes különbséget tenni közöttük.

import time

def track_job(client: OpenAI, job_id: str, interval: int = 30):
    """Nyomon követi a finomhangolási feladatot a befejezéséig."""
    while True:
        job = client.fine_tuning.jobs.retrieve(job_id)
        print(f"Állapot: {job.status}")

        if job.status == "succeeded":
            print(f"Finomhangolt modell: {job.fine_tuned_model}")
            return job

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

        if job.status == "cancelled":
            print("Feladat megszakítva.")
            return job

        time.sleep(interval)

# Használat
final_job = track_job(client, job.id)

A finomhangolt modell használata

Amint a feladat sikeresen befejeződik, a modelled pontosan úgy hívható meg, mint egy szabványos modell. Csak a model paraméternek átadott érték változik, ami azt jelenti, hogy egy meglévő alkalmazásban a saját modelledre való átállás gyakorlatilag egy konfigurációs változó módosítására redukálódik.

response = client.responses.create(
    model=final_job.fine_tuned_model,  # pl. "ft:gpt-5.6-luna:org::suffix:xxxxxxxx"
    input="Szia, problémám van a rendelésemmel."
)

print(response.output_text)

A feladataid kezelése

Két hívás elég minden adminisztrációhoz: listázd, mi létezik, és szakítsd meg, ami éppen fut. A megszakítás akkor hasznos, ha a monitoring azt mutatja, hogy a betanítás félresiklott – nincs értelme tokeneket fizetni egy olyan feladatért, amelyről már tudod, hogy rossz modellt fog produkálni.

# Az összes finomhangolási feladat listázása
jobs = client.fine_tuning.jobs.list(limit=10)
for j in jobs.data:
    print(f"{j.id} | {j.status} | {j.model} | {j.fine_tuned_model}")

# Egy futó feladat megszakítása
client.fine_tuning.jobs.cancel(job.id)

Költségek és időtartam

A betanítást a feldolgozott tokenek száma alapján számlázzák. Az időtartam viszont az adataid méretétől és az epochok számától függ.

Adatkészlet méreteBetanítási időtartam
50 példaNéhány perc
500 példa15–30 perc
5 000 példa1–2 óra

Ezek a nagyságrendek főleg abban segítenek, hogy méretezd a munkafolyamatodat: néhány perces futásidőnél ugyanabban a munkamenetben iterálsz; két óránál pedig tervezned kell. A pontos árak a választott modelltől függően változnak; az aktuális díjakért tekintsd meg az OpenAI árazási oldalát.

Főbb megállapítások

  • A munkafolyamat: fájl feltöltése, feladat létrehozása, várakozás, a modell használata
  • Adj hozzá leíró suffix utótagot a modelleid könnyű azonosításához
  • Mindig használj ellenőrző fájlt a minőség értékeléséhez
  • A finomhangolt modellt pontosan úgy használod az API-n keresztül, mint az alapmodellt
  • Őrizd meg a feladat- és modellazonosítóidat – a verziókezeléshez szükséged lesz rájuk