Vytváranie vlastných hodnotení
Na tejto strane
Lekcia aktualizovaná 3. novembra 2026 na základe dokumentácie OpenAI: parametre
temperatureatop_psú akceptované len pri úsilí o logické uvažovanie (reasoning effort) nastavenom nanone, zatiaľ čo modely GPT-5.6 štandardne uvažujú (medium). Volania, ktoré nastavujú tieto parametre, preto musia špecifikovaťreasoning={"effort": "none"}(API Responses) aleboreasoning_effort="none"(Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.
Aktualizácia z 2. novembra 2026 — platforma Evals. OpenAI oznámila ukončenie svojej platformy Evals: existujúce hodnotenia sú od 31. októbra 2026 len na čítanie a samotná dashboard aj API, vrátane hodnotiteľov (graders), budú uzavreté 30. novembra 2026. OpenAI zverejnila sprievodcu migráciou na nástroj Promptfoo. Princípy hodnotenia v tejto lekcii zostávajú platné; mení sa len nástroj.
Prispôsobenie hodnotení tvojej doméne
Všeobecní hodnotitelia nestačia na posúdenie kvality v tvojej konkrétnej doméne. Lekársky chatbot, právny asistent a nástroj na marketingové písanie majú každé iné kritériá kvality a tieto kritériá nie sú len početnejšie – sú aj rozdielne prioritizované. Nezhoda tónu v newsletteri je otrava; tá istá nepresnosť v inštrukcii o dávkovaní je vážna chyba. Všeobecný hodnotiteľ zaobchádza s oboma prípadmi rovnako, čo v praxi znamená, že nehodnotí vôbec nič.
Preto potrebuješ vlastné hodnotenia postavené na explicitnej rubrike, ktorá prekladá tvoje obchodné priority do váh. Presne takúto rubriku si teraz vytvoríme.
Preklad obchodnej požiadavky do rubriky
Rubrika je zoznam vážených kritérií, ktorých súčet sa rovná 1. Najužitočnejšou časťou nie je naprogramovanie štruktúry (to zaberie asi pätnásť riadkov), ale jej vyplnenie: rozhodnutie, že benefity pre zákazníka majú váhu 0,25, zatiaľ čo dĺžka len 0,10, si vyžaduje explicitnú konverzáciu s vlastníkmi produktu. Výsledkom je spoločná definícia „dobrej odpovede“, ktorú nikto nemôže následne spochybniť.
from dataclasses import dataclass
@dataclass
class Critere:
nom: str
description: str
poids: float # 0 to 1, sum of weights = 1
@dataclass
class Rubrique:
nom: str
criteres: list[Critere]
def valider(self) -> bool:
total = sum(c.poids for c in self.criteres)
return abs(total - 1.0) < 0.01
# Example: rubric for a marketing writing assistant
rubrique_marketing = Rubrique(
nom="Qualité rédaction marketing",
criteres=[
Critere("ton", "Le ton est professionnel et engageant", 0.20),
Critere("cta", "Contient un appel à l'action clair", 0.15),
Critere("benefices", "Met en avant les bénéfices client", 0.25),
Critere("longueur", "Respecte la longueur demandée", 0.10),
Critere("grammaire", "Aucune faute de grammaire ou orthographe", 0.15),
Critere("marque", "Respecte les guidelines de la marque", 0.15),
],
)
Metódu valider stojí za to volať v testoch, nielen ju napísať. Rubriky sa vyvíjajú: pridáš kritérium compliance, odstrániš to, ktoré už nie je užitočné, a súčet sa posunie na 1,15, pričom nič neohlási anomáliu. Skóre sa stále dajú vypočítať, sú však nesprávne, a pri porovnávaní medzi verziami ťa dovedú k chybným záverom.
Hodnotiteľ následne preloží rubriku do promptu, požiada o skóre 0–5 pre každé kritérium a poskladá vážené globálne skóre. Ku každému skóre patrí krátky komentár: práve ten ti umožní pri recenzii zlých prípadov pochopiť, či model odpovedal zle, alebo bolo tvoje kritérium zle formulované.
import openai
import json
client = openai.OpenAI()
def evaluer_multi_criteres(
question: str,
reponse: str,
rubrique: Rubrique,
) -> dict:
"""Evaluates a response against a multi-criteria rubric."""
criteres_texte = "\n".join(
f"- {c.nom} (poids: {c.poids}): {c.description}"
for c in rubrique.criteres
)
prompt = (
"Évaluez cette réponse selon les critères suivants.\n"
"Pour chaque critère, donnez un score de 0 à 5.\n\n"
f"Question posée : {question}\n"
f"Réponse à évaluer : {reponse}\n\n"
f"Critères :\n{criteres_texte}\n\n"
"Répondez en JSON avec un objet scores contenant pour chaque critère "
"un score (0-5) et un commentaire court."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.0,
)
try:
resultat = json.loads(response.output_text)
scores = resultat.get("scores", {})
# Calculate weighted score
score_pondere = 0
for critere in rubrique.criteres:
if critere.nom in scores:
score_brut = scores[critere.nom]["score"] / 5.0
score_pondere += score_brut * critere.poids
return {
"score_global": score_pondere,
"scores_details": scores,
"rubrique": rubrique.nom,
}
except (json.JSONDecodeError, KeyError):
return {"score_global": 0, "erreur": "Parsing échoué"}
Daj si pozor na výpočtovú slučku: ak kritérium chýba v odpovedi hodnotiteľa, je ticho ignorované a prispieva nulou k váženému skóre. Vynikajúca odpoveď by tak mohla skončiť maximálne na 0,75 len preto, že hodnotiteľ zabudol na kľúč. Ak sa ti skóre zasekávajú pod nevysvetliteľným stropom, skontroluj scores_details skôr, než obviníš hodnotený model.
Keď stroj hodnotí lepšie ako človek
Nechať LLM hodnotiť kód je nákladná skratka: jediný verdikt, na ktorom záleží, je vykonanie. Nižšie uvedený hodnotiteľ spojí vygenerovaný kód a test, zapíše ich do dočasného súboru, spustí ich a spočíta úspechy. Výsledné skóre nepotrebuje interpretáciu – test buď prejde, alebo nie.
import subprocess
import tempfile
def evaluer_code_python(
code_genere: str,
tests: list[str],
) -> dict:
"""Evaluates Python code by executing it against tests."""
resultats_tests = []
for i, test in enumerate(tests):
code_complet = f"{code_genere}\n\n{test}"
with tempfile.NamedTemporaryFile(
mode="w", suffix=".py", delete=False
) as f:
f.write(code_complet)
f.flush()
try:
resultat = subprocess.run(
["python3", f.name],
capture_output=True,
text=True,
timeout=10,
)
succes = resultat.returncode == 0
resultats_tests.append({
"test": i,
"succes": succes,
"sortie": resultat.stdout[:200],
"erreur": resultat.stderr[:200] if not succes else "",
})
except subprocess.TimeoutExpired:
resultats_tests.append({
"test": i,
"succes": False,
"erreur": "Timeout (10s)",
})
nb_succes = sum(1 for r in resultats_tests if r["succes"])
return {
"score": nb_succes / len(tests) if tests else 0,
"tests_passes": nb_succes,
"tests_total": len(tests),
"details": resultats_tests,
}
Nastavenie timeout=10 nie je len preventívne opatrenie pre komfort: modely pravidelne produkujú nekonečné slučky a bez tohto obmedzenia by sa tvoja hodnotiaca kampaň zasekla na prvom zlyhávajúcom prípade. Pamätaj tiež, že spúšťaš kód, ktorý si nenapísal – mimo izolovaného vývojového prostredia si táto funkcia vyžaduje sandbox.
Zhrnutie ilustruje zmiešaný prípad, kde je časť úsudku mechanická a časť nie. Dĺžka je merateľná: vypočítaný pomer penalizuje príliš krátke aj príliš dlhé zhrnutie symetricky, čo eliminuje trik modelu kopírovať zdrojový text, aby nič nevynechal. Vernosť sa však nedá merať pravidlom a vracia sa k LLM hodnotiteľovi s priamou otázkou na vymyslené informácie.
def evaluer_resume(
texte_original: str,
resume: str,
longueur_cible: int = 100,
) -> dict:
"""Evaluates summary quality."""
mots_resume = len(resume.split())
ratio_longueur = min(
mots_resume / longueur_cible,
longueur_cible / max(mots_resume, 1),
)
# Fidelity via LLM
response = client.responses.create(
model="gpt-5.6-terra",
input=(
f"Le résumé suivant est-il fidèle au texte original ? "
f"Contient-il des informations inventées ?\n\n"
f"Texte original (extrait) : {texte_original[:2000]}\n\n"
f"Résumé : {resume}\n\n"
f"Répondez en JSON avec les clés : fidélité (0-5), "
f"hallucinations (oui/non), commentaire (court)."
),
temperature=0.0,
)
try:
fidelite = json.loads(response.output_text)
except json.JSONDecodeError:
fidelite = {"fidelite": 0, "hallucinations": "inconnu"}
return {
"score_longueur": ratio_longueur,
"score_fidelite": fidelite.get("fidelite", 0) / 5.0,
"hallucinations": fidelite.get("hallucinations", "inconnu"),
"mots_resume": mots_resume,
"longueur_cible": longueur_cible,
}
Zabezpečenie opakovateľnosti hodnotenia
Hodnotenie, ktoré spúšťaš manuálne, sa časom prestane spúšťať úplne. Pipeline zapuzdruje rubriku a uchováva históriu kampaní, čím mení jednorazové meranie na časový rad: uvidíš, že priemerné skóre kleslo z 0,81 na 0,79 po zmene promptu v utorok – informáciu, ktorú by ti žiadna izolovaná exekúcia neposkytla.
class PipelineEval:
"""Reusable evaluation pipeline."""
def __init__(self, nom: str, rubrique: Rubrique):
self.nom = nom
self.rubrique = rubrique
self.historique: list[dict] = []
def evaluer_batch(
self,
dataset: list[dict],
modele: str,
prompt_systeme: str,
) -> dict:
"""Evaluates a full batch and returns metrics."""
resultats = []
for cas in dataset:
response = client.responses.create(
model=modele,
instructions=prompt_systeme,
input=cas["input"],
)
eval_result = evaluer_multi_criteres(
cas["input"],
response.output_text,
self.rubrique,
)
resultats.append(eval_result)
scores = [r["score_global"] for r in resultats]
rapport = {
"pipeline": self.nom,
"modele": modele,
"nb_cas": len(dataset),
"score_moyen": sum(scores) / len(scores),
"score_min": min(scores),
"score_max": max(scores),
}
self.historique.append(rapport)
return rapport
Jedna rada na začiatok: zostav svoju prvú rubriku len na dvadsiatich prípadoch, nechaj ju paralelne ohodnotiť LLM hodnotiteľom aj odborníkom z danej oblasti a potom obe série porovnaj. Rozdiely ti povedia, ktoré kritériá sú zle popísané, dlho predtým, než ti niečo prezradia o kvalite modelu.
Kľúčové poznatky
- Vytváraj hodnotiace rubriky špecifické pre tvoju obchodnú doménu s explicitnými váhami.
- Overuj, či súčet váh zostáva rovný 1, ako sa rubrika vyvíja.
- Kombinuj automatizované hodnotenie (kód, dĺžka) a prístup LLM-as-Judge (kvalita).
- Testuj generovaný kód jeho spustením s časovým limitom a v izolovanom prostredí.
- Buduj opakovateľné pipeline, ktoré uchovávajú históriu kampaní.