Hodnotenie svojich promptov: Metódy, hodnotitelia a migrácia na Promptfoo
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"}(Responses API) aleboreasoning_effort="none"(Chat Completions). Zdroje: Používanie GPT-6 · GPT-5.6 Terra.
Aktualizácia z 2. novembra 2026 — Platforma Evals. OpenAI oznámila ukončenie svojej platformy Evals: existujúce hodnotenia sú od 31. októbra 2026 len na čítanie a dashboard spolu s API sa uzavrie 30. novembra 2026, vrátane hodnotiteľov (graders). OpenAI vydala sprievodcu migráciou na nástroj Promptfoo. Princípy hodnotenia v tejto lekcii zostávajú platné; mení sa len nástroj.
Prečo musíš hodnotiť systematicky
Nemôžeš zlepšiť to, čo nemeriaš. Keď zmeníš prompt, model alebo parameter, ako zistíš, či sa kvalita skutočne zlepšila? Spontánnou metódou je vyskúšať tri či štyri príklady, nájsť lepšie odpovede a nasadiť zmeny do prevádzky. Toto pravidelne zlyháva, pretože testované príklady sú presne tie, ktoré spôsobovali problémy minulý týždeň: meriaš zlepšenie tam, kde si ho hľadal, a prehliadaš regresie vzniknuté v prípadoch, ktoré už predtým fungovali.
Hodnotenia (evals) menia túto intuíciu na objektívne meranie. Do roku 2026 ponúkala OpenAI integrovanú platformu Evals; tá je od 31. októbra 2026 len na čítanie a 30. novembra bude uzavretá. OpenAI teraz odporúča Promptfoo, nástroj s otvoreným zdrojovým kódom na hodnotenie a red teaming. Dobrou správou je, že oba nástroje zdieľajú rovnaké stavebné kamene – testovacie dáta, prompty, modely a kritériá bodovania. To, čo sa tu naučíš v kóde Python, sa priamo prenesie aj sem a záverečná časť lekcie ukáže prechod na Promptfoo.
Celý proces štruktúrujú tri koncepty. Dataset (súbor dát) je množina testovacích prípadov so vstupmi a očakávanými výstupmi: je to tvoja referenčná hodnota, ekvivalent sady unit testov. Grader (hodnotiteľ) je kritérium hodnotenia – presná zhoda, LLM ako rozhodca, skóre – ktoré rozhoduje, či je daná odpoveď dobrá. Run (spustenie) je vykonanie hodnotenia na datasete s konkrétnym modelom a promptom; je to jednotka, ktorú porovnávaš od jednej verzie k druhej.
Vytvor dataset, ktorý vyzerá ako tvoj reálny svet
Testovací prípad sa skladá zo vstupu, očakávaného výstupu a metadát. Tie nie sú len ozdobné: umožnia ti až dodatočne zistiť, že celkové skóre 87 % skrýva kolaps v kategórii „kód“, ktorý kompenzujú vynikajúce výsledky v geografii. Bez kategórie alebo obtiažnosti máš len agregované číslo a agregované číslo ti nikdy nepovie, kde máš zasiahnuť.
import json
# A dataset is a list of test cases
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"},
},
]
# Save as JSONL
with open("eval_dataset.jsonl", "w") as f:
for case in dataset:
f.write(json.dumps(case, ensure_ascii=False) + "\n")
Dataset vymyslený v kancelárii hodnotí tvoju predstavivosť, nie tvoju aplikáciu. Tvoji používatelia formulujú svoje požiadavky inak ako ty: preklepy, nedopovedané otázky, implicitný kontext. Najlepším zdrojom testovacích prípadov sú preto tvoje vlastné produkčné dáta, za predpokladu, že referenčné odpovede overí človek – inak zamrzneš aktuálne chyby ako normu.
import openai
import random
client = openai.OpenAI()
def create_dataset_from_logs(
production_logs: list[dict],
sample_size: int = 100,
) -> list[dict]:
"""Creates an evaluation dataset from production logs."""
# Sample
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"], # Response validated by a human
"metadata": {
"source": "production",
"date": log["date"],
"original_model": log["model"],
},
})
return dataset
Vyber si správneho hodnotiteľa
Hodnotiteľ presnej zhody (exact match) je najprísnejší a najrýchlejší. Hodí sa len pre úlohy, kde je výstup obmedzený: klasifikácia do troch kategórií, extrakcia čísla faktúry, odpoveď áno/nie. Ak ho použiješ na voľný text, dá nulu dokonalej odpovedi len preto, že je formulovaná inak ako referenčná.
def exact_grader(response: str, expected: str) -> dict:
"""Evaluates if the response matches exactly."""
score = 1.0 if response.strip().lower() == expected.strip().lower() else 0.0
return {"score": score, "type": "exact"}
Hodnotiteľ inklúzie (inclusion grader) uvoľňuje obmedzenie: kontroluje prítomnosť očakávaných kľúčových slov a vracia čiastočné skóre. Toto je správny nástroj pre odpovede, ktoré musia pokryť povinné body, pričom na formulácii nezáleží – napríklad odpoveď podpory, ktorá musí spomenúť lehotu na odstúpenie a adresu pre vrátenie tovaru. Jeho slabina je známa: text obsahujúci správne slová v absurdnom poradí by získal plný počet bodov.
def inclusion_grader(response: str, keywords: list[str]) -> dict:
"""Checks that the response contains the expected keywords."""
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",
}
Potom tu je ten najvýkonnejší: iný LLM hodnotí kvalitu odpovede. Hodnotiteľ typu LLM-as-Judge ocení to, čo žiadne mechanické pravidlo nedokáže – zrozumiteľnosť, úplnosť, presnosť tónu. Dva implementačné detaily ho robia praktickým. Po prvé, temperature=0.0: bez toho by ten istý rozhodca priradil tej istej odpovedi rôzne skóre od jedného spustenia k druhému a tvoj benchmark by stratil všetku porovnávaciu hodnotu. Po druhé, záchranný mechanizmus pre json.JSONDecodeError: rozhodca, ktorý namiesto JSONu komentuje, by nemal zhodiť celú kampaň.
def llm_judge_grader(
question: str,
response: str,
expected: str,
criteria: str = "accuracy, completeness, clarity",
) -> dict:
"""Uses an LLM to evaluate response quality."""
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 requires 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": "Parsing error", "normalized_score": 0}
Poskladaj kompletné hodnotenie
Orchestrácia nepredstavuje koncepčný problém: iteruješ cez dataset, voláš model so systémovým promptom na testovanie, aplikuješ hodnotiteľa a agreguješ výsledky. Zaujímavým bodom je, že funkcia na bodovanie prichádza ako parameter, čo ti umožňuje prehrať úplne ten istý dataset s rôznymi kritériami v závislosti od kampane – inklúzia pre rýchlu kontrolu počas vývoja, LLM rozhodca pre validáciu pred nasadením do prevádzky.
async def run_eval(
dataset: list[dict],
model: str,
system_prompt: str,
grader_fn,
) -> dict:
"""Runs a full evaluation on a dataset."""
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,
})
# Calculate aggregated metrics
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,
}
Správa si ponecháva min_score a detail každého prípadu a je to zámer. Priemer ti povie, či sa posúvaš dopredu; prípady s najhorším skóre ti povedia prečo. Urob si zvyk prečítať si päť najhorších odpovedí z každého spustenia skôr, než okomentuješ priemer: práve tam, a zriedka inde, nájdeš ďalšiu opravu, ktorú treba urobiť.
Industrializuj s Promptfoo
Písanie vlastných evals ručne v Pythone je vzdelávacie; ich údržba v čase je pohodlnejšia so špecializovaným nástrojom. Sprievodca migráciou od OpenAI opisuje logiku Promptfoo: hodnotenie žije v konfiguračnom súbore promptfooconfig.yaml, ktorý spája prompty, model(y), testovacie prípady a kritériá – tu nazývané assertions (tvrdenia). Spúšťa sa z príkazového riadku, lokálne alebo v tvojej kontinuálnej integrácii, a žije vedľa kódu aplikácie.
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 # in case of configuration error
Hodnotitelia z tejto lekcie sa objavujú ako assertions: presná zhoda, inklúzia kľúčových slov a úsudok modelu. OpenAI varuje pred posledným bodom: znovu vytvorený hodnotiteľ, najmä LLM judge, musí byť pred použitím na rozhodovanie o regresii znovu overený, pretože skóre nemusia byť medzi jednotlivými nástrojmi identické.
Kľúčové poznatky
- Evals menia intuíciu na objektívne meranie kvality
- Vytváraj svoje datasety z reálnych produkčných prípadov overených človekom
- Vyber hodnotiteľa podľa úlohy: presný pre obmedzené výstupy, inklúziu pre povinné body, LLM-as-Judge pre nuansy
- Nastav
temperature=0.0na rozhodcovi, aby boli skóre reprodukovateľné - Spúšťaj evals pred každou zmenou promptu alebo modelu
- Platforma Evals od OpenAI sa uzatvára 30. novembra 2026: Promptfoo, odporúčaný OpenAI, preberá datasety, prompty, modely a kritériá v konfiguračnom súbore