Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Értékeld ki a promptjaidat: módszerek, értékelők és átállás a Promptfoo-ra

15. lecke 20 közül Frissítve 2026. november 3. Haladó
Ezen az oldalon
  1. Miért kell szisztematikusan értékelned
  2. Készíts olyan adatkészletet, amely tükrözi a valóságot
  3. Válaszd ki a megfelelő értékelőt
  4. Állítsd össze a teljes értékelést
  5. Iparosítás Promptfoo-val
  6. Főbb megállapítások

Lecke frissítve: 2026. november 3. az OpenAI dokumentációja alapján: a temperature és a top_p paraméterek csak none gondolkodá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 a reasoning={"effort": "none"} (Responses API) vagy reasoning_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