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

Évaluation personnalisée létrehozása

16. lecke 20 közül Frissítve 2026. november 3. Haladó
Ezen az oldalon
  1. Igazítsd az értékeléseket a saját domainedhez
  2. Üzleti követelmény lefordítása értékelési rubrikára
  3. Amikor a gép jobban ítél, mint az ember
  4. Tedd az értékelést megismételhetővé
  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 (reasoning effort) mellett fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) gondolkodnak. Ezért az ezeket a paramétereket beállító hívásoknak 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.

2026. november 2-i frissítés — Evals platform. Az OpenAI bejelentette az Evals platformjának megszüntetését: a meglévő értékelések 2026. október 31. óta csak olvashatók, és mind a vezérlőpult, mind az API – beleértve az értékelőket (graders) is – 2026. november 30-án megszűnik. Az OpenAI közzétett egy migrációs útmutatót a Promptfoo-hoz. Az ebben a leckében bemutatott értékelési elvek továbbra is érvényesek; csupán az eszköz változik.

Igazítsd az értékeléseket a saját domainedhez

Az általános értékelők nem elegendőek a minőség felmérésére a te specifikus területeden. Egy orvosi chatbotnak, egy jogi asszisztensnek és egy marketing szövegíró eszköznek mind eltérő minőségi kritériumai vannak, és ezek a kritériumok nemcsak számukban különböznek, hanem prioritásukban is. Egy hangnembeli hiba egy hírlevélben csak bosszúság; ugyanaz a pontatlanság egy adagolási utasításban súlyos hiba. Egy általános értékelő mindkettőt ugyanúgy kezeli, ami gyakorlatilag azt jelenti, hogy semmit sem értékel igazán.

Ezért van szükséged olyan egyedi értékelésekre, amelyek egy explicit értékelési rubrikára épülnek, és amely üzleti prioritásaidat súlyokká fordítja. Ezt a rubrikát fogjuk most felépíteni.

Üzleti követelmény lefordítása értékelési rubrikára

A rubrika súlyozott kritériumok listája, amelyek összege 1. A leghasznosabb gyakorlat nem a struktúra kódolása (ami kb. tizenöt sor), hanem annak kitöltése: annak eldöntése, hogy az ügyfél előnyei 0,25-öt érnek, míg a hossz csak 0,10-et, ez kényszerít ki egy explicit beszélgetést a termékfelelősökkel. Ami végül kialakul, az a „jó válasz“ közös definíciója, amelyet utólag senki sem vitathat meg.

from dataclasses import dataclass

@dataclass
class Critere:
    nom: str
    description: str
    poids: float  # 0 to 1, sum of weights = 1

@dataclass
class Rubrique:
    nom: str
    criteres: list[Critere]

    def valider(self) -> bool:
        total = sum(c.poids for c in self.criteres)
        return abs(total - 1.0) < 0.01

# Example: rubric for a marketing writing assistant
rubrique_marketing = Rubrique(
    nom="Qualité rédaction marketing",
    criteres=[
        Critere("ton", "Le ton est professionnel et engageant", 0.20),
        Critere("cta", "Contient un appel à l'action clair", 0.15),
        Critere("benefices", "Met en avant les bénéfices client", 0.25),
        Critere("longueur", "Respecte la longueur demandée", 0.10),
        Critere("grammaire", "Aucune faute de grammaire ou orthographe", 0.15),
        Critere("marque", "Respecte les guidelines de la marque", 0.15),
    ],
)

A valider metódust érdemes tesztekben is meghívni, nemcsak megírni. A rubrikák fejlődnek: hozzáadsz egy megfelelőségi kritériumot, eltávolítasz egy már hasznavehetetlent, és az összeg észrevétlenül 1,15-re csúszik, anélkül, hogy bármi jelezné a rendellenességet. A pontszámok továbbra is kiszámíthatók maradnak, csak hibásak lesznek, és a verziók közötti összehasonlításkor téves következtetésekre vezetnek.

Az értékelő ezután a rubrikát prompttá alakítja, kér egy 0–5 közötti pontszámot kritériumonként, majd újraösszerakja a súlyozott globális pontszámot. Minden ponthoz rövid kommentár társul: ez teszi lehetővé, hogy a rossz esetek áttekintésekor megértsd, vajon a modell válaszolt-e rosszul, vagy a kritériumod volt-e rosszul megfogalmazva.

