Automatizované hodnotenie promptov
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.
Automatizované hodnotenie promptov
Automatizované hodnotenie je kľúčovým kameňom vyspelého pipeline pre inžinierstvo promptov. Umožňuje ti odhaliť regresie, porovnávať modely a overovať zmeny pred nasadením. Bez neho je každá zmena promptu slepým hazardom.
Typy hodnotenia
Tri rodiny evaluátorov si rozdeľujú prácu podľa povahy očakávaného výstupu a takmer vždy ich budeš kombinovať niekoľko naraz.
Hodnotenie presnej zhody (Exact Match)
Pre úlohy s jedinou očakávanou odpoveďou stačí priame porovnanie. Funkcia eval_exact_match normalizuje veľkosť písmen a medzery pred porovnaním: bez tohto opatrenia by sa „Bug“ a „bug“ počítali ako chyba, čo by ťa nútilo opravovať problém, ktorý neexistuje.
Funkcia eval_set_match rieši prípady, keď je odpoveďou množina – entity nájdené v dokumente, kategórie priradené článku. Odvodzuje presnosť (precision) a úplnosť (recall), dve čísla, ktoré rozprávajú rôzne príbehy: vysoká presnosť s nízkou úplnosťou signalizuje príliš opatrný model, ktorý extrahuje len to, čím si je istý; opačný prípad prezrádza model, ktorý halucinuje, aby zaplnil medzery. F1 skóre ich pohodlne sumarizuje, ale nenahrádza ich pri diagnostike.
def eval_exact_match(prediction: str, reference: str) -> bool:
"""Presná zhoda po normalizácii."""
return prediction.strip().lower() == reference.strip().lower()
def eval_set_match(prediction: set, reference: set) -> dict:
"""Zhoda množín (entity, kategórie)."""
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é hodnotenie (Embedding)
Pre textové odpovede, kde sa môže líšiť formulácia, sa presná zhoda stáva absurdnou: „Vaša objednávka bude doručená zajtra“ a „Doručenie je naplánované na zajtra“ hovoria to isté, no získali by nulové skóre. Kosínusová podobnosť medzi embeddingmi meria sémantickú blízkosť namiesto zhody znakov a vracia priebežné skóre.
Nastavíš si prah, nad ktorým sa odpoveď považuje za prijateľnú. Nakalibruj ho na niekoľkých desiatkach párov, ktoré si manuálne klasifikoval ako „ekvivalentné“ alebo „rôzne“, a potom vyber hodnotu, ktorá najlepšie oddeľuje tieto dve skupiny: prah zvolený podľa pocitu prináša výsledky rovnako arbitrárne ako žiadne meranie vôbec, navyše s ilúziou rigoróznosti.
from openai import OpenAI
import numpy as np
client = OpenAI()
def eval_semantic_similarity(prediction: str,
reference: str) -> float:
"""Kosínusová podobnosť medzi embeddingmi."""
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
Hodnotenie modelom LLM (LLM-as-Judge)
Model hodnotí kvalitu odpovede. Toto je jediný životaschopný prístup, keď neexistuje referenčná odpoveď: nikto ti ručne nenapíše „správnu“ odpoveď podpory pre dvesto ticketov.
To, čo robí sudcu použiteľným, závisí od niekoľkých vecí. Po prvé, použitý model: ako sudcu vyberieš schopnejší model, tu gpt-5.6-sol, pretože sudca na rovnakej úrovni ako hodnotený subjekt má tendenciu validovať jeho vlastné chyby. Po druhé, vyžadovanie odôvodnenia: motivácia každého skóre stabilizuje úsudok a umožňuje ti odhaliť evaluátora používajúceho nesprávne kritérium – odôvodnenie diskutujúce o dĺžke, keď bolo kritériom zrozumiteľnosť, je varovným signálom. Nakoniec, temperature nastavená na 0.1 zabezpečuje stabilitu skóre medzi jednotlivými behmi.
def eval_llm_judge(question: str, prediction: str,
criteria: list[str]) -> dict:
"""Hodnotenie modelom sudcu."""
criteria_text = "\n".join(
f"- {c}: skóre od 1 do 5" for c in criteria
)
response = client.responses.create(
model="gpt-5.6-sol", # Schopnejší model ako sudca
reasoning={"effort": "none"}, # temperature vyžaduje effort none
instructions="Si expertný, nestranný evaluátor.",
input=f"""Vyhodnoť túto odpoveď podľa nasledujúcich kritérií:
Otázka: {question}
Hodnotená odpoveď: {prediction}
Kritériá:
{criteria_text}
Pre každé kritérium udeľ skóre od 1 do 5 s odôvodnení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)
Komplexný pipeline hodnotenia
EvalPipeline spája tieto stavebné bloky: načíta sadu testov, spustí prompt na každom prípade, aplikuje všetkých poskytnutých evaluátorov a agreguje skóre. Evaluátory sa odovzdávajú ako zoznam funkcií, všetky volané s rovnakou signatúrou; pridanie metriky si teda nevyžaduje úpravu pipeline a môžeš spustiť presnú zhodu, sémantickú podobnosť aj sudcu na rovnakom vykonaní bez toho, aby si trikrát platil za generovanie.
Metóda summary tiež akumuluje spotrebované tokeny. Táto zdanlivo vedľajšia línia ťa chráni pred bežnou pascou: verzia promptu, ktorá získa dva body navyše, ale strojnásobí účet, nemusí byť nutne tou správnou voľbou a je lepšie zistiť to v čase kompromisov, než keď príde mesačná faktúra.
import json
from dataclasses import dataclass
from pathlib import Path
@dataclass
class TestCase:
"""Testovací prípad pre hodnotenie."""
input_text: str
expected_output: str = None
metadata: dict = None
class EvalPipeline:
"""Pipeline automatizovaného hodnotenia."""
def __init__(self, test_suite_path: str):
"""Načíta sadu testov z JSON súboru."""
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šetky testy a vyhodnotí výsledky."""
self.results = []
for tc in self.test_cases:
# Generovanie odpovede
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
# Vyhodnotenie každým evaluátorom
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:
"""Sumarizuje výsledky hodnotenia."""
if not self.results:
return {"error": "Žiadne výsledky"}
# Agregácia skóre podľa evaluátora
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 testov: Formát
Formát sady testov zámerne zostáva minimálny: vstup, očakávaný výstup a voľne štruktúrované metadáta. Tieto metadáta sú užitočnejšie, než sa zdá – označením každého prípadu kategóriou rozložíš skóre a zistíš, že tvoj klasifikátor zlyháva nie náhodne, ale pri konkrétnej rodine požiadaviek, čo globálny priemer 88 % neodhalí. Tri nižšie uvedené príklady tiež ukazujú, čo by mala dobrá sada obsahovať: jasné prípady, ako je pád aplikácie pri štarte, ale aj prípady hraničiace s inou kategóriou – otázka o chýbajúcej funkcii vyzerá veľmi podobne ako hlásenie chyby a práve na tejto hranici sa rozhoduje o kvalite klasifikátora.
[
{
"input_text": "Môj balík ešte nedorazil",
"expected_output": "sťažnosť",
"metadata": {"category": "doručenie"}
},
{
"input_text": "Ako zapnem tmavý režim?",
"expected_output": "otázka",
"metadata": {"category": "funkcia"}
},
{
"input_text": "Aplikácia padá pri štarte na iOS 18",
"expected_output": "chyba",
"metadata": {"category": "technické"}
}
]
Integrácia CI/CD
Spúšťaj hodnotenie pri každej zmene promptu. Funkcia ci_eval_check mení meranie na ochrannú bariéru: spustí pipeline, porovná priemerné skóre s prahom a vráti boolean hodnotu, ktorú tvoj integračný reťazec interpretuje ako úspech alebo zlyhanie zostavenia. Zmena, ktorá zníži presnosť pod 85 %, sa už nedostane do produkcie, rovnako ako nefunkčný unit test zablokuje merge.
Prah nastav na základe skóre, ktorého už dosahuje aktuálna verzia, nie podľa ideálu. Ak ho nastavíš príliš vysoko, odsúdiš tím k obchádzaniu overovania dočasnými vypnutiami, ktoré sa stanú trvalými; ak príliš nízko, nekontroluješ nič, hoci zobrazuješ zelený odznak. Nakoniec maj na pamäti, že sada musí zostať reprezentatívna pre reálnu prevádzku: prah splnený na dvadsiatich prípadoch napísaných pred dvoma rokmi nič nepreukazuje o dnešných požiadavkách.
def ci_eval_check(prompt_config: dict,
test_suite: str,
min_score: float = 0.85) -> bool:
"""Brána CI/CD: kontroluje, či prompt spĺňa minimálne 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"Priemerné skóre: {avg_score:.2%}")
print(f"Minimálny prah: {min_score:.2%}")
if avg_score < min_score:
print("ZLYHANIE: skóre pod prahom")
return False
print("ÚSPECH: prompt validovaný")
return True
Dashboard hodnotenia
Sleduj vývoj skóre v čase. Jedno skóre nič nehovorí; séria rozpráva príbeh tvojho promptu a odpovedá na otázku, ktorá vždy zaznie na poradách: napredujeme? Nižšie uvedená funkcia vytvára Markdown tabuľku, ktorá vedľa seba kladie pre každú verziu priemerné skóre, spotrebované tokeny a odhadované náklady. Formát nie je náhodný: vloží sa priamo do pull requestu, čím je porovnanie čitateľné pre ľudí, ktorí nikdy neotvoria tvoj kód.
def comparison_report(results: dict[str, dict]) -> str:
"""Generuje porávaciu správu medzi verziami promptov."""
report = "# Porovnávacia správa o hodnotení\n\n"
report += "| Verzia | Priemerné skóre | Priemerné 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
Nastavenie tvojich ochranných bariér
Vytvor sadu dvadsiatich testovacích prípadov pre reálny prompt, pričom umiestni niekoľko hraničných prípadov namiesto dvadsiatich pohodlných príkladov: sada, ktorá na prvý pokus prejde na 100 %, ťa nič nenaučí. Implementuj tri typy evaluátorov a spusti ich spoločne na dvoch verziách tvojho promptu. Presná zhoda dáva čisté číslo, sémantická podobnosť zachytáva legitímne preformulovania a sudca osvetľuje prípady, kde prvé dve nesúhlasia – tieto nezhody sú najbohatšie na lekcie o tom, čo vlastne od modelu očakávaš.
Porovnaj, identifikuj víťaznú verziu a potom nastav CI skript, ktorý zablokuje nasadenie, ak skóre klesne. Systém budeš vedieť, že funguje, v deň, keď odmietne zmenu, ktorú si považoval za samozrejmú.
Kľúčové poznatky
- Automatizované hodnotenie je nevyhnutné pre iterácie s istotou
- Podľa potreby kombinuj hodnotenie presnej zhody, sémantické a LLM-as-judge
- Udržiavaj sadu testov, ktorá sa vyvíja spolu s tvojou aplikáciou
- Integruj hodnotenie do svojho CI/CD s minimálnym prahom
- Použi schopnejší model ako sudcu na hodnotenie lacnejšieho modelu
- Dokumentuj skóre každej verzie pre sledovanie vývoja
Otestuj si svoje vedomosti
Pokročilé techniky a industrializácia: záverečná kontrola.
1. Čo obsahuje efektívny systémový prompt?
Odpoveď: Rola, rozsah, pravidlá správania, formát výstupu a riešenie hraničných prípadov – napísané ako špecifikácia, testované ako kód.
2. Kedy by si mal použiť self-consistency?
Odpoveď: Pri problémoch vyžadujúcich logické uvažovanie s overiteľnými odpoveďami: generuj viacero nezávislých úvah a ponechaj odpoveď väčšiny – variabilita sa stáva spojencom.
3. Čo garantuje JSON režim s vynútením schémy?
Odpoveď: Výstup striktne zodpovedajúci schéme (typy, povinné polia, enumy) – validovaný na strane API a opätovne validovaný v kóde (JSON Schema, Zod) pre reťazec bez prekvapení.
4. Čo je grounding (uzemnenie)?
Odpoveď: Ukotvenie odpovedí v poskytnutých faktoch (dokumenty, získané dáta) namiesto pamäte modelu – s požiadavkou citovať alebo sa zdržať externých zdrojov.
5. Aký je účel katalógu verzionovaných promptov?
Odpoveď: Zaobchádzať s promptmi ako s artefaktmi: verzie, A/B testy, automatizované hodnotenia pri každej zmene – vieš, čo beží v produkcii a prečo.
Záverečná slučka kurzu – verzionovanie, testovanie, automatické hodnotenie – transformuje remeselné inžinierstvo promptov na tímovú prax.