Izveido pielāgotus novērtējumus
Šajā lapā
Nodarbība atjaunināta 2026. gada 3. novembrī, pamatojoties uz OpenAI dokumentāciju: parametri
temperatureuntop_ptiek pieņemti tikai ar spriešanas piepūli (reasoning effort) vērtībānone, savukārt GPT-5.6 modeļi pēc noklusējuma veic spriešanu (medium). Tādēļ izsaukumos, kuros iestatīti šie parametri, ir jānorādareasoning={"effort": "none"}(API Responses) vaireasoning_effort="none"(Chat Completions). Avoti: Using GPT-6 · GPT-5.6 Terra.
2026. gada 2. novembra atjauninājums — Evals platforma. OpenAI ir paziņojusi par savas Evals platformas darbības izbeigšanu: esošie novērtējumi kopš 2026. gada 31. oktobra ir tikai lasāmi, un gan informācijas panelis, gan API, ieskaitot vērtētājus, tiks slēgti 2026. gada 30. novembrī. OpenAI ir publicējusi migrācijas ceļvedi uz Promptfoo. Šajā nodarbībā aplūkotie novērtēšanas principi paliek spēkā; mainās tikai rīks.
Pielāgo novērtējumus savai nozarei
Vispārīgi vērtētāji nav pietiekami, lai novērtētu kvalitāti tavā konkrētajā nozarē. Medicīnas čatbotam, juridiskajam asistentam un mārketinga rakstīšanas rīkam ir dažādi kvalitātes kritēriji, un šie kritēriji nav tikai skaitliski lielāki — tie ir dažādi prioritizēti. Tonālās neatbilstības gadījums informatīvajā vēstulē ir kaitinošs; tāda pati neprecizitāte devas instrukcijās ir nopietna kļūda. Vispārīgs vērtētājs abus gadījumus aplūko vienādi, kas faktiski nozīmē, ka netiek novērtēts nekas.
Tieši tāpēc tev ir nepieciešami pielāgoti novērtējumi, kas balstīti uz skaidru vērtēšanas skalas (rubric) sistēmu, kura pārvērš tavas biznesa prioritātes svaros. Tieši tādu skalas sistēmu mēs tagad izveidosim.
Pārvērt biznesa prasību vērtēšanas skalā
Vērtēšanas skala ir svērto kritēriju saraksts, kuru summa ir 1. Noderīgākais uzdevums nav koda struktūras programmēšana, kas aizņem aptuveni piecpadsmit rindiņas, bet gan tās aizpildīšana: lēmuma pieņemšana, ka klientu ieguvumiem ir svars 0,25, bet garumam tikai 0,10, piespiež tevi vest skaidru sarunu ar produkta īpašniekiem. Rezultātā tu iegūsti kopīgu „labas atbildes” definīciju, par kuru neviens vēlāk nevarēs strīdēties.
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),
],
)
Metode valider ir pelnījusi, lai to izsauktu testos, nevis tikai uzrakstītu. Vērtēšanas skalas evolucionē: tu pievieno atbilstības kritēriju, noņem tādu, kas vairs nav noderīgs, un summa nobīdās uz 1,15, bet nekas nenorāda uz anomāliju. Rezultāti joprojām ir aprēķināmi, tikai nepareizi, un, salīdzinot tos starp versijām, tie novedīs pie kļūdainiem secinājumiem.
Vērtētājs pēc tam pārvērš vērtēšanas skalu promptā, pieprasa 0–5 ballu vērtējumu katram kritērijam un apkopo svērto globālo rezultātu. Katram vērtējumam pievienots īss komentārs: tieši tas ļaus tev, pārskatot sliktos gadījumus, saprast, vai modelis ir sniedzis sliktu atbildi, vai arī tavs kritērijs bija slikti formulēts.
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é"}
Uzmanies ar aprēķinu ciklu: ja tiesneša atbildē trūkst kāds kritērijs, tas tiek klusi ignorēts un dod nuldi svērtajam rezultātam. Lieliska atbilde tādējādi varētu sasniegt maksimāli 0,75 vienkārši tāpēc, ka tiesnesis ir aizmirsis kādu atslēgu. Ja tavi rezultāti šķiet iestrēguši zem neizskaidrojama griesta, pirms vaino novērtēto modeli, pārbaudi scores_details.
Kad mašīna vērtē labāk nekā cilvēks
LLM izmantot koda vērtēšanai ir dārgs īsceļš: vienīgais spriedums, kam ir nozīme, ir izpilde. Tālāk redzamais vērtētājs apvieno ģenerēto kodu un testu, ieraksta to pagaidu failā, izpilda to un saskaita veiksmīgās izpildes. Iegūtajam rezultātam nav nepieciešama interpretācija — tests vai nu izdodas, vai 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,
}
Iestatījums timeout=10 nav tikai drošības pasākums: modeļi regulāri ģenerē bezgalīgus ciklus, un bez šī ierobežojuma tava novērtēšanas kampaņa iestrēgs pie pirmā neizdevušā gadījuma. Atceries arī, ka tu izpildi kodu, ko neesi rakstījis pats — ārpus izolētas izstrādes vides šī funkcija prasa smilškasti (sandbox).
Kopsavilkums ilustrē jauktu gadījumu, kur daļa vērtējuma ir mehāniska, bet daļa nav. Garums ir izmērāms: aprēķinātais attiecības rādītājs sodīs gan pārāk īsu, gan pārāk garu kopsavilkumu simetriski, kas novērš modeļa triku nokopēt avota tekstu, lai neko neizlaistu. Savukārt uzticamību nevar izmērīt ar likumu, un tā atgriežas pie LLM tiesneša ar tiešu jautājumu par izgudrotu informāciju.
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,
}
Padari novērtēšanu atkārtojamu
Novērtējums, ko atkārto manuāli, galu galā pārstās tikt atkārtots. Konveijers (pipeline) kapsulē vērtēšanas skalu un glabā kampaņu vēsturi, pārvēršot vienreizēju mērījumu laika rindā: tu redzi, ka vidējais rezultāts ir krities no 0,81 uz 0,79 pēc otrdienas prompta izmaiņām — informācija, ko neviens izolēts izpildījums tev nevarētu sniegt.
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
Viens padoms, lai sāktu: izveido savu pirmo vērtēšanas skalu, balstoties tikai uz divdesmit gadījumiem, liec to vērtēt paralēli gan LLM tiesnesim, gan nozares ekspertam, un pēc tam salīdzini abas rindas. Atšķirības tev pateiks, kuri kritēriji ir slikti aprakstīti, ilgi pirms tās tev pastāstīs kaut ko par modeļa kvalitāti.
Galvenās atziņas
- Izveido vērtēšanas skalas, kas specifiskas tavai biznesa nozarei, ar skaidriem svariem
- Pārliecinies, ka svaru summa paliek 1, kamēr vērtēšanas skala attīstās
- Apvieno automatizētu novērtēšanu (kods, garums) un LLM-as-Judge (kvalitāte)
- Testē ģenerēto kodu, to izpildot, ar noilgumu un izolētā vidē
- Izveido atkārtoti izmantojamu konveijeru, kas glabā kampaņu vēsturi