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

Automatizované vyhodnocování promptů

Lekce 16 z 16 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Automatizované vyhodnocování promptů
  2. Typy vyhodnocování
  3. Kompletní pipeline vyhodnocování
  4. Sada testů: Formát
  5. Integrace CI/CD
  6. Dashboard vyhodnocování
  7. Nastav si své ochranné zábrany
  8. Klíčové poznatky
  9. Ověř si své znalosti

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"} (Responses API) nebo reasoning_effort="none" (Chat Completions). Zdroje: Používání GPT-6 · GPT-5.6 Terra.

Automatizované vyhodnocování promptů

Automatizované vyhodnocování je základním kamenem zralého pipeline pro inženýrství promptů. Umožňuje ti detekovat regrese, porovnávat modely a validovat změny před nasazením. Bez něj je každá změna promptu slepým hazardem.

Typy vyhodnocování

Tři rodiny evaluátorů si rozdělují práci podle povahy očekávaného výstupu a téměř vždy budeš kombinovat několik z nich.

Vyhodnocování přesné shody (Exact Match)

Pro úlohy s jedinou očekávanou odpovědí stačí přímé porovnání. Funkce eval_exact_match před porovnáním normalizuje velká/malá písmena a mezery: bez tohoto opatření by se „Bug“ a „bug“ počítaly jako chyba, což by tě nutilo opravovat problém, který neexistuje.

Funkce eval_set_match řeší případy, kdy je odpovědí množina – entity nalezené v dokumentu, kategorie přiřazené článku. Odvozuje přesnost (precision) a úplnost (recall), dvě čísla, která vyprávějí různé příběhy: vysoká přesnost s nízkou úplností signalizuje příliš opatrný model, který extrahuje pouze to, čím si je jistý; opak prozrazuje model, který halucinuje, aby zaplnil mezery. F1 skóre je convenientně shrnuje, ale pro diagnostiku je nenahrazuje.

def eval_exact_match(prediction: str, reference: str) -> bool:
    """Přesná shoda po normalizaci."""
    return prediction.strip().lower() == reference.strip().lower()

def eval_set_match(prediction: set, reference: set) -> dict:
    """Shoda množin (entity, kategorie)."""
    tp = len(prediction & reference)
    fp = len(prediction - reference)
    fn = len(reference - prediction)

    precision = tp / (tp + fp) if (tp + fp) > 0 else 0
    recall = tp / (tp + fn) if (tp + fn) > 0 else 0
    f1 = (2 * precision * recall / (precision + recall)
          if (precision + recall) > 0 else 0)

    return {"precision": precision, "recall": recall, "f1": f1}

Sémantické vyhodnocování (Embedding)

Pro textové odpovědi, kde se může lišit formulace, se přesná shoda stává absurdní: „Vaše objednávka bude doručena zítra“ a „Doručení je naplánováno na zítra“ říkají totéž, přesto by získaly nulové skóre. Kosinová podobnost mezi embeddingy měří sémantickou blízkost místo shody znaků a vrací spojité skóre.

Nastavíš práh, nad kterým je odpověď považována za přijatelnou. Zkalibruj ho na několika desítkách párů, které jsi ručně klasifikoval jako „ekvivalentní“ nebo „různé“, a pak vyber hodnotu, která nejlépe odděluje tyto dvě skupiny: práh zvolený podle pocitu produkuje výsledky stejně libovolné jako žádné měření, s přidanou iluzí rigóznosti.

from openai import OpenAI
import numpy as np

client = OpenAI()

