Automatizált promptértékelés
Ezen az oldalon
Lecke frissítve: 2026. november 3. az OpenAI dokumentációja alapján: a
temperatureés atop_pparaméterek csaknonegondolkodási erőfeszítés (reasoning effort) mellett fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) gondolkodnak. Az ezeket a paramétereket beállító hívásoknak ezért meg kell adniuk areasoning={"effort": "none"}(Responses API) vagyreasoning_effort="none"(Chat Completions) beállítást. Források: GPT-6 használata · GPT-5.6 Terra.
Automatizált promptértékelés
Az automatizált értékelés egy érett promptmérnöki folyamat sarokköve. Lehetővé teszi a regressziók észlelését, a modellek összehasonlítását és a változtatások validálását telepítés előtt. Enélkül minden promptmódosítás vak szerencsejáték.
Az értékelés típusai
A kiértékelők három családja a várt kimenet jellege alapján osztja meg a munkát, és szinte mindig többet kombinálsz majd közülük.
Pontos egyezés értékelése (Exact Match)
Olyan feladatoknál, ahol egyetlen várt válasz létezik, a közvetlen összehasonlítás elegendő. Az eval_exact_match normalizálja a nagy- és kisbetűket, valamint a szóközöket az összehasonlítás előtt: e óvintézkedés nélkül a „Bug“ és a „bug“ hibának számítana, ami arra kényszerítene, hogy egy nem létező problémát javíts meg.
Az eval_set_match azokat az eseteket kezeli, ahol a válasz egy halmaz – például egy dokumentumban talált entitások vagy egy cikkhez rendelt kategóriák. Kiszámítja a pontosságot (precision) és a visszahívást (recall), két mutatót, amelyek különböző történeteket mesélnek el: a magas pontosság alacsony visszahívás mellett egy túlzottan óvatos modellt jelez, amely csak azt vonja ki, amiben biztos; az ellenkezője olyan modellt árul el, amely hallucinál, hogy kitöltse a hézagokat. Az F1-score kényelmesen összegzi ezeket, de diagnózisra nem helyettesíti őket.
def eval_exact_match(prediction: str, reference: str) -> bool:
"""Pontos egyezés normalizálás után."""
return prediction.strip().lower() == reference.strip().lower()
def eval_set_match(prediction: set, reference: set) -> dict:
"""Halmaz egyezés (entitások, kategóriák)."""
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}
Szemantikai értékelés (Beágyazás/Embedding)
Olyan szöveges válaszoknál, ahol a megfogalmazás változhat, a pontos egyezés abszurdá válik: a „A rendelését holnap kézbesítjük“ és a „A szállítást holnapra ütemeztük“ ugyanazt jelenti, mégis nullára értékelné őket. A beágyazások (embeddings) közötti koszinusz-hasonlóság a szemantikai közelséget méri a karakteregyezés helyett, folyamatos pontszámot visszaadva.
Te állítod be azt a küszöbértéket, amely felett a válasz elfogadhatónak minősül. Kalibráld néhány tucat, általad manuálisan „ekvivalensnek“ vagy „különbözőnek“ osztályozott páron, majd válaszd ki azt az értéket, amely a legjobban elkülöníti a két csoportot: a hasraütésszerűen választott küszöb ugyanolyan önkényes eredményt produkál, mint a mérés hiánya, a szigorúság illúziójával fűszerezve.
from openai import OpenAI
import numpy as np
client = OpenAI()
def eval_semantic_similarity(prediction: str,
reference: str) -> float:
"""Koszinusz-hasonlóság a beágyazások között."""
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
LLM értékelés (LLM-as-Judge)
A modell értékeli egy válasz minőségét. Ez az egyetlen életképes megközelítés, amikor nincs referenciaválasz: senki nem fog kézzel megírni kétszáz jegyre a „helyes“ ügyfélszolgálati választ.
Azt, hogy egy bíró használható legyen, néhány dolog határozza meg. Először is a használt modell: olyan modellt választasz bírónak, amely képesabb, mint az értékelt, itt a gpt-5.6-sol-t, mert egy az értékelttel azonos szintű bíró hajlamos validálni a saját hibáit. Másodszor, az indoklás megkövetelése: minden pontszám indoklása stabilizálja az ítéletet, és lehetővé teszi, hogy észleld, ha az értékelő rossz kritériumot használ – egy olyan indoklás, amely a hosszt tárgyalja, amikor a kritérium az érthetőség volt, intő jel. Végül a temperature 0,1-re állítása biztosítja a pontszámok stabilitását a futtatások között.
def eval_llm_judge(question: str, prediction: str,
criteria: list[str]) -> dict:
"""Értékelés egy bíró modell által."""
criteria_text = "\n".join(
f"- {c}: pontszám 1-től 5-ig" for c in criteria
)
response = client.responses.create(
model="gpt-5.6-sol", # Képesebb modell bíróként
reasoning={"effort": "none"}, # a temperature megköveteli a none erőfeszítést
instructions="Szakértő, pártatlan értékelő vagy.",
input=f"""Értékeld ezt a választ az alábbi kritériumok alapján:
Feltett kérdés: {question}
Értékelendő válasz: {prediction}
Kritériumok:
{criteria_text}
Minden kritériumhoz adj 1-től 5-ig terjedő pontszámot indoklással.""",
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)
Teljes értékelési folyamat (Pipeline)
Az EvalPipeline összeszereli ezeket az építőköveket: betölt egy tesztkészletet, lefuttatja a promptot minden eseten, alkalmazza az összes megadott értékelőt, és aggregálja a pontszámokat. Az értékelőket függvények listájaként adjuk át, mindegyiket ugyanazzal a szignatúrával hívva meg; egy metrika hozzáadása tehát nem igényel módosítást a folyamaton, és futtathatsz pontos egyezést, szemantikai hasonlóságot és egy bírót ugyanazon a végrehajtáson anélkül, hogy háromszor fizetnél a generálásért.
A summary metódus az elfogyasztott tokeneket is összegyűjti. Ez a látszólag másodlagos sor megvéd egy gyakori csapdától: egy promptverzió, amely két pontot javul, miközben megháromszorozza a számlát, nem feltétlenül a helyes választás, és jobb ezt a kompromisszumok meghozatalakor megtudni, mint amikor megérkezik a havi számla.
import json
from dataclasses import dataclass
from pathlib import Path
@dataclass
class TestCase:
"""Egy teszteset az értékeléshez."""
input_text: str
expected_output: str = None
metadata: dict = None
class EvalPipeline:
"""Automatizált értékelési folyamat."""
def __init__(self, test_suite_path: str):
"""Betölti a tesztkészletet egy JSON fájlból."""
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:
"""Lefuttatja az összes tesztet és kiértékeli az eredményeket."""
self.results = []
for tc in self.test_cases:
# Válasz generálása
response = client.responses.create(
model=prompt_config["model"],
reasoning={"effort": "none"}, # a temperature megköveteli a none erőfeszítést
instructions=prompt_config["system_prompt"],
input=tc.input_text,
temperature=prompt_config.get("temperature", 0.1)
)
prediction = response.output_text
# Értékelés minden értékelővel
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:
"""Összegzi az értékelési eredményeket."""
if not self.results:
return {"error": "Nincsenek eredmények"}
# Pontszámok aggregálása értékelőnként
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
Tesztkészlet: Formátum
A tesztkészlet formátuma szándékosan minimális: egy bemenet, a várt kimenet és szabad formátumú metaadatok. Ez a metaadat hasznosabb, mint elsőre tűnik – ha minden esetet kategória szerint címkézel, lebonthatod a pontszámokat, és felfedezheted, hogy az osztályozód nem véletlenszerűen, hanem egy konkrét kéréscsaládon bukik meg, amit egy globális 88%-os átlag nem tár fel. Az alábbi három példa azt is bemutatja, mit kell tartalmaznia egy jó készletnek: egyértelmű eseteket, mint egy indulási összeomlás, de olyan eseteket is, amelyek határesetek – egy hiányzó funkcióra vonatkozó kérdés nagyon hasonlít egy hibajelentésre, és ezen a határon dől el egy osztályozó minősége.
[
{
"input_text": "Még nem érkezett meg a csomagom",
"expected_output": "panasz",
"metadata": {"category": "szállítás"}
},
{
"input_text": "Hogyan kapcsolhatom be a sötét módot?",
"expected_output": "kérdés",
"metadata": {"category": "funkció"}
},
{
"input_text": "Az alkalmazás induláskor összeomlik iOS 18-on",
"expected_output": "hiba",
"metadata": {"category": "technikai"}
}
]
CI/CD integráció
Futtasd az értékelést minden promptváltoztatásnál. A ci_eval_check függvény méréssé alakítja a biztonsági korlátot: lefuttatja a folyamatot, összehasonlítja az átlagos pontszámot egy küszöbértékkel, és egy boolean értéket ad vissza, amelyet az integrációs láncod build sikerességként vagy kudarcként értelmez. Egy olyan változás, amely 85% alá csökkenti a pontosságot, többé nem kerül éles környezetbe, akárcsak egy törött unit teszt, amely blokkolja az egyesítést (merge).
Állítsd be a küszöbértéket a jelenlegi verzió által már elért pontszám alapján, nem egy ideális érték szerint. Ha túl magasra állítod, arra ítéled a csapatot, hogy ideiglenes letiltásokkal kerüljék meg az ellenőrzést, amelyek állandósulnak; ha túl alacsonyra, akkor semmit nem ellenőrzöl, miközben egy zöld jelvényt jelenítesz meg. Végül ne feledd: a készletnek reprezentatívnak kell maradnia a valós forgalomra: egy két éve írt húsz eseten teljesített küszöbérték semmit nem bizonyít a mai kérésekről.
def ci_eval_check(prompt_config: dict,
test_suite: str,
min_score: float = 0.85) -> bool:
"""CI/CD kapu: ellenőrzi, hogy a prompt megfelel-e a minimális pontszámnak."""
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"Átlagos pontszám: {avg_score:.2%}")
print(f"Minimális küszöb: {min_score:.2%}")
if avg_score < min_score:
print("HIBA: a pontszám a küszöb alatt van")
return False
print("SIKER: a prompt validálva")
return True
Értékelési irányítópult
Kövesd nyomon a pontszámok időbeli alakulását. Egyetlen pontszám semmit sem mond; a sorozat meséli el a promptod történetét, és választ ad arra a kérdésre, amely mindig felmerül a megbeszéléseken: haladunk előre? Az alábbi függvény egy Markdown táblázatot készít, amely egymás mellé helyezi minden verzióhoz az átlagos pontszámot, az elfogyasztott tokeneket és a becsült költséget. A formátum nem véletlen: közvetlenül beilleszthető egy pull requestbe, így az összehasonlítás olvashatóvá válik azok számára is, akik sosem nyitják meg a kódodat.
def comparison_report(results: dict[str, dict]) -> str:
"""Összehasonlító jelentést generál a promptverziók között."""
report = "# Összehasonlító Értékelési Jelentés\n\n"
report += "| Verzió | Átlagos pontszám | Átlagos tokenek | Költség |\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
Állítsd fel a biztonsági korlátaidat
Készíts egy húsz tesztesetből álló készletet egy valós prompthoz, ahol néhány határesetet helyezel el a húsz kényelmes példa helyett: egy olyan készlet, amely első próbálkozásra 100%-osan teljesít, semmit sem tanít neked. Implementáld a három értékelőtípust, és futtasd őket együtt a promptod két verzióján. A pontos egyezés tiszta számot ad, a szemantikai hasonlóság elkapja a jogos átfogalmazásokat, a bíró pedig megvilágítja azokat az eseteket, ahol az első kettő nem ért egyet – ezek az eltérések a leggazdagabbak tanulságokban arról, mit is vársz valójában a modelltől.
Hasonlítsd össze, azonosítsd a győztes verziót, majd állítsd be azt a CI szkriptet, amely blokkolja a telepítést, ha a pontszám csökken. Akkor tudni fogod, hogy a rendszer működik, amikor elutasít egy olyan változtatást, amelyet egyértelműnek hittél.
Főbb megállapítások
- Az automatizált értékelés elengedhetetlen a magabiztos iterációhoz
- Kombináld szükség szerint a pontos, a szemantikai és az LLM-bíró értékelést
- Tarts fenn egy tesztkészletet, amely az alkalmazásoddal együtt fejlődik
- Integráld az értékelést a CI/CD folyamatodba egy minimális küszöbértékkel
- Használj képesebb modellt bíróként egy olcsóbb modell értékeléséhez
- Dokumentáld minden verzió pontszámait az evolúció nyomon követéséhez
Teszteld a tudásod
Haladó technikák és industrializáció: a végső ellenőrzés.
1. Mit tartalmaz egy hatékony rendszer-prompt?
Válasz: Szerep, hatáskör, viselkedési szabályok, kimeneti formátum és a határesetek kezelése – specifikációként megírva, kódként tesztelve.
Mikor kell alkalmazni az ön konzisztenciát (self-consistency)?
Válasz: Olyan következtetési problémáknál, amelyeknél ellenőrizhető a válasz: generálj több független következtetést, és tartsd meg a többségi választ – a variancia szövetségessé válik.
Mit garantál a JSON mód a sémakényszerítéssel?
Válasz: A sémának szigorúan megfelelő kimenetet (típusok, kötelező mezők, enumok) – az API oldalán validálva és a kódban újraellenőrizve (JSON Schema, Zod) a meglepetésektől mentes láncolat érdekében.
Mi a grounding (horgonyzás)?
Válasz: A válaszok horgonyzása a megadott tényekhez (dokumentumok, lekért adatok) a modell memóriája helyett – azzal a követelménnyel, hogy hivatkozni kell, vagy tartózkodni kell a külső forrásoktól.
Mi a célja a verzionált promptkatalógusnak?
Válasz: Hogy artifactként kezeljük a promptokat: verziók, A/B tesztek, automatizált értékelések minden változtatásnál – tudod, mi fut éles környezetben, és miért.
A tanfolyam utolsó köre – verzionálás, tesztelés, automatikus értékelés – átalakítja a kézműves promptmérnökséget csapatgyakorlattá.