import openai
import json

client = openai.OpenAI()

def evaluer_multi_criteres(
    question: str,
    reponse: str,
    rubrique: Rubrique,
) -> dict:
    """Evaluates a response against a multi-criteria rubric."""

    criteres_texte = "\n".join(
        f"- {c.nom} (poids: {c.poids}): {c.description}"
        for c in rubrique.criteres
    )

    prompt = (
        "Évaluez cette réponse selon les critères suivants.\n"
        "Pour chaque critère, donnez un score de 0 à 5.\n\n"
        f"Question posée : {question}\n"
        f"Réponse à évaluer : {reponse}\n\n"
        f"Critères :\n{criteres_texte}\n\n"
        "Répondez en JSON avec un objet scores contenant pour chaque critère "
        "un score (0-5) et un commentaire court."
    )

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

    try:
        resultat = json.loads(response.output_text)
        scores = resultat.get("scores", {})

        # Calculate weighted score
        score_pondere = 0
        for critere in rubrique.criteres:
            if critere.nom in scores:
                score_brut = scores[critere.nom]["score"] / 5.0
                score_pondere += score_brut * critere.poids

        return {
            "score_global": score_pondere,
            "scores_details": scores,
            "rubrique": rubrique.nom,
        }
    except (json.JSONDecodeError, KeyError):
        return {"score_global": 0, "erreur": "Parsing échoué"}

Vigyázz a számítási ciklussal: ha egy kritérium hiányzik a bíró (judge) válaszából, az csendesen figyelmen kívül marad, és nulla hozzájárulást jelent a súlyozott ponthoz. Egy kiváló válasz így akár 0,75-nél is megállhat pusztán azért, mert a bíró elfelejtett egy kulcsot. Ha a pontszámaid megmagyarázhatatlan plafon alatt ragadnak, vizsgáld meg a scores_details adatokat, mielőtt az értékelt modellt hibáztatnád.

Amikor a gép jobban ítél, mint az ember

LLM-mel kódot értékelni költséges rövidítés: az egyetlen mérvadó ítélet a végrehajtás. Az alábbi értékelő összefűzi a generált kódot és egy tesztet, ideiglenes fájlba írja, végrehajtja, és megszámolja a sikereket. Az így kapott pontszám nem igényel értelmezést – egy teszt vagy sikerül, vagy nem.

import subprocess
import tempfile

def evaluer_code_python(
    code_genere: str,
    tests: list[str],
) -> dict:
    """Evaluates Python code by executing it against tests."""
    resultats_tests = []

    for i, test in enumerate(tests):
        code_complet = f"{code_genere}\n\n{test}"

        with tempfile.NamedTemporaryFile(
            mode="w", suffix=".py", delete=False
        ) as f:
            f.write(code_complet)
            f.flush()

            try:
                resultat = subprocess.run(
                    ["python3", f.name],
                    capture_output=True,
                    text=True,
                    timeout=10,
                )
                succes = resultat.returncode == 0
                resultats_tests.append({
                    "test": i,
                    "succes": succes,
                    "sortie": resultat.stdout[:200],
                    "erreur": resultat.stderr[:200] if not succes else "",
                })
            except subprocess.TimeoutExpired:
                resultats_tests.append({
                    "test": i,
                    "succes": False,
                    "erreur": "Timeout (10s)",
                })

    nb_succes = sum(1 for r in resultats_tests if r["succes"])
    return {
        "score": nb_succes / len(tests) if tests else 0,
        "tests_passes": nb_succes,
        "tests_total": len(tests),
        "details": resultats_tests,
    }

A timeout=10 nem kényelmi óvintézkedés: egy modell rendszeresen produkál végtelen ciklusokat, és e határ nélkül az értékelési kampányod már az első sikertelen esetben beragad. Ne feledd azt sem, hogy olyan kódot hajtasz végre, amit nem te írtál – egy izolált fejlesztői környezeten kívül ez a függvény homokozót (sandbox) igényel.