def eval_semantic_similarity(prediction: str,
                              reference: str) -> float:
    """Kosinová podobnost mezi embeddingy."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=[prediction, reference]
    )
    emb_pred = np.array(response.data[0].embedding)
    emb_ref = np.array(response.data[1].embedding)

    similarity = float(
        np.dot(emb_pred, emb_ref) /
        (np.linalg.norm(emb_pred) * np.linalg.norm(emb_ref))
    )
    return similarity

Vyhodnocování pomocí LLM (LLM-as-Judge)

Model hodnotí kvalitu odpovědi. Toto je jediný životaschopný přístup, když neexistuje referenční odpověď: nikdo ti ručně nenapíše „správnou“ odpověď podpory pro dvě stě tiketů.

To, co činí soudce použitelným, se redukuje na několik věcí. Zaprvé, použitý model: jako soudce vybíráš schopnější model, zde gpt-5.6-sol, protože soudce na stejné úrovni jako hodnocený má tendenci validovat jeho vlastní chyby. Zadruhé, požadavek na zdůvodnění: motivace každého skóre stabilizuje úsudek a umožňuje ti odhalit evaluátora používajícího špatné kritérium – zdůvodnění diskutující o délce, když kritériem byla srozumitelnost, je varovným signálem. Nakonec, temperature nastavená na 0.1 zajišťuje stabilitu skóre mezi jednotlivými běhy.

def eval_llm_judge(question: str, prediction: str,
                    criteria: list[str]) -> dict:
    """Vyhodnocení modelem soudce."""
    criteria_text = "\n".join(
        f"- {c}: score from 1 to 5" for c in criteria
    )

    response = client.responses.create(
        model="gpt-5.6-sol",  # Schopnější model jako soudce
        reasoning={"effort": "none"},  # temperature vyžaduje effort none
        instructions="Jsi expertní, nestranný evaluátor.",
        input=f"""Vyhodnoť tuto odpověď podle následujících kritérií:

Položená otázka: {question}

Odpověď k vyhodnocení: {prediction}

Kritéria:
{criteria_text}

