Metriky a referenčné hodnoty
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.
Meranie kvality pomocou metrík
Okrem hodnotení typu LLM-as-Judge existujú kvantitatívne metriky na vyhodnotenie rôznych aspektov výstupov LLM. Ich hodnota nespočíva v tom, že sú presnejšie – dobre zostavený LLM rozhodca vidí veci, ktoré žiadny vzorec nikdy neuvidí –, ale v tom, že sú stabilné a lacné. Kosínusová podobnosť vráti pri každom spustení úplne rovnaké číslo, stojí takmer nič, a preto ju môžeš spustiť na tisíckach prípadov pri každom commite. Následne si LLM rozhodcu vyhradíš pre dimenzie, ktoré si to skutočne vyžadujú.
Predtým, než tieto metriky poskladáš do reprodukovateľných referenčných testov (benchmarkov), si ich podrobne predstavíme.
Porovnávanie významu, nie slov
Porovnávanie dvoch textov znak po znaku sa stáva nepoužiteľným hneď, ako je formulácia voľná. Sémantická podobnosť tento problém obchádza: každý text sa pomocou embedding modelu prevedie na vektor a my meriame uhol medzi týmito dvoma vektormi. Dve vety, ktoré hovoria to isté inými slovami, smerujú rovnakým smerom.
import openai
import numpy as np
client = openai.OpenAI()
def cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
"""Calculates the cosine similarity between two vectors."""
a = np.array(vec_a)
b = np.array(vec_b)
return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))
def semantic_similarity(text_a: str, text_b: str) -> float:
"""Measures the semantic similarity between two texts."""
response = client.embeddings.create(
model="text-embedding-3-large",
input=[text_a, text_b],
)
vec_a = response.data[0].embedding
vec_b = response.data[1].embedding
return cosine_similarity(vec_a, vec_b)
# Example
score = semantic_similarity(
"The cat is on the rug.",
"A feline is resting on the carpet.",
)
print(f"Similarity: {score:.3f}") # ~0.85+
Príklad je poučný: dve vety, ktoré nemajú žiadne spoločné slová, dosahujú skóre nad 0,85. To je silnou stránkou tejto metódy, ale aj jej pascou. Sémantická podobnosť ignoruje negáciu a nuansy stupňa – „platba bola prijatá“ a „platba bola zamietnutá“ vyzerajú z hľadiska vektorov veľmi podobne. Nikdy ju preto nepoužívaj samostatne na validáciu odpovede, kde záleží na faktickej presnosti.
Keď je otázkou „odpovedá odpoveď skutočne na položenú otázku“, žiadny vzorec nenahradí úsudok. Nižšie uvedené skóre relevancie rozkladá tento úsudok na tri odlišné otázky: Je odpoveď priama? Zostáva sústredená? Je úplná? Tento rozklad je lepší ako globálne skóre, pretože ti hovorí, ktorým smerom máš korigovať prompt – uverbose model a neúplný model si vyžadujú opačné korekcie.
def relevance_score(
question: str,
answer: str,
context: str | None = None,
) -> dict:
"""Evaluates whether the answer is relevant to the question."""
prompt = (
"Evaluate the relevance of this answer.\n\n"
f"Question: {question}\n"
)
if context:
prompt += f"Context provided: {context[:1000]}\n"
prompt += (
f"Answer: {answer}\n\n"
"Criteria:\n"
"1. Does the answer directly address the question? (0-5)\n"
"2. Does the answer contain unrequested information? (0-5, 5=none)\n"
"3. Is the answer complete? (0-5)\n\n"
"Respond in JSON with keys: direct, focus, completeness."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.0,
)
import json
try:
scores = json.loads(response.output_text)
average = sum(scores.values()) / (len(scores) * 5)
return {"score": average, "details": scores}
except (json.JSONDecodeError, TypeError):
return {"score": 0, "error": "Parsing failed"}
Všimni si obrátené znenie druhého kritéria, kde 5 znamená „žiadne nepožadované informácie“. To umožňuje sčítať všetky tri skóre rovnakým smerom, ale pri čítaní to môže byť proti intuitívne: keď pridávaš vlastné kritériá, dodržuj túto konvenciu, inak dostaneš priemery, ktoré odmeňujú chybu, ktorú si chcel potrestať.
Overenie, či model nehalucinuje
V aplikácii typu Q&A založenej na dokumentoch nie je rozhodujúcou metrikou kvalita písania, ale vernosť zdroju. Princíp kontroly je jednoduchý: predlož rozhodcovi pôvodný kontext a vygenerovanú odpoveď a požiadaj ho, aby každé tvrdenie klasifikoval ako podporované kontextom, v kontexte chýbajúce alebo v rozpore s ním. Rozdiel medzi týmito dvoma poslednými kategóriami je dôležitý, pretože tvrdenie, ktoré len chýba, môže byť presnou všeobecnou znalosťou, zatiaľ čo tvrdenie, ktoré je v rozpore so zdrojom, je vždy chybou.
def detect_hallucinations(
context: str,
answer: str,
) -> dict:
"""Detects statements not supported by the context."""
prompt = (
"Analyze this answer and identify any statement "
"that is NOT supported by the provided context.\n\n"
f"Context: {context[:3000]}\n\n"
f"Answer: {answer}\n\n"
"For each statement in the answer, indicate:\n"
"- supported: the statement is in the context\n"
"- unsupported: the statement is not in the context\n"
"- invented: the statement contradicts the context\n\n"
"Respond in JSON with the key statements (list) and "
"fidelity_score (0 to 1)."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.0,
)
import json
try:
return json.loads(response.output_text)
except json.JSONDecodeError:
return {"fidelity_score": 0, "error": "Parsing failed"}
Skreslenie kontextu na 3 000 znakov je limitom, ktorý si musíš uvedomovať: ak zdroj presahuje túto veľkosť, úplne presné tvrdenia budú započítané ako nepodporované jednoducho preto, že pasáž, ktorá ich odôvodňuje, bola orezaná. Pri dlhých dokumentoch rozdeľ vyhodnotenie po sekciách, namiesto toho, aby si akceptoval systematické falošne pozitívne výsledky.
Zostavenie reprodukovateľného benchmarku
Benchmark nie je len ďalšia metrika: je to nastavenie, ktoré zmrazí dataset a protokol tak, aby boli dva behy porovnateľné. Nižšie uvedená trieda meria relevanciu, vernosť (ak je k dispozícii kontext), latenciu a náklady, pričom každý výsledok uchováva s dátumom a označením verzie promptu.
from dataclasses import dataclass, field
import time
@dataclass
class BenchmarkResult:
model: str
prompt_version: str
scores: dict
avg_latency: float
total_cost: float
date: str = field(default_factory=lambda: time.strftime("%Y-%m-%d"))
class Benchmark:
"""Reusable benchmark for comparing models and prompts."""
def __init__(self, name: str, dataset: list[dict]):
self.name = name
self.dataset = dataset
self.results: list[BenchmarkResult] = []
def run(
self,
model: str,
system_prompt: str,
prompt_version: str,
) -> BenchmarkResult:
"""Runs the benchmark with a given model and prompt."""
relevance_scores = []
hallucination_scores = []
latencies = []
cost = 0
for case in self.dataset:
start = time.perf_counter()
response = client.responses.create(
model=model,
instructions=system_prompt,
input=case["input"],
)
latency = time.perf_counter() - start
latencies.append(latency)
# Evaluate
relevance = relevance_score(
case["input"], response.output_text
)
relevance_scores.append(relevance["score"])
if case.get("context"):
halluc = detect_hallucinations(
case["context"], response.output_text
)
hallucination_scores.append(
halluc.get("fidelity_score", 0)
)
result = BenchmarkResult(
model=model,
prompt_version=prompt_version,
scores={
"relevance": sum(relevance_scores) / len(relevance_scores),
"fidelity": (
sum(hallucination_scores) / len(hallucination_scores)
if hallucination_scores else None
),
},
avg_latency=sum(latencies) / len(latencies),
total_cost=cost,
)
self.results.append(result)
return result
def compare(self) -> str:
"""Compares all benchmark results."""
lines = [f"Benchmark: {self.name}\n"]
for r in self.results:
lines.append(
f" {r.model} (prompt {r.prompt_version}) | "
f"Relevance: {r.scores['relevance']:.2f} | "
f"Latency: {r.avg_latency:.2f}s"
)
return "\n".join(lines)
Výstup metódy compare zámerne umiestňuje relevanciu a latenciu na jeden riadok, pretože práve takto sa v skutočnosti robí rozhodnutie. Model, ktorý získa dve stotiny bodu na relevancii, ale zdvojnásobí čas odozvy, nie je lepšou voľbou pre interaktívnu aplikáciu; mohol by ňou byť pre nočné spracovanie. Tabuľka nerozhoduje za teba; kladie kompromis priamo pred tvoje oči.
Nakoniec, total_cost zostáva v tejto implementácii nulové. Populuj ho z polí usage vrátených API: porovnanie modelov, ktoré vynecháva náklady, vynecháva kritérium, ktoré rozhodne diskusiu s tvojím finančným tímom.
Kľúčové poznatky
- Sémantická podobnosť meria význam, ale zostáva slepá voči negácii
- Rozdeľ relevanciu na jednotlivé kritériá namiesto globálneho skóre
- Odhaľuj halucinácie konfrontáciou odpovede so zdrojovým kontextom
- Vytváraj reprodukovateľné benchmarky, ktoré merajú kvalitu, latenciu a náklady spoločne
- Kombinuj automatické metriky a LLM-as-Judge pre kompletné vyhodnotenie