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

Metrikák és referenciapontok

17. lecke 20 közül Frissítve 2026. november 3. Haladó
Ezen az oldalon
  1. Minőség mérése metrikákkal
  2. Jelentés összehasonlítása a szavak helyett
  3. Annak ellenőrzése, hogy a modell nem hallucinál-e
  4. Reprodukálható referenciapont (benchmark) összeállítása
  5. 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 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"} (API Responses) vagy reasoning_effort="none" (Chat Completions) értéket. Források: GPT-6 használata · GPT-5.6 Terra.

Minőség mérése metrikákkal

Az LLM mint bíró (LLM-as-Judge) pontszámokon túl léteznek kvantitatív metrikák is az LLM-kimenetek különböző aspektusainak értékelésére. Az értékük nem abban rejlik, hogy pontosabbak lennének – egy jól felépített LLM-bíró olyan dolgokat is lát, amit egyetlen képlet sem –, hanem abban, hogy stabilak és olcsók. A koszinusz-hasonlóság minden futtatáskor pontosan ugyanazt az értéket adja vissza, szinte semmibe sem kerül, így minden commitnál lefuttatható ezrekenyi eseten. Az LLM-bírót ezután csak azokhoz a dimenziókhoz tartogatod, amelyekhez valóban szükség van rá.

Áttekintjük a legfontosabb metrikákat, mielőtt reprodukálható referenciapontokká (benchmarkokká) állítanánk össze őket.

Jelentés összehasonlítása a szavak helyett

A szövegek karakterenkénti összehasonlítása használhatatlanná válik, amint a megfogalmazás szabad. A szemantikai hasonlóság megkerüli ezt a problémát: minden szöveget egy beágyazási modell (embedding model) vektorrá alakít, és mi a két vektor közötti szöget mérjük. Két mondat, amely különböző szavakkal ugyanazt mondja, ugyanabba az irányba mutat.

import openai
import numpy as np

client = openai.OpenAI()

def cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
    """Kiszámítja két vektor koszinusz-hasonlóságát."""
    a = np.array(vec_a)
    b = np.array(vec_b)
    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))

