A finomhangolt modell kiértékelése
Ezen az oldalon
Frissítés: 2026. november 2. – A finomhangolás elérhetősége. Az OpenAI saját kiszolgálású finomhangolási szolgáltatását fokozatosan megszüntetik: 2026. május 7. óta azok a szervezetek, amelyek még sosem használták, már nem hozhatnak létre új feladatokat; július 2. óta pedig az elmúlt 60 napban használnod kellett egy finomhangolt modellt. 2027. január 6-tól kezdve egyetlen ügyfél sem indíthat új feladatokat. A már betanított modellek addig használhatók maradnak, amíg az alapmodelljüket nyugdíjaztatják. Ez a tanfolyam 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ést helyezd előtérbe.
Miért elengedhetetlen az értékelés?
Egy sikeres finomhangolást nem csupán a veszteségfüggvény (loss) alapján mérünk. Az igazi kérdés: valóban jobb-e a finomhangolt modelled az alapmodellnél a te konkrét felhasználási esetedben? Egy tisztán csökkenő görbe csak azt bizonyítja, hogy a modell megtanulta reprodukálni a példáidat; semmit nem árul el arról, hogyan viselkedik olyan kérések esetén, amelyeket korábban nem látott. Ez a lecke bemutatja, hogyan építs fel egy szigorú értékelési protokollt, amely egyesíti az automatizált metrikákat, az LLM-alapú bíráskodást és az emberi ellenőrzést.
Tesztkészlet összeállítása
A tesztkészletednek elkülönülten kell kezelnie mind a tanító, mind az validációs adatokat. A különbségtevés fontos: az validációs készlet a tanítást figyeli, és így befolyásolja a hiperparaméter-döntéseidet, ami fokozatosan szennyezi azt. Ezzel szemben a tesztkészletet csak akkor nyitod meg, ha a modell már „befagyott“. Ez képviseli azokat a valós helyzeteket, amelyekkel a modell a éles környezetben találkozni fog, ugyanolyan arányban tartalmazva az egyszerű és a trükkös eseteket. Egy korábban összekevert korpusz 80/10/10-es felosztása jó kiindulópont.
import json
import random
def prepare_datasets(file: str, ratios: tuple = (0.8, 0.1, 0.1)):
"""Splits data into train/validation/test."""
with open(file, "r") as f:
examples = [json.loads(l) for l in f]
random.shuffle(examples)
n = len(examples)
i1 = int(n * ratios[0])
i2 = int(n * (ratios[0] + ratios[1]))
datasets = {
"train": examples[:i1],
"validation": examples[i1:i2],
"test": examples[i2:]
}
for name, data in datasets.items():
with open(f"{name}.jsonl", "w") as f:
for ex in data:
f.write(json.dumps(ex, ensure_ascii=False) + "\n")
print(f"{name}: {len(data)} examples")
return datasets
prepare_datasets("all_data.jsonl")
Automatizált értékelés
Metrika-alapú értékelés
Az elv egyszerű: minden egyes tesztpélda esetén távolítsd el az asszisztens üzenetét – ez a várt válasz, amit a modellnek nem szabad látnia –, küldd el a többit, és tartsd egymás mellett a bemenetet, a referenciaválaszt és a generált választ. Ez a háromoszlopos szerkezet alapja mindennek, ami ezután következik; legyen szó metrikák számításáról vagy minőségi megítélésről, csupán a további feldolgozás módja változik.
from openai import OpenAI
client = OpenAI()
def evaluate_model(model: str, test_examples: list[dict]) -> dict:
"""Evaluates a model on a test set."""
results = []
for ex in test_examples:
# Extract the question (without the expected answer)
input_messages = [
m for m in ex["messages"] if m["role"] != "assistant"
]
expected_answer = next(
m["content"] for m in ex["messages"] if m["role"] == "assistant"
)
# Get the model's response
response = client.responses.create(
model=model,
input=input_messages
)
model_answer = response.output_text
results.append({
"input": input_messages[-1]["content"],
"expected": expected_answer,
"obtained": model_answer
})
return results
LLM mint bíró (LLM-as-a-Judge) értékelés
Erőteljes technika, ha egy nagy teljesítményű modellt bízunk meg a válaszok minőségének megítélésével. A referenciával való szó szerinti összehasonlás használhatatlanná válik, amint többféle megfogalmazás is elfogadható; egy bíró viszont a lényeget értékeli. Ítéletének minősége kizárólag a prompt pontosságától függ: négy, 1-től 5-ig terjedő skálán értékelt kritérium, egy kikényszerített JSON-kimenet, valamint egy szabad szöveges megjegyzés, amelyet később a hibák megértésére használsz. Tervezd meg azokat az eseteket is, amikor a kimenet nem elemezhető, ahelyett, hogy hagynád, hogy egy kivétel megszakítsa a teljes kampányt.
def evaluate_with_judge(results: list[dict]) -> list[dict]:
"""Uses gpt-5.6-sol as a judge to evaluate responses."""
evaluations = []
for r in results:
judge_prompt = f"""Evaluate the quality of the obtained response compared to the expected response.
Question: {r['input']}
Expected response: {r['expected']}
Obtained response: {r['obtained']}
Criteria (rate each from 1 to 5):
1. Accuracy: Is the information correct?
2. Completeness: Are all important points covered?
3. Style: Is the tone and format appropriate?
4. Conciseness: Is the response an appropriate length?
Respond in JSON: {{"accuracy": N, "completeness": N, "style": N, "conciseness": N, "comment": "..."}}"""
response = client.responses.create(
model="gpt-5.6-sol",
input=judge_prompt
)
try:
evaluation = json.loads(response.output_text)
evaluations.append(evaluation)
except json.JSONDecodeError:
evaluations.append({"error": "Response not parseable"})
return evaluations
Specializált metrikák
Az előző két megközelítés jól működik szöveges válaszok esetén. Amint a modelled kimenete rögzített szerkezetű, közvetlenebb mérések válnak lehetővé, amelyekkel megspórolhatod a bírón keresztül vezető kitérőt.
Osztályozás esetén
Amikor a várt kimenet egy zárt halmazba tartozik – például egy jegykategória, egy hangulat vagy egy termékkód –, a pontos egyezés (exact match) ismét relevánssá válik. Normalizáld a nagybetűket és a szóközöket az összehasonlítás előtt; ellenkező esetben az „Urgent“ és az „urgent“ hibának számít, és eltorzítja az arányodat.
def classification_metrics(results: list[dict]) -> dict:
"""Calculates precision, recall, and F1 for a classification task."""
correct = sum(
1 for r in results
if r["expected"].strip().lower() == r["obtained"].strip().lower()
)
total = len(results)
precision = correct / total if total > 0 else 0
print(f"Precision: {precision:.2%} ({correct}/{total})")
return {"precision": precision, "correct": correct, "total": total}
Függvényhívás esetén
A függvényhívást két tengely mentén kell megítélni, amelyeket külön-külön kell mérni. Egy modell, amely kiválasztja a helyes függvényt, de rosszul adja meg a paramétert, másképp hibázik, mint az, amely teljesen rossz eszközt hív meg: az első problémát kivonási példákkal, a másodikat diszkriminációs példákkal javíthatod. Egyetlen globális pontszám elfedné ezt a különbséget, és vakrepülésre kényszerítene.
def function_calling_metrics(results: list[dict]) -> dict:
"""Evaluates the quality of function calls."""
stats = {"correct_function": 0, "correct_params": 0, "total": 0}
for r in results:
stats["total"] += 1
if r.get("expected_function") == r.get("obtained_function"):
stats["correct_function"] += 1
if r.get("expected_params") == r.get("obtained_params"):
stats["correct_params"] += 1
print(f"Correct function: {stats['correct_function']}/{stats['total']}")
print(f"Correct parameters: {stats['correct_params']}/{stats['total']}")
return stats
Emberi értékelés
Az automatizált értékelés nem fed le mindent. Egy enyhén lekezelő hangnem, egy ügyfeleid számára kellemetlen mondat, vagy egy technikailag helyes, de használhatatlan válasz: ezek a hibák csak emberi szem előtt válnak láthatóvá. A protokoll egyenes: véletlenszerűen mintázz húsz-ötven választ, soha ne azokat, amelyeket már korábban problémásként jelöltél meg, mert akkor csak a saját szelekciós torzításodat méred. Ezután definiálj világos, mérhető kritériumokat, és formalizáld őket egy szabványosított értékelési rubrikában, hogy két értékelő ugyanazt bírálja el.
Végül végeztess értékelést több személlyel, és számítsd ki az értékelők közötti egyetértést. Az erős nézeteltérés nem feltétlenül jelent rossz modellt: leggyakrabban azt árulja el, hogy a rubrikád még mindig kétértelmű, és tisztázásra szorul, mielőtt bármilyen következtetést levonnál.
Mintaértékelési rubrika
| Kritérium | 1 (Gyenge) | 3 (Elfogadható) | 5 (Kiváló) |
|---|---|---|---|
| Relevancia | Tárgytalan | Részben releváns | Tökéletesen célzott |
| Hangnem | Nem megfelelő | Elfogadható, de színtelen | Tökéletesen illeszkedő |
| Formátum | Nem követett | Részben követett | Tökéletesen követett |
Értékelési jelentés
Egy utolsó reflexus választja el az értékelést a döntéstől: rögzítsd mindkét eredménytípust egyetlen jelentésben, kísérd explicit ajánlással. Az általad meghatározott küszöbértéket – itt emberi átlagban a 4 a élesítéshez, a 3 az adatokon való iteráláshoz – a kampány indítása előtt kell meghoznod. Ha utólag döntöd el, az mindig a remélt eredményhez fog igazodni.
def evaluation_report(auto_results: dict, human_results: dict):
"""Generates a combined evaluation report."""
print("=" * 60)
print("FINE-TUNED MODEL EVALUATION REPORT")
print("=" * 60)
print(f"\nAutomated metrics:")
for k, v in auto_results.items():
print(f" {k}: {v}")
print(f"\nHuman evaluation:")
for k, v in human_results.items():
print(f" {k}: {v}")
print(f"\nRecommendation:")
average_score = sum(human_results.values()) / len(human_results)
if average_score >= 4:
print(" Model is ready for production")
elif average_score >= 3:
print(" Improvements needed—iterate on data")
else:
print(" Insufficient results—rethink your approach")
Főbb megállapítások
- Mindig különíts el egy független tesztkészletet (se nem tanító, se nem validációs)
- Kombináld az automatizált és az emberi értékelést
- Az LLM mint bíró (LLM-as-a-judge) értékelés jó kompromisszum a kettő között
- Definálj mérhető kritériumokat, mielőtt elkezdenéd
- Egy alacsony veszteségérték (loss) nem garantálja a éles környezeti minőséget