Kurkite individualius vertinimus
Šiame puslapyje
Pamoka atnaujinta 2026 m. lapkričio 3 d. pagal „OpenAI“ dokumentaciją: parametrai
temperatureirtop_ppriimami tik esantnonelygio samprotavimui, tuo tarpu GPT-5.6 modeliai pagal nutylėjimą samprotauja (medium). Todėl kvietimuose, kuriuose nustatomi šie parametrai, būtina nurodytireasoning={"effort": "none"}(API Responses) arbareasoning_effort="none"(Chat Completions). Šaltiniai: Using GPT-6 · GPT-5.6 Terra.
2026 m. lapkričio 2 d. naujiena — „Evals“ platforma. „OpenAI“ paskelbė apie savo „Evals“ platformos veiklos pabaigą: esami vertinimai nuo 2026 m. spalio 31 d. yra tik skaitymo režimu, o tiek skydelis, tiek API, įskaitant vertintojus, bus uždaryti 2026 m. lapkričio 30 d. „OpenAI“ paskelbė migracijos į „Promptfoo“ gidą. Šioje pamokoje pateikti vertinimo principai lieka galioti; keičiasi tik įrankis.
Pritaikykite vertinimus savo sričiai
Bendrieji vertintojai nepakankami kokybei įvertinti jūsų specifinėje srityje. Medicininis pokalbių robotas, teisinis asistentas ir rinkodaros rašymo įrankis turi skirtingus kokybės kriterijus, ir šie kriterijai yra ne tik gausesni – jie prioritetizuojami skirtingai. Tonas, neatitinkantis naujienlaiškio, yra tik nepatogumas; tas pats netikslumas dozavimo instrukcijoje yra rimta klaida. Bendrasis vertintojas abu atvejus traktuoja vienodai, o tai reiškia, kad jis iš tikrųjų nieko nevertina.
Štai kodėl tau reikia individualių vertinimų, pagrįstų aiškia rubrika, kuri tavo verslo prioritetus paverčia svoriais. Būtent tokią rubriką ir kursime.
Verslo reikalavimą paversk rubrika
Rubrika – tai pasvertų kriterijų sąrašas, kurio suma lygi 1. Naudingiausia užduotis – ne struktūros kodavimas (tam užtenka apie penkiolikos eilučių), o jos užpildymas: sprendimas, kad kliento nauda sveria 0,25, o ilgis – tik 0,10, verčia aiškiai pasikalbėti su produkto savininkais. Galutinis rezultatas – bendras „gero atsakymo“ apibrėžimas, dėl kurio niekas negalės ginčytis 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),
],
)
Metodą valider verta kviesti testuose, o ne tik parašyti. Rubrikos keičiasi: pridėjus atitikties kriterijų arba pašalinus nebenaudojamą, suma gali nukrypti iki 1,15, ir niekas nepastebės anomalijos. Balai vis dar bus apskaičiuojami, tik bus neteisingi, o lyginant juos tarp versijų, padarysi klaidingas išvadas.
Tada vertintojas rubriką paverčia užklausa, paprašo 0–5 balo už kiekvieną kriterijų ir perskaičiuoja pasvertą bendrą balą. Kiekvienas balas pateikiamas su trumpu komentaru: tai leis tau, peržiūrint blogus atvejus, suprasti, ar modelis atsakė prastai, ar tavo kriterijus buvo suformuluotas netiksliai.
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é"}
Atkreipk dėmesį į skaičiavimo ciklą: jei vertintojo atsakyme trūksta kriterijaus, jis tyliai ignoruojamas ir pasvertam balui suteikia nulį. Todėl puikus atsakymas gali gauti tik 0,75 balo vien todėl, kad vertintojas pamiršo vieną punktą. Jei tavo balai, atrodo, sustingo nepaaiškinamose lubose, prieš kaltinant vertinamą modelį, patikrink scores_details.
Kai mašina vertina geriau nei žmogus
LLM kodui vertinti yra brangus trumpinys: vienintelis svarbus verdiktas yra vykdymas. Toliau pateiktas vertintojas sujungia sugeneruotą kodą ir testą, įrašo juos į laikiną failą, įvykdo ir suskaičiuoja sėkmes. Gautam balui nereikia interpretacijos – testas arba pavyksta, arba ne.
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 nėra šiaip sau atsargumo priemonė: modeliai reguliariai kuria begalines kilpas, ir be šios ribos tavo vertinimo kampanija įstrigtų ties pirmuoju nepavykusiu atveju. Taip pat atmink, kad vykdai kodą, kurio nerašei – už izoliuotos kūrimo aplinkos ribų šiai funkcijai reikia smėlio dėžės (sandbox).
Santrauka iliustruoja mišrų atvejį, kai dalis vertinimo yra mechaninė, o dalis – ne. Ilgį galima išmatuoti: apskaičiuotas santykis baudžia tiek per trumpą, tiek per ilgą santrauką simetriškai, taip išvengiant modelio gudrybės kopijuoti šaltinio tekstą, kad nieko nepraleistų. Tuo tarpu tikslumo negalima išmatuoti taisykle, todėl tenka grįžti prie LLM vertintojo, tiesiogiai klausiant apie sugalvotą informaciją.
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,
}
Padaryk vertinimą pakartojamą
Vertinimas, kurį kartoji rankiniu būdu, ilgainiui nustoja būti kartojamas. Vamzdynas (pipeline) inkapsuliuoja rubriką ir saugo kampanijų istoriją, paviesdamas vienkartinį matavimą į laiko eilutę: matai, kad vidutinis balas sumažėjo nuo 0,81 iki 0,79 po antradienio užklausos pakeitimo – informacija, kurios negalėtum gauti iš vienkartinio vykdymo.
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
Patarimas pradedantiesiems: sukurk savo pirmąją rubriką tik dvidešimčiai atvejų, leisk ją įvertinti lygiagrečiai LLM vertintojui ir srities ekspertui, tada palygink abi eilutes. Skirtumai parodys, kurie kriterijai aprašyti netiksliai, gerokai anksčiau nei jie ką nors pasakys apie modelio kokybę.
Svarbiausi punktai
- Kurk vertinimo rubrikas, specifines tavo verslo sričiai, su aiškiais svoriais
- Patikrink, ar svorių suma lieka lygi 1, rubrikai evoliucionuojant
- Derink automatinį vertinimą (kodas, ilgis) ir LLM kaip vertintoją (kokybė)
- Testuok sugeneruotą kodą jį vykdydami, naudodami laiko limitą ir izoliuotą aplinką
- Sukurk pakartotinai naudojamą vamzdyną, kuris saugo kampanijų istoriją