Vyhodnocování svých promptů: Metody, hodnotitelé a migrace na Promptfoo
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.
Aktualizace 2. listopadu 2026 — Platforma Evals. OpenAI oznámila ukončení své platformy Evals: stávající vyhodnocení jsou pouze pro čtení od 31. října 2026 a dashboard spolu s API bude uzavřen 30. listopadu 2026, včetně hodnotitelů (graders). OpenAI zveřejnila migrační příručku pro přechod na Promptfoo. Principy vyhodnocování popsané v této lekci zůstávají v platnosti; mění se pouze nástroj.
Proč musíš vyhodnocovat systematicky
Nemůžeš zlepšit to, co neměříš. Když změníš prompt, model nebo parametr, jak poznáš, že se kvalita skutečně zlepšila? Spontánní metodou je vyzkoušet tři nebo čtyři příklady, najít lepší odpovědi a nasadit změny do provozu. To pravidelně selhává, protože testované příklady jsou přesně ty, které způsobily problémy minulý týden: měříš zlepšení tam, kde jsi ho hledal, a přehlížíš regrese vzniklé v případech, které již fungovaly.
Vyhodnocení (evals) mění tuto intuici v objektivní měřítko. Do roku 2026 nabízela OpenAI integrovanou platformu Evals; ta je od 31. října 2026 pouze pro čtení a 30. listopadu bude uzavřena. OpenAI nyní doporučuje Promptfoo, open-source nástroj pro vyhodnocování a red teaming. Dobrou zprávou je, že oba nástroje sdílejí stejné stavební kameny – testovací data, prompty, modely a kritéria skórování. To, co se zde naučíš v kódu Pythonu, lze přímo převést a závěrečná část lekce ukazuje přechod na Promptfoo.
Celý proces strukturuje pět klíčových konceptů. Dataset je sada testovacích případů se vstupy a očekávanými výstupy: je to tvůj referenční bod, ekvivalent sady unit testů. Hodnotitel (grader) je kritérium vyhodnocení – přesná shoda, LLM jako rozhodčí, skóre – které rozhoduje, zda je daná odpověď dobrá. Spuštění (run) je provedení vyhodnocení na datasetu s konkrétním modelem a promptem; je to jednotka, kterou porovnáváš od jedné verze k druhé.
Vytvoř dataset, který vypadá jako tvůj reálný svět
Testovací případ se skládá ze vstupu, očekávaného výstupu a metadat. Ta nejsou jen ozdobná: umožní ti dodatečně zjistit, že celkové skóre 87 % skrývá kolaps v kategorii „kód“, který je kompenzován vynikajícími výsledky v geografii. Bez kategorie nebo obtížnosti máš pouze agregované číslo a to ti nikdy neřekne, kde máš zasáhnout.
import json
# Dataset je seznam testovacích případů
dataset = [
{
"input": "What is the capital of France?",
"expected": "Paris",
"metadata": {"category": "geography", "difficulty": "easy"},
},
{
"input": "Explain Bayes' theorem in one sentence.",
"expected": "Bayes' theorem calculates the probability "
"of an event based on known conditional probabilities.",
"metadata": {"category": "mathematics", "difficulty": "medium"},
},
{
"input": "Write a Python function that reverses a list.",
"expected": "def reverse_list(lst): return lst[::-1]",
"metadata": {"category": "code", "difficulty": "easy"},
},
]
# Uložení jako JSONL
with open("eval_dataset.jsonl", "w") as f:
for case in dataset:
f.write(json.dumps(case, ensure_ascii=False) + "\n")
Dataset vymyšlený v kanceláři hodnotí tvou představivost, nikoli tvou aplikaci. Tví uživatelé formulují své požadavky jinak než ty: překlepy, nedokončené otázky, implicitní kontext. Nejlepším zdrojem testovacích případů jsou proto tvá vlastní produkční data, za předpokladu, že referenční odpovědi ověří člověk – jinak zmrazíš současné chyby jako normu.
import openai
import random
client = openai.OpenAI()
def create_dataset_from_logs(
production_logs: list[dict],
sample_size: int = 100,
) -> list[dict]:
"""Vytvoří vyhodnocovací dataset z produkčních logů."""
# Vzorek
sample = random.sample(
production_logs,
min(sample_size, len(production_logs)),
)
dataset = []
for log in sample:
dataset.append({
"input": log["prompt"],
"expected": log["validated_response"], # Odpověď ověřená člověkem
"metadata": {
"source": "production",
"date": log["date"],
"original_model": log["model"],
},
})
return dataset
Vyber správného hodnotitele
Hodnotitel přesné shody (exact match) je nejpřísnější a nejrychlejší. Hodí se pouze pro úlohy, kde je výstup omezený: klasifikace do tří kategorií, extrakce čísla faktury, odpověď ano/ne. Pokud jej použiješ na volný text, dá nulu i perfektní odpovědi, která je pouze formulována jinak než reference.
def exact_grader(response: str, expected: str) -> dict:
"""Vyhodnotí, zda odpověď přesně odpovídá."""
score = 1.0 if response.strip().lower() == expected.strip().lower() else 0.0
return {"score": score, "type": "exact"}
Hodnotitel inkluze uvolňuje omezení: kontroluje přítomnost očekávaných klíčových slov a vrací částečné skóre. To je správný nástroj pro odpovědi, které musí pokrýt povinné body, přičemž na formulaci nezáleží – například odpověď podpory, která musí zmínit lhůtu pro odstoupení a adresu pro vrácení zboží. Jeho slabina je dobře známá: text obsahující správná slova v absurdním pořadí by získal perfektní skóre.
def inclusion_grader(response: str, keywords: list[str]) -> dict:
"""Zkontroluje, zda odpověď obsahuje očekávaná klíčová slova."""
response_lower = response.lower()
found = sum(1 for word in keywords if word.lower() in response_lower)
score = found / len(keywords) if keywords else 0.0
return {
"score": score,
"found": found,
"total": len(keywords),
"type": "inclusion",
}
Pak tu je ten nejmocnější: jiný LLM hodnotí kvalitu odpovědi. Hodnotitel typu LLM-as-Judge ocení to, co žádná mechanická pravidla nedokážou – srozumitelnost, úplnost, přesnost tónu. Dva implementační detaily z něj dělají praktický nástroj. Zaprvé, temperature=0.0: bez toho by stejný rozhodčí přiřadil stejné odpovědi různé skóre od jednoho spuštění k druhému a tvůj benchmark by ztratil veškerou srovnávací hodnotu. Zadruhé, záchranný mechanismus pro json.JSONDecodeError: rozhodčí, který místo JSONu pouze komentuje, by neměl shodit celou kampaň.
def llm_judge_grader(
question: str,
response: str,
expected: str,
criteria: str = "accuracy, completeness, clarity",
) -> dict:
"""Použije LLM k vyhodnocení kvality odpovědi."""
judge_prompt = f"""Rate the quality of this response on a scale of 1 to 5.
Question: {question}
Expected Response: {expected}
Response to Evaluate: {response}
Criteria: {criteria}
Respond ONLY with JSON:
{{"score": <1-5>, "justification": "<short explanation>"}}"""
response_obj = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature vyžaduje effort none
input=judge_prompt,
temperature=0.0,
)
import json
try:
result = json.loads(response_obj.output_text)
result["normalized_score"] = result["score"] / 5.0
return result
except json.JSONDecodeError:
return {"score": 0, "justification": "Chyba parsování", "normalized_score": 0}
Sestav kompletní vyhodnocení
Orchestrace nepředstavuje koncepční obtížnost: iteruješ přes dataset, zavoláš model se systémovým promptem k otestování, aplikuješ hodnotitele a agreguješ výsledky. Zajímavým bodem je, že funkce pro skórování přichází jako parametr, což ti umožňuje přehrát přesně stejný dataset s různými kritérii v závislosti na kampani – inkluze pro rychlou kontrolu během vývoje, LLM rozhodčí pro validaci před nasazením do produkce.
async def run_eval(
dataset: list[dict],
model: str,
system_prompt: str,
grader_fn,
) -> dict:
"""Spustí kompletní vyhodnocení na datasetu."""
results = []
for case in dataset:
response = client.responses.create(
model=model,
instructions=system_prompt,
input=case["input"],
)
score = grader_fn(response.output_text, case["expected"])
results.append({
"input": case["input"],
"expected": case["expected"],
"obtained": response.output_text,
**score,
})
# Výpočet agregovaných metrik
scores = [r["score"] for r in results if "score" in r]
return {
"model": model,
"num_cases": len(dataset),
"average_score": sum(scores) / len(scores) if scores else 0,
"min_score": min(scores) if scores else 0,
"max_score": max(scores) if scores else 0,
"results": results,
}
Zpráva uchovává min_score a detaily každého případu, a to záměrně. Průměr ti řekne, zda se posouváš vpřed; případy s nejhorším skóre ti řeknou proč. Udělej si zvyk číst pět nejhorších odpovědí z každého spuštění, než okomentuješ průměr: právě tam, a jen zřídka jinde, najdeš další opravu, kterou je třeba provést.
Industrializuj s Promptfoo
Psaní vlastních evals ručně v Pythonu je vzdělávací; jejich údržba v čase je pohodlnější s vyhrazeným nástrojem. Migrační příručka OpenAI popisuje logiku Promptfoo: vyhodnocení žije v konfiguračním souboru promptfooconfig.yaml, který sjednocuje prompty, model(y), testovací případy a kritéria – zde nazývaná assertions (tvrzení). Spouští se z příkazového řádku, lokálně nebo v tvém continuous integration, a žije vedle kódu aplikace.
description: Support ticket classification
prompts:
- "Classify this ticket into a single category (billing, technical, account): {{ticket}}"
providers:
- openai:gpt-6.1-sol
tests:
- vars:
ticket: "My card was charged twice this month."
assert:
- type: icontains
value: billing
- vars:
ticket: "The app crashes when I open a PDF."
assert:
- type: icontains
value: technical
promptfoo eval -c promptfooconfig.yaml --no-cache
promptfoo view
promptfoo validate config -c promptfooconfig.yaml # v případě chyby konfigurace
Hodnotitelé z této lekce se znovu objevují jako assertions: přesná shoda, inkluze klíčových slov a úsudek modelu. OpenAI varuje u posledního bodu: znovu vytvořený hodnotitel, zejména LLM rozhodčí, musí být před použitím k rozhodování o regresi znovu validován, protože skóre nemusí být mezi jednotlivými nástroji totožná.
Klíčové poznatky
- Evals mění intuici v objektivní měřítko kvality
- Vytvářej své datasety z reálných produkčních případů ověřených člověkem
- Vyber hodnotitele podle úlohy: přesný pro omezené výstupy, inkluze pro povinné body, LLM-as-Judge pro nuance
- Nastav
temperature=0.0u rozhodčího, aby byla skóre reprodukovatelná - Spouštěj evals před každou změnou promptu nebo modelu
- Platforma Evals od OpenAI se uzavírá 30. listopadu 2026: Promptfoo, doporučovaný OpenAI, přebírá datasety, prompty, modely a kritéria v konfiguračním souboru