Salt la conținutul principal
Română— Alege o limbă
Meniu

Crearea evaluărilor personalizate

Lecția 16 din 20 Actualizată 3 noiembrie 2026 Avansat
Pe această pagină
  1. Adaptați evaluările la domeniul dumneavoastră
  2. Traduceți o cerință de business într-o grilă de evaluare
  3. Când mașina judecă mai bine decât omul
  4. Faceți evaluarea repetabilă
  5. Puncte cheie

Lecție actualizată la 3 noiembrie 2026 pe baza documentației OpenAI: parametrii temperature și top_p sunt acceptați doar cu un efort de raționament de none, în timp ce modelele GPT-5.6 raționează implicit (medium). Apelurile care setează acești parametri trebuie, prin urmare, să specifice reasoning={"effort": "none"} (API Responses) sau reasoning_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