Értékeld ki a promptjaidat: módszerek, értékelők és átállás a Promptfoo-ra
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.
Frissítés: 2026. november 2. — Evals Platform. Az OpenAI bejelentette az Evals platformjának megszűnését: a meglévő értékelések 2026. október 31. óta csak olvashatók, és a műszerfal az API-val együtt 2026. november 30-án bezár, beleértve az értékelőket (graders) is. Az OpenAI közzétett egy útmutatót a Promptfoo-ra való átálláshoz. Ebben a leckében az értékelési elvek érvényesek maradnak; csupán az eszköz változik.
Miért kell szisztematikusan értékelned
Nem fejleszthetsz olyat, amit nem mész. Ha megváltoztatsz egy promptot, egy modellt vagy egy paramétert, honnan tudod, hogy a minőség ténylegesen javult? A spontán módszer az, hogy kipróbálsz három-négy példát, megtalálod a jobb válaszokat, és bevezeted a rendszert. Ez rendszeresen kudarcot vall, mert a tesztelt példák pontosan azok, amelyek a múlt héten problémát okoztak: ott méred a javulást, ahol kerested, és elmulasztod azokat a regressziókat, amelyeket olyan esetekben vezettél be, amelyek már korábban is működtek.
Az értékelések (evals) ezt a megérzést objektív méréssé alakítják. 2026-ig az OpenAI erre egy integrált platformot, az Evals-t kínálta; ez 2026. október 31. óta csak olvasható, és november 30-án megszűnik. Az OpenAI most a Promptfoo-t ajánlja, egy nyílt forráskódú eszközt az értékeléshez és a „red teaming“ tevékenységekhez. A jó hír az, hogy mindkettő ugyanazokra az építőkövekre támaszkodik: tesztadatok, promptok, modellek és pontozási kritériumok. Amit itt Python kódban megtanulsz, az közvetlenül alkalmazható, és a lecke utolsó része bemutatja a Promptfoo-ra való átállást.
Három fogalom strukturálja az egész folyamatot. Az adatkészlet (dataset) tesztesetek gyűjteménye bemenetekkel és várt kimenetekkel: ez a referenciád, az egységteszt-csomagok megfelelője. Az értékelő (grader) egy értékelési kritérium – pontos egyezés, LLM mint bíró, pontszám –, amely eldönti, hogy egy adott válasz jó-e. A futtatás (run) egy értékelés végrehajtása egy adatkészleten egy konkrét modellel és prompttal; ez az egység, amelyet az egyik verzióról a másikra összehasonlítasz.
Készíts olyan adatkészletet, amely tükrözi a valóságot
Egy teszteset egy bemenetből, egy várt kimenetből és metaadatokból áll. Ez utóbbiak nem díszítőelemek: ezek teszik lehetővé, hogy utólag rájöjj: egy összesített 87%-os pontszám egy összeomlást takar a „kód“ kategóriában, amelyet a földrajzi témákban elért kiváló eredmények kompenzálnak. Kategória vagy nehézségi szint nélkül csak egy összesített számod van, egy összesített szám pedig sosem árulja el, hol kell beavatkoznod.
import json
# Egy adatkészlet tesztesetek listája
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"},
},
]
# Mentés JSONL formátumban
with open("eval_dataset.jsonl", "w") as f:
for case in dataset:
f.write(json.dumps(case, ensure_ascii=False) + "\n")
Az irodában kitalált adatkészlet a képzeletedet értékeli, nem az alkalmazásodat. A felhasználóid másképp fogalmazzák meg a kéréseiket, mint te: elírások, félig feltett kérdések, implicit kontextus. A tesztesetek legjobb forrása ezért a saját éles adataid (production data), feltéve, hogy egy ember validálja a referencia válaszokat – ellenkező esetben a jelenlegi hibákat fagyasztod be normaként.
import openai
import random
client = openai.OpenAI()
def create_dataset_from_logs(
production_logs: list[dict],
sample_size: int = 100,
) -> list[dict]:
"""Értékelési adatkészlet létrehozása éles naplókból."""
# Mintavétel
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"], # Ember által validált válasz
"metadata": {
"source": "production",
"date": log["date"],
"original_model": log["model"],
},
})
return dataset
Válaszd ki a megfelelő értékelőt
A pontos egyezés (exact match) értékelő a legszigorúbb és a leggyorsabb. Csak olyan feladatokhoz alkalmas, ahol a kimenet kötött: három kategóriás osztályozás, számlaszám kinyerése, igen/nem válasz. Szabad szövegen használva nullát adna egy tökéletes válaszra is, ha az csak másképp van megfogalmazva, mint a referencia.
def exact_grader(response: str, expected: str) -> dict:
"""Kiértékeli, hogy a válasz pontosan egyezik-e."""
score = 1.0 if response.strip().lower() == expected.strip().lower() else 0.0
return {"score": score, "type": "exact"}
A tartalmazás alapú (inclusion) értékelő lazítja a feltételt: ellenőrzi a várt kulcsszavak jelenlétét, és részleges pontszámot ad vissza. Ez a megfelelő eszköz olyan válaszokhoz, amelyeknek kötelező pontokat kell lefedniük anélkül, hogy a megfogalmazás számítana – például egy ügyfélszolgálati válasznak említenie kell az elállási időt és a visszaküldési címet. Gyengesége közismert: egy szöveg, amely a helyes szavakat abszurd sorrendben tartalmazza, tökéletes pontszámot kapna.
def inclusion_grader(response: str, keywords: list[str]) -> dict:
"""Ellenőrzi, hogy a válasz tartalmazza-e a várt kulcsszavakat."""
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",
}
Aztán ott van a leghatékonyabb: egy másik LLM értékeli a válasz minőségét. Az LLM-as-Judge (LLM mint bíró) értékelő azt becsüli meg, amit egyetlen mechanikus szabály sem képes: az érthetőséget, a teljességet, a hangnem pontosságát. Két megvalósítási részlet teszi praktikussá. Először is: temperature=0.0: enélkül ugyanaz a bíró eltérő pontszámokat adna ugyanarra a válaszra egyik futtatásról a másikra, és a benchmarkod elveszítené minden összehasonlító értékét. Másodszor: a json.JSONDecodeError kezelése: egy bíró, amely kommentár helyett JSON-t kellene visszaadnia, ne okozza az egész kampány összeomlását.
def llm_judge_grader(
question: str,
response: str,
expected: str,
criteria: str = "accuracy, completeness, clarity",
) -> dict:
"""LLM-et használ a válaszminőség értékelésére."""
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"}, # a temperature megköveteli az effort none beállítást
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}
Állítsd össze a teljes értékelést
Az orchestráció nem jelent koncepcionális nehézséget: végigmész az adatkészleten, meghívod a modellt a tesztelendő rendszerprompttal, alkalmazod az értékelőt, és aggregálsz. Az érdekesség az, hogy a pontozó függvény paraméterként érkezik, ami lehetővé teszi, hogy ugyanazt az adatkészletet különböző kritériumokkal játszd le a kampány függvényében – tartalmazás alapú gyors ellenőrzés fejlesztés közben, LLM bíró az élesítés előtti validáláshoz.
async def run_eval(
dataset: list[dict],
model: str,
system_prompt: str,
grader_fn,
) -> dict:
"""Teljes értékelés futtatása egy adatkészleten."""
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,
})
# Összesített metrikák kiszámítása
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,
}
A jelentés megtartja a min_score értéket és az egyes esetek részleteit, és ez szándékos. Az átlag megmondja, haladsz-e előre; a legrosszabb pontszámú esetek elárulják, miért. Szoktasd rá magad, hogy minden futtatás előtt elolvasd az öt legrosszabb választ, mielőtt kommentálnád az átlagot: itt, és ritkán máshol, találod meg a következő javítanivalót.
Iparosítás Promptfoo-val
Az evals kézi megírása Pythonban tanulságos; az időbeli karbantartásuk kényelmesebb egy dedikált eszközzel. Az OpenAI átállási útmutatója leírja a Promptfoo logikáját: az értékelés egy konfigurációs fájlban, a promptfooconfig.yaml-ban él, amely egyesíti a promptokat, a modell(ek)et, a teszteseteket és a kritériumokat – itt ezeket állításoknak (assertions) hívják. Parancssorból futtatható, helyben vagy a folyamatos integrációdban (CI), és az alkalmazáskód mellett él.
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 # konfigurációs hiba esetén
Ebben a leckében az értékelők állításokként jelennek meg újra: pontos egyezés, kulcsszó-tartalmazás és modell-ítélet. Az OpenAI figyelmeztet az utóbbi pontnál: egy újra létrehozott értékelőt, különösen egy LLM bírót, újra validálni kell, mielőtt regresszióról döntene, mert a pontszámok nem feltétlenül lesznek azonosak az egyik eszközről a másikra.
Főbb megállapítások
- Az evals a megérzést a minőség objektív mérésévé alakítják
- Hozd létre az adatkészleteidet valós éles esetekből, emberi validálással
- Válaszd ki az értékelőt a feladat alapján: pontos a kötött kimenetekhez, tartalmazás alapú a kötelező pontokhoz, LLM-as-Judge az árnyalatokhoz
- Állítsd be a
temperature=0.0értéket a bírónál a pontszámok reprodukálhatósága érdekében - Futtass evals-t minden prompt- vagy modellváltoztatás előtt
- Az OpenAI Evals platformja 2026. november 30-án bezár: a Promptfoo, amelyet az OpenAI ajánl, veszi át az adatkészleteket, promptokat, modelleket és kritériumokat egy konfigurációs fájlban