Az összefoglaló egy vegyes esetet illusztrál, ahol az ítélet egy része mechanikus, másik része pedig nem. A hossz mérhető: a kiszámított arány szimmetrikusan bünteti a túl rövid és a túl hosszú összefoglalót is, ami elkerüli a modell azon trükkjét, hogy a forrásszöveg másolásával kihagyjon bármit is. A hűség viszont nem mérhető szabállyal, és visszakerül az LLM-bíróhoz, egy közvetlen kérdéssel a kitalált információkról.

def evaluer_resume(
    texte_original: str,
    resume: str,
    longueur_cible: int = 100,
) -> dict:
    """Evaluates summary quality."""
    mots_resume = len(resume.split())
    ratio_longueur = min(
        mots_resume / longueur_cible,
        longueur_cible / max(mots_resume, 1),
    )

    # Fidelity via LLM
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=(
            f"Le résumé suivant est-il fidèle au texte original ? "
            f"Contient-il des informations inventées ?\n\n"
            f"Texte original (extrait) : {texte_original[:2000]}\n\n"
            f"Résumé : {resume}\n\n"
            f"Répondez en JSON avec les clés : fidélité (0-5), "
            f"hallucinations (oui/non), commentaire (court)."
        ),
        temperature=0.0,
    )

    try:
        fidelite = json.loads(response.output_text)
    except json.JSONDecodeError:
        fidelite = {"fidelite": 0, "hallucinations": "inconnu"}

    return {
        "score_longueur": ratio_longueur,
        "score_fidelite": fidelite.get("fidelite", 0) / 5.0,
        "hallucinations": fidelite.get("hallucinations", "inconnu"),
        "mots_resume": mots_resume,
        "longueur_cible": longueur_cible,
    }

Tedd az értékelést megismételhetővé

Egy kézzel újra és újra futtatott értékelés előbb-utóbb abbamarad. A folyamat (pipeline) kapszulázza a rubrikát, és nyilvántartja a kampányok történetét, így az egyszeri mérésből idősor lesz: látod, hogy az átlagpontszám 0,81-ről 0,79-re esett vissza a keddi prompt-változtatás után – olyan információ, amelyet egyetlen izolált végrehajtás sosem adott volna meg neked.

class PipelineEval:
    """Reusable evaluation pipeline."""

    def __init__(self, nom: str, rubrique: Rubrique):
        self.nom = nom
        self.rubrique = rubrique
        self.historique: list[dict] = []

    def evaluer_batch(
        self,
        dataset: list[dict],
        modele: str,
        prompt_systeme: str,
    ) -> dict:
        """Evaluates a full batch and returns metrics."""
        resultats = []

        for cas in dataset:
            response = client.responses.create(
                model=modele,
                instructions=prompt_systeme,
                input=cas["input"],
            )

            eval_result = evaluer_multi_criteres(
                cas["input"],
                response.output_text,
                self.rubrique,
            )
            resultats.append(eval_result)

        scores = [r["score_global"] for r in resultats]
        rapport = {
            "pipeline": self.nom,
            "modele": modele,
            "nb_cas": len(dataset),
            "score_moyen": sum(scores) / len(scores),
            "score_min": min(scores),
            "score_max": max(scores),
        }

        self.historique.append(rapport)
        return rapport

Egy tipp a kezdéshez: építsd fel az első rubrikádat mindössze húsz esetre, értékeltessed párhuzamosan az LLM-bíróval és egy domain-szakértővel, majd hasonlítsd össze a két adatsort. Az eltérések sokkal hamarabb megmutatják, mely kritériumok vannak rosszul leírva, mint ahogy bármit is mondanának a modell minőségéről.

Főbb megállapítások

  • Készíts üzleti domainedre szabott értékelési rubrikákat explicit súlyokkal
  • Ellenőrizd, hogy a súlyok összege 1 marad-e a rubrika fejlődése során
  • Kombináld az automatizált értékelést (kód, hossz) és az LLM-mint-bíró megközelítést (minőség)
  • Teszteld a generált kódot végrehajtással, időtúllépési korláttal és izolált környezetben
  • Építs újrahasználható folyamatot, amely nyilvántartja a kampányok történetét