Evaluați-vă prompturile: metode, evaluatori și migrarea către Promptfoo
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-ul Responses) saureasoning_effort="none"(Chat Completions). Surse: Utilizarea GPT-6 · GPT-5.6 Terra.
Actualizare 2 noiembrie 2026 — Platforma Evals. OpenAI a anunțat închiderea platformei sale Evals: evaluările existente sunt în mod read-only începând cu 31 octombrie 2026, iar tabloul de bord împreună cu API-ul se vor închide la 30 noiembrie 2026, inclusiv evaluatorii (graders). OpenAI a publicat un ghid de migrare către Promptfoo. Principiile de evaluare din această lecție rămân valabile; doar instrumentul se schimbă.
De ce trebuie să evaluați sistematic
Nu puteți îmbunătăți ceea ce nu măsurați. Când modificați un prompt, un model sau un parametru, cum știți că quality s-a îmbunătățit efectiv? Metoda spontană constă în a testa trei sau patru exemple, a le găsi pe cele mai bune și a le implementa. Aceasta eșuează frecvent deoarece exemplele testate sunt chiar cele care au cauzat probleme săptămâna trecută: măsurați îmbunătățirea acolo unde ați căutat-o și ratați regresiile introduse în cazurile care funcționau deja.
Evaluările (evals) transformă această intuiție într-o măsură obiectivă. Până în 2026, OpenAI oferea o platformă integrată pentru acest scop, Evals; aceasta este în mod read-only din 31 octombrie 2026 și se închide la 30 noiembrie. OpenAI recomandă acum Promptfoo, un instrument open-source pentru evaluare și red teaming. Vestea bună este că ambele share aceleași blocuri de construcție—date de test, prompturi, modele și criterii de scor. Ceea ce învățați aici în cod Python se traduce direct, iar partea finală a lecției prezintă trecerea la Promptfoo.
Trei concepte structurează întregul proces. Dataset-ul este un set de cazuri de test cu intrări și ieșiri așteptate: este referința dumneavoastră, echivalentul unei suite de teste unitare. Evaluatorul (grader) este un criteriu de evaluare—potrivire exactă, LLM-ca-judecător, scor—care decide dacă un răspuns dat este bun. Rularea (run) este o execuție de evaluare pe un dataset cu un model și un prompt specifice; este unitatea pe care o comparați de la o versiune la alta.
Construiți un dataset care reflectă lumea reală
Un caz de test constă într-o intrare, o ieșire așteptată și metadate. Acestea din urmă nu sunt decorative: ele sunt cele care vă vor permite să realizați, post-factum, că un scor global de 87% ascunde un colaps în categoria „cod“, compensat de rezultate excelente la geografie. Fără categorie sau dificultate, aveți doar un număr agregat, iar un număr agregat nu vă spune niciodată unde să interveniți.
import json
# Un dataset este o listă de cazuri de test
dataset = [
{
"input": "What is the capital of France?",
"expected": "Paris",
"metadata": {"category": "geography", "difficulty": "easy"},
},
{
"input": "Explain Bayes' theorem in one sentence.",
"expected": "Bayes' theorem calculates the probability "
"of an event based on known conditional probabilities.",
"metadata": {"category": "mathematics", "difficulty": "medium"},
},
{
"input": "Write a Python function that reverses a list.",
"expected": "def reverse_list(lst): return lst[::-1]",
"metadata": {"category": "code", "difficulty": "easy"},
},
]
# Salvați ca JSONL
with open("eval_dataset.jsonl", "w") as f:
for case in dataset:
f.write(json.dumps(case, ensure_ascii=False) + "\n")
Un dataset inventat la birou evaluează imaginația dumneavoastră, nu aplicația. Utilizatorii dumneavoastră formulează cererile diferit față de dumneavoastră: greșeli de tastare, întrebări incomplete, context implicit. Cea mai bună sursă de cazuri de test este, prin urmare, propriul dumneavoastră date de producție, cu condiția ca un om să valideze răspunsurile de referință—altfel, înghețați erorile curente ca normă.
import openai
import random
client = openai.OpenAI()
def create_dataset_from_logs(
production_logs: list[dict],
sample_size: int = 100,
) -> list[dict]:
"""Creează un dataset de evaluare din jurnalele de producție."""
# Eșantionare
sample = random.sample(
production_logs,
min(sample_size, len(production_logs)),
)
dataset = []
for log in sample:
dataset.append({
"input": log["prompt"],
"expected": log["validated_response"], # Răspuns validat de un om
"metadata": {
"source": "production",
"date": log["date"],
"original_model": log["model"],
},
})
return dataset
Alegeți evaluatorul (grader) potrivit
Evaluatorul de potrivire exactă (exact match) este cel mai strict și rapid. Se potrivește doar sarcinilor unde ieșirea este constrânsă: o clasificare în trei categorii, extragerea unui număr de factură, un răspuns da/nu. Folosit pe text liber, ar da zero unui răspuns perfect formulat diferit față de referință.
def exact_grader(response: str, expected: str) -> dict:
"""Evaluează dacă răspunsul se potrivește exact."""
score = 1.0 if response.strip().lower() == expected.strip().lower() else 0.0
return {"score": score, "type": "exact"}
Evaluatorul de incluziune relaxează constrângerea: verifică prezența cuvintelor-cheie așteptate și returnează un scor parțial. Acesta este instrumentul potrivit pentru răspunsuri care trebuie să acopere puncte obligatorii fără ca formularea să conteze—un răspuns de suport care trebuie să menționeze perioada de retragere și adresa de returnare, de exemplu. Slăbiciunea sa este bine cunoscută: un text care conține cuvintele potrivite într-o ordine absurdă ar obține un scor perfect.
def inclusion_grader(response: str, keywords: list[str]) -> dict:
"""Verifică dacă răspunsul conține cuvintele-cheie așteptate."""
response_lower = response.lower()
found = sum(1 for word in keywords if word.lower() in response_lower)
score = found / len(keywords) if keywords else 0.0
return {
"score": score,
"found": found,
"total": len(keywords),
"type": "inclusion",
}
Apoi există cel mai puternic: un alt LLM evaluează calitatea răspunsului. Evaluatorul LLM-as-Judge apreciază ceea ce nicio regulă mecanică nu poate—claritatea, completitudinea, acuratețea tonului. Două detalii de implementare îl fac practic. În primul rând, temperature=0.0: fără aceasta, același judecător ar atribui scoruri diferite aceluiași răspuns de la o rulare la alta, iar benchmark-ul dumneavoastră și-ar pierde toată valoarea comparativă. În al doilea rând, fallback-ul pentru json.JSONDecodeError: un judecător care comentează în loc să returneze JSON nu ar trebui să blocheze întreaga campanie.
def llm_judge_grader(
question: str,
response: str,
expected: str,
criteria: str = "accuracy, completeness, clarity",
) -> dict:
"""Folosește un LLM pentru a evalua calitatea răspunsului."""
judge_prompt = f"""Rate the quality of this response on a scale of 1 to 5.
Question: {question}
Expected Response: {expected}
Response to Evaluate: {response}
Criteria: {criteria}
Respond ONLY with JSON:
{{"score": <1-5>, "justification": "<short explanation>"}}"""
response_obj = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=judge_prompt,
temperature=0.0,
)
import json
try:
result = json.loads(response_obj.output_text)
result["normalized_score"] = result["score"] / 5.0
return result
except json.JSONDecodeError:
return {"score": 0, "justification": "Parsing error", "normalized_score": 0}
Asamblați evaluarea completă
Orchestrarea nu prezintă nicio dificultate conceptuală: iterați prin dataset, apelați modelul cu promptul de sistem de testat, aplicați evaluatorul și agregați. Punctul interesant este că funcția de scor vine ca parametru, ceea ce vă permite să reluați exact același dataset cu criterii diferite în funcție de campanie—incluziune pentru o verificare rapidă în timpul dezvoltării, judecător LLM pentru validare înainte de producție.
async def run_eval(
dataset: list[dict],
model: str,
system_prompt: str,
grader_fn,
) -> dict:
"""Rulează o evaluare completă pe un dataset."""
results = []
for case in dataset:
response = client.responses.create(
model=model,
instructions=system_prompt,
input=case["input"],
)
score = grader_fn(response.output_text, case["expected"])
results.append({
"input": case["input"],
"expected": case["expected"],
"obtained": response.output_text,
**score,
})
# Calculați metricile agregate
scores = [r["score"] for r in results if "score" in r]
return {
"model": model,
"num_cases": len(dataset),
"average_score": sum(scores) / len(scores) if scores else 0,
"min_score": min(scores) if scores else 0,
"max_score": max(scores) if scores else 0,
"results": results,
}
Raportul păstrează min_score și detaliul fiecărui caz, și asta este deliberat. Media vă spune dacă avansați; cazurile cu cel mai slab scor vă spun de ce. Faceți-vă un obicei din a citi cele cinci răspunsuri cu cel mai slab scor din fiecare rulare înainte de a comenta media: acolo, și rareori altundeva, veți găsi următoarea remediere de făcut.
Industrializați cu Promptfoo
Scrierea evaluărilor dumneavoastră manual în Python este educativă; menținerea lor în timp este mai confortabilă cu un instrument dedicat. Ghidul de migrare al OpenAI descrie logica Promptfoo: evaluarea trăiește într-un fișier de configurație, promptfooconfig.yaml, care reunește prompturi, model(e), cazuri de test și criterii—numite aici afirmații (assertions). Rulează din linia de comandă, local sau în integrarea continuă, și trăiește alături de codul aplicației.
description: Support ticket classification
prompts:
- "Classify this ticket into a single category (billing, technical, account): {{ticket}}"
providers:
- openai:gpt-6.1-sol
tests:
- vars:
ticket: "My card was charged twice this month."
assert:
- type: icontains
value: billing
- vars:
ticket: "The app crashes when I open a PDF."
assert:
- type: icontains
value: technical
promptfoo eval -c promptfooconfig.yaml --no-cache
promptfoo view
promptfoo validate config -c promptfooconfig.yaml # in case of configuration error
Evaluatorii din această lecție reapar ca afirmații: potrivire exactă, incluziune de cuvinte-cheie și judecata modelului. OpenAI avertizează asupra ultimului punct: un evaluator recreat, în special un judecător LLM, trebuie revalidat înainte de a fi folosit pentru a decide asupra unei regresii, deoarece scorurile nu vor fi neapărat identice de la un instrument la altul.
Puncte cheie
- Evals transformă intuiția într-o măsură obiectivă a calității
- Creați-vă dataset-urile din cazuri reale de producție, validate de un om
- Alegeți evaluatorul în funcție de sarcină: exact pentru constrângeri, incluziune pentru puncte obligatorii, LLM-as-Judge pentru nuanțe
- Setați
temperature=0.0la judecător pentru a face scorurile reproductibile - Rulați evals înainte de fiecare modificare de prompt sau model
- Platforma Evals a OpenAI se închide la 30 noiembrie 2026: Promptfoo, recomandat de OpenAI, preia dataset-urile, prompturile, modelele și criteriile într-un fișier de configurație