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

Automatizált promptértékelés

16. lecke 16 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Automatizált promptértékelés
  2. Az értékelés típusai
  3. Teljes értékelési folyamat (Pipeline)
  4. Tesztkészlet: Formátum
  5. CI/CD integráció
  6. Értékelési irányítópult
  7. Állítsd fel a biztonsági korlátaidat
  8. Főbb megállapítások
  9. Teszteld a tudásod

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.

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á.