Automatizované vyhodnocování promptů
Na této stránce
Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry
temperatureatop_pjsou přijímány pouze při úsilí o uvažování (reasoning effort) nastaveném nanone, zatímco modely GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která tyto parametry nastavují, musí proto specifikovatreasoning={"effort": "none"}(Responses API) neboreasoning_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.