Skapa anpassade utvärderingar
På denna sida
Lektionen uppdaterad 3 november 2026 baserat på OpenAI:s dokumentation:
temperatureochtop_paccepteras 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 specificerareasoning={"effort": "none"}(API Responses) ellerreasoning_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