Twórz własne ewaluacje
Na tej stronie
Lekcja zaktualizowana 3 listopada 2026 na podstawie dokumentacji OpenAI: parametry
temperatureitop_psą akceptowane tylko przy wysiłku rozumowania (reasoning effort) ustawionym nanone, podczas gdy modele GPT-5.6 domyślnie rozumują (medium). Wywołania ustawiające te parametry muszą zatem określaćreasoning={"effort": "none"}(API Responses) lubreasoning_effort="none"(Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.
Aktualizacja z 2 listopada 2026 — platforma Evals. OpenAI ogłosiło zakończenie działania swojej platformy Evals: istniejące ewaluacje są tylko do odczytu od 31 października 2026, a zarówno panel sterowania, jak i API, włącznie z oceniającymi (graders), zostaną zamknięte 30 listopada 2026. OpenAI opublikowało przewodnik migracyjny do narzędzia Promptfoo. Zasady ewaluacji przedstawione w tej lekcji pozostają ważne; zmienia się jedynie narzędzie.
Dostosuj ewaluacje do swojej domeny
Ogólne oceniające nie wystarczą do oceny jakości w Twojej specyficznej domenie. Chatbot medyczny, asystent prawny i narzędzie do pisania tekstów marketingowych mają różne kryteria jakości, które nie tylko różnią się liczbą, ale też priorytetami. Niedopasowanie tonu w newsletterze to niedogodność; to samo przybliżenie w instrukcji dawkowania to poważny błąd. Ogólny oceniający traktuje oba przypadki tak samo, co w praktyce oznacza brak jakiejkolwiek ewaluacji.
Dlatego potrzebujesz własnych ewaluacji opartych na wyraźnej rubryce, która przekłada Twoje priorytety biznesowe na wagi. Tę rubrykę właśnie zbudujemy.
Przekład wymogu biznesowego na rubrykę
Rubryka to lista ważonych kryteriów, których suma wynosi 1. Najbardziej użytecznym ćwiczeniem nie jest kodowanie struktury (co zajmuje około piętnastu linii), ale jej wypełnianie: decyzja, że korzyści dla klienta ważą 0,25, a długość tylko 0,10, wymusza explicitną rozmowę z właścicielami produktu. Efektem jest wspólna definicja „dobrej odpowiedzi“, której nikt nie zakwestionuje post factum.
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),
],
)
Metoda valider zasługuje na wywołanie w testach, a nie tylko na zapisanie. Rubryki ewoluują: dodajesz kryterium zgodności, usuwasz takie, które nie jest już użyteczne, a suma dryfuje do 1,15 bez żadnego flagowania anomalii. Wyniki pozostają obliczalne, ale są błędne, a porównywane między wersjami doprowadzą Cię do mylnych wniosków.
Oceniający tłumaczy następnie rubrykę na prompt, prosi o ocenę 0–5 dla każdego kryterium i recomponuje ważony wynik globalny. Każda ocena zawiera krótki komentarz: to pozwoli Ci, podczas przeglądania złych przypadków, zrozumieć, czy model odpowiedział źle, czy może Twoje kryterium było źle sformułowane.
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é"}
Uważaj na pętlę obliczeniową: kryterium brakujące w odpowiedzi sędziego jest cicho ignorowane i wnosi zero do ważonego wyniku. Doskonała odpowiedź mogłaby więc utknąć na poziomie 0,75 wyłącznie dlatego, że sędzia zapomniał o kluczowym elemencie. Jeśli Twoje wyniki wydają się utykać pod niewyjaśnionym sufitem, sprawdź scores_details, zanim obwinisz oceniany model.
Kiedy maszyna ocenia lepiej niż człowiek
Kazanie LLM oceniać kod to kosztowny skrót: jedynym werdyktem, który się liczy, jest wykonanie. Poniższy oceniający konkatenuje wygenerowany kod i test, zapisuje go w pliku tymczasowym, wykonuje go i zlicza sukcesy. Wynikowy wynik nie wymaga interpretacji – test albo przechodzi, albo nie.
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,
}
Parametr timeout=10 to nie wygoda: model regularnie produkuje nieskończone pętle i bez tego ograniczenia Twoja kampania ewaluacyjna utknęłaby na pierwszym failing przypadku. Pamiętaj też, że wykonujesz kod, którego nie napisałeś – poza izolowanym środowiskiem deweloperskim ta funkcja wymaga piaskownicy (sandbox).
Podsumowanie ilustruje przypadek mieszany, gdzie część osądu jest mechaniczna, a część nie. Długość jest mierzalna: obliczony współczynnik karze zarówno podsumowanie zbyt krótkie, jak i zbyt długie w sposób symetryczny, co uniknąć sztuczki modelu polegającej na kopiowaniu tekstu źródłowego, by niczego nie pominąć. Wierność z kolei nie jest mierzalna regułą i wraca do sędziego LLM, z bezpośrednim pytaniem o zmyślone informacje.
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,
}
Uczyń ewaluację powtarzalną
Ewaluacja, którą powtarzasz ręcznie, w końcu przestaje być powtarzana. Potok (pipeline) enkapsuluje rubrykę i utrzymuje historię kampanii, zamieniając jednorazowy pomiar w szereg czasowy: widzisz, że średni wynik spadł z 0,81 do 0,79 po zmianie promptu we wtorek – informacji, której żadne izolowane wykonanie nie mogłoby Ci dać.
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
Wskazówka na start: zbuduj swoją pierwszą rubrykę na zaledwie dwudziestu przypadkach, każ ją ocenić równolegle przez sędziego LLM i przez eksperta domenowego, a następnie porównaj oba szeregi. Rozbieżności powiedzą Ci, które kryteria są źle opisane, na długo zanim powiedzą Ci cokolwiek o jakości modelu.
Kluczowe wnioski
- Twórz rubryki ewaluacyjne specyficzne dla Twojej domeny biznesowej, z explicitnymi wagami
- Weryfikuj, czy suma wag pozostaje równa 1 w miarę ewolucji rubryki
- Łącz ewaluację zautomatyzowaną (kod, długość) z podejściem LLM-as-Judge (jakość)
- Testuj generowany kod poprzez jego wykonanie, z limitem czasu i w izolowanym środowisku
- Buduj wielokrotnego użytku potok, który przechowuje historię kampanii