Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Opret tilpassede evalueringer

Lektion 16 af 20 Opdateret 3. november 2026 Avanceret
På denne side
  1. Tilpas evalueringer til dit domæne
  2. Oversæt et forretningskrav til en rubrik
  3. Når maskinen bedømmer bedre end et menneske
  4. Gør evaluering gentagelig
  5. Vigtige pointer

Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation: temperature og top_p accepteres kun med en ræsonneringsindsats på none, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificere reasoning={"effort": "none"} (API Responses) eller reasoning_effort="none" (Chat Completions). Kilder: Using GPT-6 · GPT-5.6 Terra.

Opdatering 2. november 2026 — Evals-platformen. OpenAI har annonceret afviklingen af deres Evals-platform: eksisterende evalueringer har været skrivebeskyttede siden 31. oktober 2026, og både dashboardet og API’et, inklusive bedømmere, lukker den 30. november 2026. OpenAI har udgivet en migrationsguide til Promptfoo. Evalueringsprincipperne i denne lektion forbliver gyldige; det er kun værktøjet, der ændrer sig.

Tilpas evalueringer til dit domæne

Generiske bedømmere er ikke nok til at vurdere kvalitet inden for dit specifikke domæne. En medicinsk chatbot, en juridisk assistent og et skriverværktøj til marketing har hver især forskellige kvalitetskriterier, og disse kriterier er ikke blot flere i antal – de prioriteres forskelligt. En tone, der ikke matcher, i et nyhedsbrev er irriterende; den samme unøjagtighed i en doseringsvejledning er en alvorlig fejl. En generisk bedømmer behandler begge på samme måde, hvilket i praksis svarer til slet ikke at evaluere noget.

Derfor har du brug for tilpassede evalueringer bygget på en eksplicit rubrik, der oversætter dine forretningsprioriteter til vægte. Det er netop den rubrik, vi skal bygge nu.

Oversæt et forretningskrav til en rubrik

En rubrik er en liste over vægtede kriterier, der summerer til 1. Den mest nyttige øvelse er ikke at kode strukturen, hvilket tager omkring femten linjer, men at udfylde den: At beslutte, at kundegoder vejer 0,25, mens længde kun vejer 0,10, tvinger en eksplicit samtale med produktejere i gang. Det, du ender med, er en fælles definition af „et godt svar”, som ingen kan bestride i eftertid.

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),
    ],
)

Metoden valider fortjener at blive kaldt i tests, ikke blot at blive skrevet. Rubrikker udvikler sig: Du tilføjer et overholdelseskriterium, fjerner et, der ikke længere er nyttigt, og summen driver mod 1,15 uden at noget flagger anomalien. Scores forbliver beregnelige, men forkerte, og når de sammenlignes på tværs af versioner, vil de lede dig til fejlagtige konklusioner.

Bedømmeren oversætter derefter rubrikken til en prompt, beder om en score på 0–5 pr. kriterium og sammensætter en vægtet global score. Hver score ledsages af en kort kommentar: Det er det, der vil lade dig forstå, når du gennemgår dårlige tilfælde, om modellen svarede dårligt, eller om dit kriterium var dårligt formuleret.

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é"}

Pas på beregningsløkken: Et kriterium, der mangler i dommerens svar, ignoreres stille og bidrager med nul til den vægtede score. Et fremragende svar kunne derfor ende på maksimalt 0,75 simpelthen fordi dommeren glemte en nøgle. Hvis dine scores ser ud til at hænge fast under et uforklarligt loft, så inspecter scores_details, før du bebrejder den evaluerede model.

Når maskinen bedømmer bedre end et menneske

At få en LLM til at bedømme kode er en dyr genvej: Den eneste dom, der betyder noget, er eksekvering. Bedømmeren nedenfor sammenkæder den genererede kode og en test, skriver det til en midlertidig fil, eksekverer det og tæller succeser. Den resulterende score behøver ingen fortolkning – en test består enten, eller også gør den ikke.

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,
    }

timeout=10 er ikke en komfortforanstaltning: En model producerer regelmæssigt uendelige løkker, og uden denne grænse vil din evalueringskampagne hænge fast på det første fejlsagne tilfælde. Husk også, at du eksekverer kode, du ikke har skrevet selv – uden for et isoleret udviklingsmiljø kræver denne funktion en sandbox.

Sammenfatningen illustrerer et blandet tilfælde, hvor en del af bedømmelsen er mekanisk, og en del ikke er. Længde er målelig: Det beregnede forhold straffer et resumé, der er for kort, og et, der er for langt, symmetrisk, hvilket undgår modellens trick med at kopiere kildeteksten for ikke at udelade noget. Trofasthed kan derimod ikke måles med en regel og sendes tilbage til LLM-dommeren med et direkte spørgsmål om opfundne oplysninger.

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,
    }

Gør evaluering gentagelig

En evaluering, du gentager manuelt, holder til sidst op med at blive gentaget. Pipelinen kapsler rubrikken ind og holder en historik over kampagner, hvilket gør en engangsmåling til en tidsserie: Du ser, at den gennemsnitlige score faldt fra 0,81 til 0,79 efter tirsdagens prompt-ændring, en information ingen isoleret eksekvering kunne have givet dig.

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

Et tip til at komme i gang: Byg din første rubrik på blot tyve tilfælde, lad den blive scoret parallelt af LLM-dommeren og af en domæneekspert, og sammenlign derefter de to serier. Uoverensstemmelserne vil fortælle dig, hvilke kriterier der er dårligt beskrevet, længe før de fortæller dig noget om modellens kvalitet.

Vigtige pointer

  • Opret evalueringsrubrikker specifikke for dit forretningsdomæne med eksplicitte vægte
  • Verificer, at summen af vægte forbliver på 1, efterhånden som rubrikken udvikler sig
  • Kombinér automatiseret evaluering (kode, længde) og LLM-as-Judge (kvalitet)
  • Test genereret kode ved at eksekvere den med en timeout og i et isoleret miljø
  • Byg en genanvendelig pipeline, der holder en historik over kampagner