Vyhodnotenie vášho doladeného modelu
Na tejto strane
Aktualizácia 2. novembra 2026 — Dostupnosť doladzovania. Služba vlastného doladzovania od OpenAI sa postupne ukončuje: od 7. mája 2026 organizácie, ktoré ju nikdy nepoužili, už nemôžu vytvárať nové úlohy; od 2. júla musíte mať použitý doladený model za posledných 60 dní; a od 6. januára 2027 žiadny zákazník nebude môcť spustiť nové úlohy. Už natrénované modely zostávajú použiteľné až do vyradenia ich základného modelu. Tento kurz zostáva užitočný na pochopenie a využitie existujúceho modelu; pre nové projekty uprednostnite inžinierstvo promptov, RAG a hodnotenia.
Prečo je hodnotenie nevyhnutné
Úspešné doladenie sa nemeria len stratou (loss). Skutočná otázka znie: je váš doladený model skutočne lepší ako základný model pre váš konkrétny prípad použitia? Čisto klesajúca krivka len dokazuje, že sa model naučil reprodukovať vaše príklady; nič nehovorí o jeho správaní pri nevidených požiadavkách. Táto lekcia vám ukáže, ako zostaviť rigorózny protokol hodnotenia kombinujúci automatizované metriky, hodnotenie pomocou LLM a ľudskú revíziu.
Vytvorenie testovacej množiny
Vaša testovacia množina musí byť oddelená od trénovacích aj validačných dát. Tento rozdiel je dôležitý: validačná množina monitoruje trénovanie, a preto ovplyvňuje vaše rozhodnutia o hyperparametroch, čo ju postupne kontaminuje. Testovacia množina sa naopak otvorí až po zmrazení modelu. Predstavuje reálne situácie, s ktorými sa model stretne v produkcii, s rovnakým pomerom jednoduchých aj zložitých prípadov. Rozdelenie 80/10/10 na predtým zamiešanom korpuse je rozumným východiskom.
import json
import random
def prepare_datasets(file: str, ratios: tuple = (0.8, 0.1, 0.1)):
"""Rozdelí dáta na trénovaciu/validačnú/testovaciu množinu."""
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)} príkladov")
return datasets
prepare_datasets("all_data.jsonl")
Automatizované hodnotenie
Hodnotenie založené na metrikách
Princíp je jednoduchý: pre každý testovací príklad odstráňte správu asistenta – to je očakávaná odpoveď, ktorú model nesmie vidieť – odošlite zvyšok a uložte vstup, referenčnú odpoveď a vygenerovanú odpoveď vedľa seba. Táto trochstĺpcová štruktúra je základom pre všetko, čo nasleduje; jej použitie na výpočet metrík alebo kvalitatívne posúdenie je len otázkou následného spracovania.
from openai import OpenAI
client = OpenAI()
def evaluate_model(model: str, test_examples: list[dict]) -> dict:
"""Vyhodnotí model na testovacej množine."""
results = []
for ex in test_examples:
# Extrahujte otázku (bez očakávanej odpovede)
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"
)
# Získajte odpoveď modelu
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
Hodnotenie typu LLM-as-a-Judge
Výkonnou technikou je použitie vysoko výkonného modelu na posúdenie kvality odpovedí. Porovnávanie slovo od slova s referenciou sa stáva nepoužiteľným hneď, ako je akceptovateľných viacero formulácií; rozhodca (judge) však ocení podstatu. Kvalita jeho verdiktu závisí výlučne od presnosti promptu: štyri kritériá hodnotené od 1 do 5, vynútený výstup vo formáte JSON a komentár voľným textom, ktorý neskôr využijete na pochopenie zlyhaní. Naplánujte si prípady, keď výstup nie je možné analyzovať, namiesto toho, aby výnimka prerušila celú kampaň.
def evaluate_with_judge(results: list[dict]) -> list[dict]:
"""Používa gpt-5.6-sol ako rozhodcu na vyhodnotenie odpovedí."""
evaluations = []
for r in results:
judge_prompt = f"""Vyhodnoť kvalitu získanej odpovede v porovnaní s očakávanou odpoveďou.
Otázka: {r['input']}
Očakávaná odpoveď: {r['expected']}
Získaná odpoveď: {r['obtained']}
Kritériá (ohodnoť každé od 1 do 5):
1. Presnosť: Sú informácie správne?
2. Úplnosť: Sú pokryté všetky dôležité body?
3. Štýl: Je tón a formát vhodný?
4. Stručnosť: Má odpoveď primeranú dĺžku?
Odpovedz v 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": "Odpoveď nie je možné analyzovať"})
return evaluations
Špecializované metriky
Dva predchádzajúce prístupy fungujú dobre pre písomné odpovede. Akonáhle má výstup vášho modelu pevnú štruktúru, sú možné priamejšie merania, ktoré vám ušetria obchádzku cez rozhodcu.
Pre klasifikáciu
Keď očakávaný výstup patrí do uzavretej množiny – kategória tiketu, sentiment, kód produktu – presná zhoda sa opäť stáva relevantnou. Pred porovnaním normalizujte veľkosť písmen a medzery; inak sa „Urgent“ verzus „urgent“ započíta ako chyba a skreslí vašu mieru úspešnosti.
def classification_metrics(results: list[dict]) -> dict:
"""Vypočíta presnosť, úplnosť a F1 skóre pre úlohu klasifikácie."""
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"Presnosť: {precision:.2%} ({correct}/{total})")
return {"precision": precision, "correct": correct, "total": total}
Pre volanie funkcií (Function Calling)
Volanie funkcií sa hodnotí na dvoch osiach, ktoré sa musia merať oddelene. Model, ktorý vyberie správnu funkciu, ale zle zadá parameter, zlyhá inak než ten, ktorý zavolá úplne nesprávny nástroj: prvý problém sa rieši príkladmi extrakcie, druhý príkladmi diskriminácie. Jedno globálne skóre by toto rozlíšenie zamaskovalo a nechalo by vás pracovať naslepo.
def function_calling_metrics(results: list[dict]) -> dict:
"""Vyhodnotí kvalitu volaní funkcií."""
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"Správna funkcia: {stats['correct_function']}/{stats['total']}")
print(f"Správne parametre: {stats['correct_params']}/{stats['total']}")
return stats
Ľudské hodnotenie
Automatizované hodnotenie nezachytí všetko. Mierne povýšenecký tón, fráza, ktorá nezní vašim zákazníkom, technicky správna, ale nepoužiteľná odpoveď: tieto chyby odhalí len ľudské oko. Protokol je priamočiary. Náhodne vyberte dvadsať až päťdesiat odpovedí, nikdy nie prípady, ktoré ste už označili ako problematické, inak budete merať len vlastnú selektívnu zaujatosť. Potom definujte jasné, merateľné kritériá a formalizujte ich do štandardizovanej hodnotiacej rubriky, aby dvaja recenzenti hodnotili to isté.
Nakoniec nechajte hodnotiť viacero ľudí a vypočítajte zhodu medzi hodnotiteľmi (inter-rater agreement). Silný nesúhlas neznamení nutne zlý model: najčastejšie odhaľuje, že vaša rubrika zostáva nejednoznačná a potrebuje spresnenie, než budete môcť vyvodiť akékoľvek závery.
Príklad hodnotiacej rubriky
| Kritérium | 1 (Slabé) | 3 (Prijateľné) | 5 (Výborné) |
|---|---|---|---|
| Relevancia | Mimo témy | Čiastočne relevantné | Perfektne cielené |
| Tón | Nevhodný | Prijateľný, ale fádny | Perfektne zladený |
| Formát | Nedodržaný | Čiastočne dodržaný | Perfektne dodržaný |
Správa o hodnotení
Jeden posledný reflex oddeľuje hodnotenie od rozhodnutia: zaznamenajte obe skupiny výsledkov do jednej správy sprevádzanej explicitným odporúčaním. Prah, ktorý si nastavíte – tu ľudský priemer 4 na nasadenie do produkcie, 3 na iteráciu nad dátami – musí byť zvolený pred spustením kampane. Ak sa rozhodnete až afterward, vždy sa prispôsobí výsledku, ktorý ste dúfali získať.
def evaluation_report(auto_results: dict, human_results: dict):
"""Generuje kombinovanú správu o hodnotení."""
print("=" * 60)
print("SPRÁVA O VYHODNOTENÍ DOLOADENÉHO MODELU")
print("=" * 60)
print(f"\nAutomatizované metriky:")
for k, v in auto_results.items():
print(f" {k}: {v}")
print(f"\nĽudské hodnotenie:")
for k, v in human_results.items():
print(f" {k}: {v}")
print(f"\nOdporúčanie:")
average_score = sum(human_results.values()) / len(human_results)
if average_score >= 4:
print(" Model je pripravený na produkciu")
elif average_score >= 3:
print(" Potrebné zlepšenia – iterujte nad dátami")
else:
print(" Nedostatočné výsledky – prehodnoťte svoj prístup")
Kľúčové poznatky
- Vždy si vyhraďte nezávislú testovaciu množinu (ani trénovaciu, ani validačnú)
- Kombinujte automatizované a ľudské hodnotenie
- Hodnotenie typu LLM-as-a-judge je dobrým kompromisom medzi oboma prístupmi
- Definujte merateľné kritériá ešte pred začiatkom
- Nízka hodnota straty (loss) nezaručuje kvalitu pre produkciu