Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Skapa anpassade utvärderingar

Lektion 16 av 20 Uppdaterad 3 november 2026 Avancerad
På denna sida
  1. Skräddarsy utvärderingar för din domän
  2. Översätt ett affärskrav till en bedömningsmall
  3. När maskinen bedömer bättre än en människa
  4. Gör utvärderingen repeterbar
  5. Viktiga punkter

Lektionen uppdaterad 3 november 2026 baserat på OpenAI:s dokumentation: temperature och top_p accepteras endast med ett resonemangsarbete på none, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificera reasoning={"effort": "none"} (API Responses) eller reasoning_effort="none" (Chat Completions). Källor: Using GPT-6 · GPT-5.6 Terra.

Uppdatering 2 november 2026 — Evals-plattform. OpenAI har meddelat att deras Evals-plattform läggs ner: befintliga utvärderingar har varit skrivskyddade sedan den 31 oktober 2026, och både instrumentpanelen och API:t, inklusive bedömare, stängs den 30 november 2026. OpenAI har publicerat en migreringsguide till Promptfoo. Utvärderingsprinciperna i denna lektion förblir giltiga; det är endast verktyget som ändras.

Skräddarsy utvärderingar för din domän

Generiska bedömare räcker inte för att bedöma kvalitet inom din specifika domän. En medicinsk chattbot, en juridisk assistent och ett verktyg för marknadsföringstext har alla olika kvalitetskriterier, och dessa kriterier är inte bara fler till antalet – de prioriteras också olika. En tonart som inte stämmer i ett nyhetsbrev är irriterande; samma ungefärlighet i en doseringsinstruktion är ett allvarligt fel. En generisk bedömare behandlar båda på samma sätt, vilket i praktiken innebär att man inte utvärderar något alls.

Därför behöver du anpassade utvärderingar byggda på en explicit bedömningsmall som översätter dina affärsprioriteringar till vikter. Det är den mallen vi ska bygga nu.

Översätt ett affärskrav till en bedömningsmall

En bedömningsmall är en lista över viktade kriterier som summeras till 1. Den mest givande övningen är inte att koda strukturen, vilket tar cirka femton rader, utan att fylla i den: att besluta att kundfördelar väger 0,25 medan längd bara väger 0,10 tvingar fram en explicit konversation med produktägare. Resultatet blir en gemensam definition av “ett bra svar” som ingen kan bestrida i efterhand.

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 förtjänar att anropas i tester, inte bara skrivas. Bedömningsmallar utvecklas: du lägger till ett efterlevnadskriterium, tar bort ett som inte längre är användbart, och summan glider till 1,15 utan att något flaggar avvikelsen. Poängen går fortfarande att beräkna, men de blir felaktiga, och vid jämförelse över versioner leder de dig till felaktiga slutsatser.

Bedömaren översätter sedan mallen till en prompt, begär ett betyg på 0–5 per kriterium och sätter samman ett viktat globalt betyg. Varje betyg åtföljs av en kort kommentar: det är vad som låter dig, när du granskar dåliga fall, förstå om modellen svarade dåligt eller om ditt kriterium var dåligt formulerat.

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

Se upp med beräkningsloopen: ett kriterium som saknas i domarens svar ignoreras tyst och bidrar med noll till det viktade betyget. Ett utmärkt svar kan därför fastna på 0,75 helt enkelt för att domaren glömde en nyckel. Om dina betyg verkar fastna under ett oförklarat tak, inspektera scores_details innan du skyller på den utvärderade modellen.

När maskinen bedömer bättre än en människa

Att låta en LLM bedöma kod är en dyr genväg: den enda domen som räknas är exekvering. Bedömaren nedan slår samman den genererade koden och ett test, skriver det till en temporär fil, exekverar det och räknar framgångar. Det resulterande betyget behöver ingen tolkning – ett test klaras antingen eller så gör det det inte.

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 är ingen bekvämlighetsåtgärd: en modell producerar regelbundet oändliga loopar, och utan denna gräns fastnar din utvärderingskampanj på det första misslyckade fallet. Kom också ihåg att du exekverar kod du inte har skrivit – utanför en isolerad utvecklingsmiljö kräver denna funktion en sandlåda.

Sammanfattningen illustrerar ett blandat fall, där en del av bedömningen är mekanisk och en del inte är det. Längd är mätbar: det beräknade förhållandet straffar en sammanfattning som är för kort och en som är för lång symmetriskt, vilket undviker modellens trick att kopiera källtexten för att inte utelämna något. Trohet är däremot inte mätbar med en regel och återgår till LLM-domaren, med en direkt fråga om påhittad information.

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 utvärderingen repeterbar

En utvärdering som du kör manuellt slutar så småningom med att inte köras alls. Pipelinen kapslar in bedömningsmallen och håller en historik över kampanjer, vilket gör en engångsmätning till en tidsserie: du ser att medelbetyget sjönk från 0,81 till 0,79 efter tisdagens promptändring, information som ingen isolerad exekvering kunde ha gett 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

Ett tips för att komma igång: bygg din första bedömningsmall på bara tjugo fall, låt den betygsättas parallellt av LLM-domaren och av en domänexpert, och jämför sedan de två serierna. Avvikelserna kommer att berätta vilka kriterier som är dåligt beskrivna långt innan de berättar något om modellens kvalitet.

Viktiga punkter

  • Skapa utvärderingsmallar specifika för din affärsdomän med explicita vikter
  • Verifiera att summan av vikterna förblir 1 när mallen utvecklas
  • Kombinera automatiserad utvärdering (kod, längd) och LLM-as-Judge (kvalitet)
  • Testa genererad kod genom att exekvera den, med en tidsgräns och i en isolerad miljö
  • Bygg en återanvändbar pipeline som håller en historik över kampanjer