def semantic_similarity(text_a: str, text_b: str) -> float:
    """Méri két szöveg szemantikai hasonlóságát."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=[text_a, text_b],
    )

    vec_a = response.data[0].embedding
    vec_b = response.data[1].embedding

    return cosine_similarity(vec_a, vec_b)

# Példa
score = semantic_similarity(
    "The cat is on the rug.",
    "A feline is resting on the carpet.",
)
print(f"Similarity: {score:.3f}")  # ~0.85+

A példa tanulságos: két mondat, amelynek nincs közös szava, 0,85 feletti pontszámot kap. Ez a módszer erőssége, de egyben a csapdája is. A szemantikai hasonlóság figyelmen kívül hagyja a tagadást és a fokozati árnyalatokat – „a fizetést elfogadták“ és „a fizetést elutasították“ vektorszinten nagyon hasonlónak tűnnek. Soha ne használd ezért egyedül olyan válaszok validálására, ahol a ténybeli pontosság számít.

Amikor a kérdés az, hogy „a válasz tényleg a feltett kérdésre válaszol-e“, nincs olyan képlet, amely helyettesítené az ítélőképességet. Az alábbi relevancia-pontszám ezt az ítélőképességet három különálló kérdésre bontja: Közvetlen a válasz? Megmarad a tárgynál? Teljes? Ez a lebontás jobb, mint egy globális pontszám, mert megmutatja, milyen irányba kell korrigálnod a promptot – egy bőbeszédű modell és egy hiányos modell ellentétes korrekciókat igényel.

def relevance_score(
    question: str,
    answer: str,
    context: str | None = None,
) -> dict:
    """Értékeli, hogy a válasz releváns-e a kérdésre."""
    prompt = (
        "Evaluate the relevance of this answer.\n\n"
        f"Question: {question}\n"
    )
    if context:
        prompt += f"Context provided: {context[:1000]}\n"
    prompt += (
        f"Answer: {answer}\n\n"
        "Criteria:\n"
        "1. Does the answer directly address the question? (0-5)\n"
        "2. Does the answer contain unrequested information? (0-5, 5=none)\n"
        "3. Is the answer complete? (0-5)\n\n"
        "Respond in JSON with keys: direct, focus, completeness."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=prompt,
        temperature=0.0,
    )

    import json
    try:
        scores = json.loads(response.output_text)
        average = sum(scores.values()) / (len(scores) * 5)
        return {"score": average, "details": scores}
    except (json.JSONDecodeError, TypeError):
        return {"score": 0, "error": "Parsing failed"}

Figyeld meg a második kritérium fordított megfogalmazását, ahol az 5 azt jelenti: „nincs nem kért információ“. Ez lehetővé teszi a három pontszám ugyanabba az irányba történő összeadását, de olvasás szempontjából ellentmondásos: amikor saját kritériumokat adsz hozzá, tartsd be ezt a konvenciót, különben olyan átlagokat kapsz, amelyek jutalmazzák azt a hibát, amelyet büntetni szerettél volna.

Annak ellenőrzése, hogy a modell nem hallucinál-e

Dokumentumalapú kérdés-felelet alkalmazásokban a döntő metrika nem az írás minősége, hanem a forráshoz való hűség. Az ellenőrzés elve egyszerű: a bíró elé tárjuk az eredeti kontextust és a generált választ, majd megkérjük, hogy minden állítást osztályozzon aszerint, hogy a kontextus alátámasztja-e, hiányzik-e a kontextusból, vagy ellentmond-e neki. Ezen utóbbi két kategória közötti különbség számít, mert egy csupán hiányzó állítás lehet általános tudás, míg a forrással ellentétes állítás mindig hiba.

def detect_hallucinations(
    context: str,
    answer: str,
) -> dict:
    """Azonosítja a kontextus által nem alátámasztott állításokat."""
    prompt = (
        "Analyze this answer and identify any statement "
        "that is NOT supported by the provided context.\n\n"
        f"Context: {context[:3000]}\n\n"
        f"Answer: {answer}\n\n"
        "For each statement in the answer, indicate:\n"
        "- supported: the statement is in the context\n"
        "- unsupported: the statement is not in the context\n"
        "- invented: the statement contradicts the context\n\n"
        "Respond in JSON with the key statements (list) and "
        "fidelity_score (0 to 1)."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=prompt,
        temperature=0.0,
    )

    import json
    try:
        return json.loads(response.output_text)
    except json.JSONDecodeError:
        return {"fidelity_score": 0, "error": "Parsing failed"}

A kontextus 3000 karakterre való csonkítása egy olyan korlát, amellyel tisztában kell lenned: ha a forrás ennél nagyobb, a tökéletesen pontos állításokat is nem alátámasztottnak fogja számolni a rendszer pusztán azért, mert az azokat igazoló szakaszt levágták. Hosszú dokumentumok esetén bontsd szét és szakaszonként értékeld őket, ahelyett, hogy szisztematikus téves riasztásokat (false positive) fogadnál el.

Reprodukálható referenciapont (benchmark) összeállítása

A benchmark nem csupán egy további metrika: ez egy olyan felállás, amely rögzít egy adathalmazt és egy protokollt, így két futtatás összehasonlíthatóvá válik. Az alábbi osztály méri a relevanciát, a hűséget (ha rendelkezésre áll kontextus), a késleltetést és a költséget, majd minden eredményt dátummal és a prompt verziójával címkézve tárol.

from dataclasses import dataclass, field
import time

@dataclass
class BenchmarkResult:
    model: str
    prompt_version: str
    scores: dict
    avg_latency: float
    total_cost: float
    date: str = field(default_factory=lambda: time.strftime("%Y-%m-%d"))

class Benchmark:
    """Újrahasználható benchmark modellek és promptok összehasonlítására."""

    def __init__(self, name: str, dataset: list[dict]):
        self.name = name
        self.dataset = dataset
        self.results: list[BenchmarkResult] = []

    def run(
        self,
        model: str,
        system_prompt: str,
        prompt_version: str,
    ) -> BenchmarkResult:
        """Futtatja a benchmarkot egy adott modellel és prompttal."""
        relevance_scores = []
        hallucination_scores = []
        latencies = []
        cost = 0

        for case in self.dataset:
            start = time.perf_counter()
            response = client.responses.create(
                model=model,
                instructions=system_prompt,
                input=case["input"],
            )
            latency = time.perf_counter() - start
            latencies.append(latency)

            # Értékelés
            relevance = relevance_score(
                case["input"], response.output_text
            )
            relevance_scores.append(relevance["score"])

            if case.get("context"):
                halluc = detect_hallucinations(
                    case["context"], response.output_text
                )
                hallucination_scores.append(
                    halluc.get("fidelity_score", 0)
                )

        result = BenchmarkResult(
            model=model,
            prompt_version=prompt_version,
            scores={
                "relevance": sum(relevance_scores) / len(relevance_scores),
                "fidelity": (
                    sum(hallucination_scores) / len(hallucination_scores)
                    if hallucination_scores else None
                ),
            },
            avg_latency=sum(latencies) / len(latencies),
            total_cost=cost,
        )

        self.results.append(result)
        return result

    def compare(self) -> str:
        """Összehasonlítja az összes benchmark eredményt."""
        lines = [f"Benchmark: {self.name}\n"]
        for r in self.results:
            lines.append(
                f"  {r.model} (prompt {r.prompt_version}) | "
                f"Relevance: {r.scores['relevance']:.2f} | "
                f"Latency: {r.avg_latency:.2f}s"
            )
        return "\n".join(lines)

A compare kimenete szándékosan ugyanarra a sorra helyezi a relevanciát és a késleltetést, mert a döntés valójában így születik meg. Egy modell, amely két századpontot nyer relevanciában, miközben megduplázza a válaszidőt, nem jobb választás interaktív alkalmazáshoz; éjszakai feldolgozáshoz viszont lehet az. A táblázat nem dönt helyetted; csak az arcodba tolja a kompromisszumot.

Végezetül, a total_cost ebben a megvalósításban nullán marad. Töltsd fel az API által visszaadott használati (usage) mezőkből: egy olyan modell-összehasonlítás, amely kihagyja a költséget, figyelmen kívül hagyja azt a szempontot, amely eldönti a vitát a pénzügyi csapatoddal.

Főbb megállapítások

  • A szemantikai hasonlóság a jelentést méri, de vak marad a tagadásra
  • Bontsd fel a relevanciát különálló kritériumokra egy globális pontszám helyett
  • A hallucinációk észlelése a válasz és a forráskontextus szembeállításával történik
  • Készíts reprodukálható benchmarkokat, amelyek egyszerre mérik a minőséget, a késleltetést és a költséget
  • Kombináld az automatikus metrikákat és az LLM mint bíró megközelítést a teljes körű értékeléshez