Crearea evaluărilor personalizate
Pe această pagină
Lecție actualizată la 3 noiembrie 2026 pe baza documentației OpenAI: parametrii
temperatureșitop_psunt acceptați doar cu un efort de raționament denone, în timp ce modelele GPT-5.6 raționează implicit (medium). Apelurile care setează acești parametri trebuie, prin urmare, să specificereasoning={"effort": "none"}(API Responses) saureasoning_effort="none"(Chat Completions). Surse: Utilizarea GPT-6 · GPT-5.6 Terra.
Actualizare 2 noiembrie 2026 — Platforma Evals. OpenAI a anunțat încetarea platformei sale Evals: evaluările existente sunt în mod read-only începând cu 31 octombrie 2026, iar atât tabloul de bord, cât și API-ul, inclusiv corectorii (graders), se vor închide la 30 noiembrie 2026. OpenAI a publicat un ghid de migrare către Promptfoo. Principiile de evaluare din această lecție rămân valabile; se schimbă doar instrumentul.
Adaptați evaluările la domeniul dumneavoastră
Corectorii generici nu sunt suficienți pentru a evalua calitatea în domeniul dumneavoastră specific. Un chatbot medical, un asistent juridic și un instrument de scriere pentru marketing au fiecare criterii de calitate diferite, iar aceste criterii nu sunt doar mai numeroase—sunt ierarhizate diferit. O nepotrivire de ton într-un newsletter este o neplăcere; aceeași aproximare într-o instrucțiune de dozaj este o eroare gravă. Un corector generic le tratează pe ambele la fel, ceea ce echivalează cu a nu evalua nimic deloc.
De aceea, aveți nevoie de evaluări personalizate, construite pe o grilă explicită care traduce prioritățile afacerii dumneavoastră în ponderi. Aceasta este grila pe care o vom construi.
Traduceți o cerință de business într-o grilă de evaluare
O grilă este o listă de criterii ponderate care însumează 1. Cel mai util exercițiu nu este codarea structurii, care durează aproximativ cincisprezece linii, ci completarea acesteia: decizia ca beneficiile pentru client să cântărească 0,25, în timp ce lungimea cântărește doar 0,10, forțează o conversație explicită cu proprietarii de produs. Ceea ce obțineți în final este o definiție comună a „unui răspuns bun“ pe care nimeni nu o poate contesta ulterior.
from dataclasses import dataclass
@dataclass
class Criteriu:
nume: str
descriere: str
pondere: float # 0 la 1, suma ponderilor = 1
@dataclass
class Grila:
nume: str
criterii: list[Criteriu]
def valida(self) -> bool:
total = sum(c.pondere for c in self.criterii)
return abs(total - 1.0) < 0.01
# Exemplu: grilă pentru un asistent de scriere marketing
grila_marketing = Grila(
nume="Calitate redactare marketing",
criterii=[
Criteriu("ton", "Tonul este profesionist și angajant", 0.20),
Criteriu("cta", "Conține un apel la acțiune clar", 0.15),
Criteriu("beneficii", "Evidențiază beneficiile pentru client", 0.25),
Criteriu("lungime", "Respectă lungimea solicitată", 0.10),
Criteriu("gramatica", "Fără greșeli de gramatică sau ortografie", 0.15),
Criteriu("marca", "Respectă ghidul de stil al mărcii", 0.15),
],
)
Metoda valida merită apelată în teste, nu doar scrisă. Grilele evoluează: adăugați un criteriu de conformitate, eliminați unul care nu mai este util, iar suma deviază la 1,15 fără ca nimic să semnaleze anomalia. Scorurile rămân calculabile, doar că sunt greșite, iar atunci când sunt comparate între versiuni, vă vor conduce la concluzii eronate.
Corectorul traduce apoi grila într-un prompt, cere un scor de la 0 la 5 pentru fiecare criteriu și recompune un scor global ponderat. Fiecare scor vine însoțit de un scurt comentariu: asta vă va permite, atunci când revizuiți cazurile negative, să înțelegeți dacă modelul a răspuns slab sau dacă criteriul dumneavoastră a fost formulat prost.
import openai
import json
client = openai.OpenAI()
def evalua_multi_criterii(
intrebare: str,
raspuns: str,
grila: Grila,
) -> dict:
"""Evaluează un răspuns conform unei grile cu mai multe criterii."""
text_criterii = "\n".join(
f"- {c.nume} (pondere: {c.pondere}): {c.descriere}"
for c in grila.criterii
)
prompt = (
"Evaluați acest răspuns conform criteriilor următoare.\n"
"Pentru fiecare criteriu, acordați un scor de la 0 la 5.\n\n"
f"Întrebare pusă : {intrebare}\n"
f"Răspuns de evaluat : {raspuns}\n\n"
f"Criterii :\n{text_criterii}\n\n"
"Răspundeți în JSON cu un obiect scores conținând pentru fiecare criteriu "
"un scor (0-5) și un comentariu scurt."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature necesită effort none
input=prompt,
temperature=0.0,
)
try:
rezultat = json.loads(response.output_text)
scoruri = rezultat.get("scores", {})
# Calcularea scorului ponderat
scor_ponderat = 0
for criteriu in grila.criterii:
if criteriu.nume in scoruri:
scor_brut = scoruri[criteriu.nume]["score"] / 5.0
scor_ponderat += scor_brut * criteriu.pondere
return {
"scor_global": scor_ponderat,
"detalii_scoruri": scoruri,
"grila": grila.nume,
}
except (json.JSONDecodeError, KeyError):
return {"scor_global": 0, "eroare": "Analiza JSON a eșuat"}
Atenție la bucla de calcul: un criteriu lipsă din răspunsul judecătorului este ignorat tacit și contribuie cu zero la scorul ponderat. Un răspuns excelent ar putea, prin urmare, să se blocheze la 0,75 simplu pentru că judecătorul a uitat o cheie. Dacă scorurile dumneavoastră par blocate sub un plafon neexplicat, inspectați detalii_scoruri înainte de a da vina pe modelul evaluat.
Când mașina judecă mai bine decât omul
A avea un LLM care notează codul este o scurtătură costisitoare: singurul verdict care contează este execuția. Corectorul de mai jos concatenează codul generat și un test, îl scrie într-un fișier temporar, îl execută și numără succesele. Scorul rezultat nu necesită interpretare—un test fie trece, fie nu.
import subprocess
import tempfile
def evalua_cod_python(
cod_generat: str,
teste: list[str],
) -> dict:
"""Evaluează codul Python executându-l împotriva testelor."""
rezultate_teste = []
for i, test in enumerate(teste):
cod_complet = f"{cod_generat}\n\n{test}"
with tempfile.NamedTemporaryFile(
mode="w", suffix=".py", delete=False
) as f:
f.write(cod_complet)
f.flush()
try:
rezultat = subprocess.run(
["python3", f.name],
capture_output=True,
text=True,
timeout=10,
)
succes = rezultat.returncode == 0
rezultate_teste.append({
"test": i,
"succes": succes,
"iesire": rezultat.stdout[:200],
"eroare": rezultat.stderr[:200] if not succes else "",
})
except subprocess.TimeoutExpired:
rezultate_teste.append({
"test": i,
"succes": False,
"eroare": "Timeout (10s)",
})
nr_succese = sum(1 for r in rezultate_teste if r["succes"])
return {
"scor": nr_succese / len(teste) if teste else 0,
"teste_trecute": nr_succese,
"teste_total": len(teste),
"detalii": rezultate_teste,
}
Parametrul timeout=10 nu este o măsură de confort: un model produce regulat bucle infinite, iar fără această limită, campania dumneavoastră de evaluare se blochează la primul caz eșuat. De asemenea, amintiți-vă că executați cod pe care nu l-ați scris—în afara unui mediu de dezvoltare izolat, această funcție necesită un sandbox.
Rezumatul ilustrează un caz mixt, unde o parte a judecății este mecanică, iar alta nu. Lungimea este măsurabilă: raportul calculat penalizează simetric un rezumat prea scurt și unul prea lung, ceea ce evită trucul modelului de a copia textul sursă pentru a nu omite nimic. Fidelitatea, pe de altă parte, nu este măsurabilă printr-o regulă și revine judecătorului LLM, cu o întrebare directă despre informațiile inventate.
def evalua_rezumat(
text_original: str,
rezumat: str,
lungime_tinta: int = 100,
) -> dict:
"""Evaluează calitatea rezumatului."""
cuvinte_rezumat = len(rezumat.split())
raport_lungime = min(
cuvinte_rezumat / lungime_tinta,
lungime_tinta / max(cuvinte_rezumat, 1),
)
# Fidelitate prin LLM
response = client.responses.create(
model="gpt-5.6-terra",
input=(
f"Este următorul rezumat fidel textului original? "
f"Conține informații inventate?\n\n"
f"Text original (extras) : {text_original[:2000]}\n\n"
f"Rezumat : {rezumat}\n\n"
f"Răspundeți în JSON cu cheile : fidelitate (0-5), "
f"halucinatii (da/nu), comentariu (scurt)."
),
temperature=0.0,
)
try:
fidelitate = json.loads(response.output_text)
except json.JSONDecodeError:
fidelitate = {"fidelitate": 0, "halucinatii": "necunoscut"}
return {
"scor_lungime": raport_lungime,
"scor_fidelitate": fidelitate.get("fidelitate", 0) / 5.0,
"halucinatii": fidelitate.get("halucinatii", "necunoscut"),
"cuvinte_rezumat": cuvinte_rezumat,
"lungime_tinta": lungime_tinta,
}
Faceți evaluarea repetabilă
O evaluare pe care o rulați manual în mod repetat va ajunge în cele din urmă să nu mai fie rulată deloc. Pipeline-ul încapsulează grila și păstrează un istoric al campaniilor, transformând o măsurătoare unică într-o serie temporală: vedeți că scorul mediu a scăzut de la 0,81 la 0,79 după modificarea promptului de marți, informație pe care nicio execuție izolată nu v-ar fi putut-o oferi.
class PipelineEval:
"""Pipeline de evaluare reutilizabil."""
def __init__(self, nume: str, grila: Grila):
self.nume = nume
self.grila = grila
self.istoric: list[dict] = []
def evalua_lot(
self,
dataset: list[dict],
model: str,
prompt_sistem: str,
) -> dict:
"""Evaluează un lot complet și returnează metricile."""
rezultate = []
for caz in dataset:
response = client.responses.create(
model=model,
instructions=prompt_sistem,
input=caz["input"],
)
eval_rezultat = evalua_multi_criterii(
caz["input"],
response.output_text,
self.grila,
)
rezultate.append(eval_rezultat)
scoruri = [r["scor_global"] pentru r in rezultate]
raport = {
"pipeline": self.nume,
"model": model,
"nr_cazuri": len(dataset),
"scor_mediu": sum(scoruri) / len(scoruri),
"scor_min": min(scoruri),
"scor_max": max(scoruri),
}
self.istoric.append(raport)
return raport
Un sfat pentru început: construiți prima dumneavoastră grilă pe doar douăzeci de cazuri, faceți-o notată în paralel de judecătorul LLM și de un expert în domeniu, apoi comparați cele două serii. Discrepanțele vă vor spune care criterii sunt descrise prost mult înainte de a vă spune ceva despre calitatea modelului.
Puncte cheie
- Creați grile de evaluare specifice domeniului dumneavoastră de activitate, cu ponderi explicite
- Verificați ca suma ponderilor să rămână la 1 pe măsură ce grila evoluează
- Combinați evaluarea automatizată (cod, lungime) și LLM-as-Judge (calitate)
- Testați codul generat executându-l, cu un timeout și într-un mediu izolat
- Construiți un pipeline reutilizabil care păstrează un istoric al campaniilor