Pro každé kritérium udělej skóre od 1 do 5 se zdůvodněním.""",
        text={
            "format": {
                "type": "json_schema",
                "name": "evaluation",
                "schema": {
                    "type": "object",
                    "properties": {
                        "scores": {
                            "type": "array",
                            "items": {
                                "type": "object",
                                "properties": {
                                    "criterion": {"type": "string"},
                                    "score": {"type": "integer"},
                                    "justification": {"type": "string"}
                                },
                                "required": ["criterion", "score",
                                              "justification"],
                                "additionalProperties": False
                            }
                        },
                        "overall_score": {"type": "number"},
                        "verdict": {"type": "string"}
                    },
                    "required": ["scores", "overall_score", "verdict"],
                    "additionalProperties": False
                },
                "strict": True
            }
        },
        temperature=0.1
    )
    return json.loads(response.output_text)

Kompletní pipeline vyhodnocování

EvalPipeline sestavuje tyto stavební bloky: načte sadu testů, spustí prompt na každém případě, aplikuje všechny poskytnuté evaluátory a agreguje skóre. Evaluátory jsou předávány jako seznam funkcí, všechny volané se stejnou signaturou; přidání metriky tedy nevyžaduje žádnou úpravu pipeline a můžeš spustit přesnou shodu, sémantickou podobnost i soudce na stejném执行ení, aniž bys platil za generování třikrát.

Metoda summary také akumuluje spotřebované tokeny. Tato zdánlivě vedlejší řádka tě chrání před běžnou pastí: verze promptu, která získá dva body skóre, ale ztrojnásobí účet, nemusí být nutně tou správnou volbou, a je lepší se to dozvědět v době rozhodování o kompromisech, než když přijde měsíční faktura.

import json
from dataclasses import dataclass
from pathlib import Path

@dataclass
class TestCase:
    """Testovací případ pro vyhodnocení."""
    input_text: str
    expected_output: str = None
    metadata: dict = None

class EvalPipeline:
    """Automatizované pipeline vyhodnocování."""

    def __init__(self, test_suite_path: str):
        """Načte sadu testů z JSON souboru."""
        data = json.loads(Path(test_suite_path).read_text())
        self.test_cases = [TestCase(**tc) for tc in data]
        self.results = []

    def run(self, prompt_config: dict,
            evaluators: list[callable]) -> dict:
        """Spustí všechny testy a vyhodnotí výsledky."""
        self.results = []

        for tc in self.test_cases:
            # Generování odpovědi
            response = client.responses.create(
                model=prompt_config["model"],
                reasoning={"effort": "none"},  # temperature vyžaduje effort none
                instructions=prompt_config["system_prompt"],
                input=tc.input_text,
                temperature=prompt_config.get("temperature", 0.1)
            )

            prediction = response.output_text

            # Vyhodnocení každým evaluátorem
            scores = {}
            for evaluator in evaluators:
                score = evaluator(
                    question=tc.input_text,
                    prediction=prediction,
                    reference=tc.expected_output
                )
                scores[evaluator.__name__] = score

            self.results.append({
                "input": tc.input_text,
                "expected": tc.expected_output,
                "prediction": prediction,
                "scores": scores,
                "tokens": {
                    "input": response.usage.input_tokens,
                    "output": response.usage.output_tokens
                }
            })

        return self.summary()

    def summary(self) -> dict:
        """Shrnuje výsledky vyhodnocení."""
        if not self.results:
            return {"error": "Žádné výsledky"}

        # Agregace skóre podle evaluátoru
        all_scores = {}
        for result in self.results:
            for eval_name, score in result["scores"].items():
                if eval_name not in all_scores:
                    all_scores[eval_name] = []
                if isinstance(score, (int, float)):
                    all_scores[eval_name].append(score)
                elif isinstance(score, dict) and "f1" in score:
                    all_scores[eval_name].append(score["f1"])

        summary = {
            "total_tests": len(self.results),
            "average_scores": {
                name: sum(scores) / len(scores)
                for name, scores in all_scores.items()
                if scores
            },
            "total_token_cost": sum(
                r["tokens"]["input"] + r["tokens"]["output"]
                for r in self.results
            )
        }
        return summary

Sada testů: Formát

Formát sady testů zůstává úmyslně minimální: vstup, očekávaný výstup a metadata volného formátu. Tato metadata jsou užitečnější, než se zdá – označením každého případu kategorií rozkládáš skóre a zjišťuješ, že tvůj klasifikátor selhává ne náhodně, ale u specifické rodiny požadavků, což globální průměr 88 % neodhalí. Tři níže uvedené příklady také ukazují, co by měla dobrá sada obsahovat: jasné případy, jako je pád aplikace při startu, ale také případy, které hraničí s jinou kategorií – otázka ohledně chybějící funkce vypadá velmi podobně jako hlášení chyby a právě na této hranici se rozhoduje o kvalitě klasifikátoru.

[
    {
        "input_text": "My package hasn't arrived",
        "expected_output": "complaint",
        "metadata": {"category": "delivery"}
    },
    {
        "input_text": "How do I enable dark mode?",
        "expected_output": "question",
        "metadata": {"category": "feature"}
    },
    {
        "input_text": "The app crashes on startup on iOS 18",
        "expected_output": "bug",
        "metadata": {"category": "technical"}
    }
]

Integrace CI/CD

Spusť vyhodnocení při každé změně promptu. Funkce ci_eval_check promění měření v ochrannou zábranu: spustí pipeline, porovná průměrné skóre s prahem a vrátí boolean, který tvůj integrační řetězec interpretuje jako úspěch nebo selhání buildu. Změna, která sníží přesnost pod 85 %, se již nedostane do produkce, stejně jako rozbitý unit test zablokuje merge.

Nastav práh na základě skóre, kterého již dosahuje aktuální verze, nikoliv z ideálu. Nastavíš-li ho příliš vysoko, odsoudíš tým k obcházení ověřování pomocí dočasných deaktivací, které se stanou trvalými; nastavíš-li ho příliš nízko, nekontroluješ nic, zatímco zobrazuješ zelený odznak. Nakonec měj na paměti, že sada musí zůstat reprezentativní pro reálný provoz: práh splněný na dvaceti případech napsaných před dvěma lety nic neprokazuje o dnešních požadavcích.

def ci_eval_check(prompt_config: dict,
                   test_suite: str,
                   min_score: float = 0.85) -> bool:
    """Brána CI/CD: kontroluje, zda prompt splňuje minimální skóre."""
    pipeline = EvalPipeline(test_suite)

    def accuracy(question, prediction, reference):
        return 1.0 if prediction.strip().lower() == reference.strip().lower() else 0.0

    results = pipeline.run(prompt_config, [accuracy])
    avg_score = results["average_scores"].get("accuracy", 0)

    print(f"Průměrné skóre: {avg_score:.2%}")
    print(f"Minimální práh: {min_score:.2%}")

    if avg_score < min_score:
        print("SELHÁNÍ: skóre pod prahem")
        return False

    print("ÚSPĚCH: prompt validován")
    return True

Dashboard vyhodnocování

Sleduj vývoj skóre v čase. Jediné skóre nic neříká; série vypráví příběh tvého promptu a odpovídá na otázku, která vždy vyvstane na schůzkách: děláme pokrok? Níže uvedená funkce produkuje Markdown tabulku, která vedle sebe staví pro každou verzi průměrné skóre, spotřebované tokeny a odhadované náklady. Formát není náhodný: lze jej přímo vložit do pull requestu, což činí porovnání čitelným pro lidi, kteří nikdy neotevřou tvůj kód.

def comparison_report(results: dict[str, dict]) -> str:
    """Generuje srovnávací zprávu mezi verzemi promptů."""
    report = "# Srovnávací zpráva vyhodnocení\n\n"
    report += "| Verze | Průměrné skóre | Průměrné tokeny | Náklady |\n"
    report += "|---------|---------------|----------------|------|\n"

    for version, data in results.items():
        score = data.get("average_scores", {})
        score_val = list(score.values())[0] if score else 0
        tokens = data.get("total_token_cost", 0)
        report += (f"| {version} | {score_val:.2%} | "
                   f"{tokens} | ${tokens * 5 / 1e6:.4f} |\n")

    return report

Nastav si své ochranné zábrany

Vytvoř sadu dvaceti testovacích případů pro reálný prompt, přičemž umístíš několik hraničních případů místo dvaceti pohodlných příkladů: sada, která napoprvé projde na 100 %, tě nic nenaučí. Implementuj tři typy evaluátorů a spusť je společně na dvou verzích svého promptu. Přesná shoda dá čisté číslo, sémantická podobnost zachytí legitimní přeformulování a soudce osvětlí případy, kde se první dva neshodnou – tyto neshody jsou nejbohatší na lekce o tom, co skutečně očekáváš od modelu.

Porovnej, identifikuj vítěznou verzi a poté nastav CI skript, který zablokuje nasazení, pokud skóre klesne. Systém budeš vědět, že funguje, ten den, kdy odmítne změnu, kterou jsi považoval za samozřejmou.

Klíčové poznatky

  • Automatizované vyhodnocování je nezbytné pro iterace s jistotou
  • Kombinuj podle potřeby vyhodnocování přesné shody, sémantické a LLM-as-judge
  • Udržuj sadu testů, která se vyvíjí spolu s tvou aplikací
  • Integruj vyhodnocování do svého CI/CD s minimálním prahem
  • Použij jako soudce schopnější model k vyhodnocení levnějšího modelu
  • Dokumentuj skóre každé verze pro sledování vývoje

Ověř si své znalosti

Pokročilé techniky a industrializace: závěrečná kontrola.

1. Co obsahuje efektivní systémový prompt?

Odpověď: Role, rozsah, pravidla chování, formát výstupu a zpracování hraničních případů – napsáno jako specifikace, testováno jako kód.

2. Kdy bys měl použít self-consistency?

Odpověď: U úloh vyžadujících uvažování s ověřitelnými odpověďmi: generuj více nezávislých úvah a ponech odpověď většiny – variance se stává spojencem.

3. Co garantuje JSON mód s vynuceným schématem?

Odpověď: Výstup striktně odpovídající schématu (typy, povinná pole, enumerace) – validovaný na straně API a znovu validovaný v kódu (JSON Schema, Zod) pro řetězec bez překvapení.

4. Co je grounding?

Odpověď: Ukotvení odpovědí v poskytnutých faktech (dokumenty, získaná data) namísto paměti modelu – s požadavkem citovat zdroje nebo se zdržet odpovědi mimo ně.

5. Jaký je účel katalogu verzovaných promptů?

Odpověď: Zacházet s prompty jako s artefakty: verze, A/B testy, automatizovaná vyhodnocení při každé změně – víš, co běží v produkci a proč.

Závěrečná smyčka kurzu – verzionování, testování, automatické vyhodnocování – transformuje řemeslné inženýrství promptů v týmovou praxi.