Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Metriky a referenční testy

Lekce 17 z 20 Aktualizováno 3. listopadu 2026 Pokročilý
Na této stránce
  1. Měření kvality pomocí metrik
  2. Porovnávání významu, nikoliv slov
  3. Ověření, že model nehalucinuje
  4. Sestavení reprodukovatelného referenčního testu
  5. Klíčové poznatky

Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry temperature a top_p jsou přijímány pouze při úsilí o uvažování (reasoning effort) nastaveném na none, zatímco modely GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která tyto parametry nastavují, musí proto specifikovat reasoning={"effort": "none"} (API Responses) nebo reasoning_effort="none" (Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.

Měření kvality pomocí metrik

Kromě hodnocení typu LLM-as-Judge existují kvantitativní metriky pro evaluaci různých aspektů výstupů LLM. Jejich hodnota nespočívá v tom, že by byly přesnější – dobře navržený soudce LLM postřehne věci, které žádný vzorec nikdy nezachytí – ale v tom, že jsou stabilní a levné. Kosinová podobnost vrátí při každém spuštění přesně stejné číslo, stojí téměř nic, a proto ji můžeš spustit na tisících případů při každém commitu. Soudce LLM si pak necháš pro dimenze, které to skutečně vyžadují.

Než tyto metriky sestavíš do reprodukovatelných referenčních testů, projdeme si ty zásadní.

Porovnávání významu, nikoliv slov

Porovnávání dvou textů znak po znaku se stane nepoužitelným hned, jakmile je formulace volná. Sémantická podobnost tento problém obchází: každý text je převeden na vektor pomocí embedding modelu a my změříme úhel mezi těmito dvěma vektory. Dvě věty, které říkají totéž jinými slovy, směřují stejným směrem.

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+

Příklad je poučný: dvě věty bez jediného společného slova dosáhnou skóre nad 0,85. To je síla této metody, ale také její past. Sémantická podobnost ignoruje negaci a nuance míry – „platba byla přijata“ a „platba byla zamítnuta“ vypadají z hlediska vektorů velmi podobně. Nikdy ji proto nepoužívej osamoceně k ověření odpovědi, kde záleží na faktické přesnosti.

Když jde o otázku „odpovídá odpověď skutečně na položenou otázku“, žádný vzorec nenahradí úsudek. Níže uvedené skóre relevance rozkládá tento úsudek na tři odlišné otázky: Je odpověď přímá? Zůstává zaměřená? Je úplná? Tento rozklad je lepší než globální skóre, protože ti říká, kterým směrem prompt opravit – upřídáný model a neúplný model vyžadují opačné korekce.

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ácené formulace druhého kritéria, kde 5 znamená „žádné nepožadované informace“. To umožňuje sečíst všechna tři skóre stejným směrem, ale pro čtení je to kontra-intuitivní: když přidáváš vlastní kritéria, dodržuj tuto konvenci, jinak získáš průměry, které odměňují chybu, kterou jsi chtěl potrestat.

Ověření, že model nehalucinuje

V aplikacích pro otázky a odpovědi založených na dokumentech není rozhodující metrikou kvalita psaní, ale věrnost zdroji. Kontrolní princip je jednoduchý: předlož soudci původní kontext a vygenerovanou odpověď a požádej ho, aby každé tvrzení klasifikoval jako podložené kontextem, v kontextu chybějící nebo s kontextem v rozporu. Rozdíl mezi těmito posledními dvěma kategoriemi matters, protože tvrzení, které pouze chybí, může být přesnou obecnou znalostí, zatímco tvrzení odporující zdroji 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"}

Zkrácení kontextu na 3 000 znaků je limit, kterého si musíš být vědom: pokud zdroj překročí tuto velikost, budou dokonale přesná tvrzení počítána jako nepodložená jednoduše proto, že úsek, který je odůvodňoval, byl useknut. U dlouhých dokumentů rozděl kontext a evaluuj ho po sekcích, místo abys akceptoval systematické falešně pozitivní výsledky.

Sestavení reprodukovatelného referenčního testu

Referenční test (benchmark) není jen další metrika: je to nastavení, které zmrazí dataset a protokol tak, aby byla dvě spuštění porovnatelná. Níže uvedená třída měří relevanci, věrnost (pokud je k dispozici kontext), latenci a náklady, přičemž každý výsledek uchovává s datem a označením verze 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 metody compare záměrně umisťuje relevanci a latenci na stejný řádek, protože tak se rozhodnutí ve skutečnosti dělají. Model, který získá dvě setiny bodu na relevanci, ale zdvojnásobí dobu odezvy, není lepší volbou pro interaktivní aplikaci; pro noční zpracování možná ano. Tabulka za tebe nerozhodne; postaví kompromis přímo před tvé oči.

Nakonec, total_cost zůstává v této implementaci nulové. Populuj ji z polí usage vrácených API: srovnání modelů, které vynechá náklady, ponechává stranou kritérium, které rozhodne diskusi s tvým finančním týmem.

Klíčové poznatky

  • Sémantická podobnost měří význam, ale zůstává slepá vůči negaci
  • Rozlož relevanci na jednotlivá kritéria místo globálního skóre
  • Detekuj halucinace konfrontací odpovědi se zdrojovým kontextem
  • Vytvářej reprodukovatelné referenční testy, které měří kvalitu, latenci a náklady dohromady
  • Kombinuj automatické metriky a LLM-as-Judge pro kompletní evaluaci