Oceni svoje pozive: metode, ocenjevalci in selitev na Promptfoo
Na tej strani
Lekcija posodobljena 3. novembra 2026 na podlagi dokumentacije OpenAI: parametra
temperatureintop_psta sprejeta le pri naporu razmišljanja (reasoning effort) vrednostinone, medtem ko modeli GPT-5.6 privzeto razmišljajo (medium). Klici, ki nastavljajo te parametre, morajo zato določitireasoning={"effort": "none"}(Responses API) alireasoning_effort="none"(Chat Completions). Viri: Uporaba GPT-6 · GPT-5.6 Terra.
Posodobitev 2. novembra 2026 — Platforma Evals. OpenAI je napovedal konec svoje platforme Evals: obstoječa ocenjevanja so samo za branje od 31. oktobra 2026, nadzorna plošča in API pa se bosta zaprla 30. novembra 2026, vključno z ocenjevalci. OpenAI je objavil vodnik za selitev na Promptfoo. Načela ocenjevanja v tej lekciji ostajajo veljavna; spreminja se le orodje.
Zakaj moraš sistematično ocenjevati
Ne moreš izboljšati tega, česar ne meriš. Ko spremeniš poziv, model ali parameter, kako veš, da se je kakovost dejansko izboljšala? Spontana metoda je preizkusiti tri ali štiri primere, poiskati boljše odgovore in jih uvesti v proizvodnjo. To redno odpove, ker so testirani primeri ravno tisti, ki so prejšnji teden povzročali težave: izboljšavo meriš tam, kjer si jo iskal, spregledaš pa regresije, uvedene v primerih, ki so že delovali.
Ocenjevanja (evals) to intuicijo spremenijo v objektivno merilo. Do leta 2026 je OpenAI za to ponujal integrirano platformo Evals; ta je od 31. oktobra 2026 samo za branje in se 30. novembra zapira. OpenAI zdaj priporoča Promptfoo, odprtokodno orodje za ocenjevanje in testiranje odpornosti (red teaming). Dobra novica je, da si obe orodji delita iste gradnike – testne podatke, pozive, modele in merila točkovanja. Kar se tu naučiš v kodi Python, lahko neposredno preneseš, zadnji del lekcije pa prikazuje selitev na Promptfoo.
Celoten proces strukturirajo trije koncepti. Nabor podatkov (dataset) je niz testnih primerov z vhodi in pričakovanimi izhodi: to je tvoja referenca, ekvivalent niza enotskih testov. Ocenjevalec (grader) je merilo ocenjevanja – točno ujemanje, LLM kot sodnik, točkovanje – ki odloči, ali je dani odgovor dober. Zagon (run) je izvedba ocenjevanja na naboru podatkov z določenim modelom in pozivom; to je enota, ki jo primerjaš med različicami.
Izgradi nabor podatkov, ki odraža tvojo realnost
Testni primer sestavljajo vhod, pričakovani izhod in metapodatki. Slednji niso okrasni: omogočajo ti, da naknadno ugotoviš, da skupna ocena 87 % skriva zlom v kategoriji „koda”, ki ga kompenzirajo odlični rezultati v geografiji. Brez kategorije ali težavnosti imaš le agregirano številko, agregirana številka pa ti nikoli ne pove, kje moraš poseči.
import json
# A dataset is a list of test cases
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"},
},
]
# Save as JSONL
with open("eval_dataset.jsonl", "w") as f:
for case in dataset:
f.write(json.dumps(case, ensure_ascii=False) + "\n")
Nabor podatkov, izmišljen v pisarni, ocenjuje tvojo domišljijo, ne tvoje aplikacije. Tvoji uporabniki svoje zahteve oblikujejo drugače kot ti: tipkarske napake, nedokončana vprašanja, implicitni kontekst. Najboljši vir testnih primerov so zato tvoji lastni proizvodni podatki, pod pogojem, da referenčne odgovore potrdi človek – sicer zamrzneš trenutne napake kot normo.
import openai
import random
client = openai.OpenAI()
def create_dataset_from_logs(
production_logs: list[dict],
sample_size: int = 100,
) -> list[dict]:
"""Creates an evaluation dataset from production logs."""
# Sample
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"], # Response validated by a human
"metadata": {
"source": "production",
"date": log["date"],
"original_model": log["model"],
},
})
return dataset
Izberi pravega ocenjevalca
Ocenjevalec za točno ujemanje je najstrožji in najhitrejši. Ustrezen je le za naloge, kjer je izhod omejen: klasifikacija v tri kategorije, ekstrakcija številke računa, odgovor da/ne. Če ga uporabiš na prostem besedilu, bi popolnoma pravilnemu odgovoru, ki je le drugače formuliran kot referenca, dodelil ničlo.
def exact_grader(response: str, expected: str) -> dict:
"""Evaluates if the response matches exactly."""
score = 1.0 if response.strip().lower() == expected.strip().lower() else 0.0
return {"score": score, "type": "exact"}
Ocenjevalec za vključitev omili omejitev: preveri prisotnost pričakovanih ključnih besed in vrne delno oceno. To je pravo orodje za odgovore, ki morajo pokriti obvezne točke, ne da bi bila formulacija pomembna – na primer odgovor podpore, ki mora omeniti rok za odstop in naslov za vračilo. Njegova šibkost je dobro znana: besedilo, ki vsebuje prave besede v absurdnem vrstnem redu, bi dobilo popolno oceno.
def inclusion_grader(response: str, keywords: list[str]) -> dict:
"""Checks that the response contains the expected keywords."""
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",
}
Nato tu je še najzmogljivejši: drug LLM oceni kakovost odgovora. Ocenjevalec LLM-as-Judge ceni tisto, česar nobeno mehansko pravilo ne more – jasnost, popolnost, ustreznost tona. Dve podrobnosti pri implementaciji ga naredita uporabnega. Prvič, temperature=0.0: brez tega bi isti sodnik istemu odgovoru od zagona do zagona dodelil različne ocene in tvoja merila bi izgubila vso primerjalno vrednost. Drugič, rezervna možnost za json.JSONDecodeError: sodnik, ki namesto JSON-a vrne komentar, ne sme sesuti celotne kampanje.
def llm_judge_grader(
question: str,
response: str,
expected: str,
criteria: str = "accuracy, completeness, clarity",
) -> dict:
"""Uses an LLM to evaluate response quality."""
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}
Sestavi popolno ocenjevanje
Orkestracija ne predstavlja konceptualne težave: iteriraš skozi nabor podatkov, pokličeš model s sistemskim pozivom za testiranje, uporabiš ocenjevalca in agregiraš rezultate. Zanimiva točka je, da funkcija za točkovanje pride kot parameter, kar ti omogoča, da isti nabor podatkov ponovno zaženeš z različnimi merili glede na kampanjo – vključitev za hiter pregled med razvojem, sodnik LLM za validacijo pred proizvodnjo.
async def run_eval(
dataset: list[dict],
model: str,
system_prompt: str,
grader_fn,
) -> dict:
"""Runs a full evaluation on a 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,
})
# Calculate aggregated metrics
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,
}
Poročilo ohranja min_score in podrobnosti vsakega primera, in to namensko. Povprečje ti pove, ali napreduješ; primeri z najslabšo oceno ti povedo, zakaj. Naj bo tvoja navada, da pred komentiranjem povprečja prebereš pet najslabših odgovorov iz vsakega zagona: tam, in redko kje drugje, boš našel naslednji popravek, ki ga moraš izvesti.
Industrializiraj s Promptfoo
Ročno pisanje ocenjevanj v Pythonu je poučno; njihovo vzdrževanje skozi čas je udobnejše z namenskim orodjem. Vodnik OpenAI za selitev opisuje logiko Promptfoo: ocenjevanje živi v konfiguracijski datoteki promptfooconfig.yaml, ki združuje pozive, model(e), testne primere in merila – tu imenovana trditve (assertions). Zažene se iz ukazne vrstice, lokalno ali v tvojem neprekinjenem integracijskem procesu, in sobiva s kodo aplikacije.
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
Ocenjevalci iz te lekcije se ponovno pojavijo kot trditve: točno ujemanje, vključitev ključnih besed in sodba modela. OpenAI opozarja na zadnjo točko: na novo ustvarjen ocenjevalec, zlasti sodnik LLM, mora biti pred uporabo za odločanje o regresiji ponovno validiran, saj ocene med orodji ne bodo nujno identične.
Ključne ugotovitve
- Ocenjevanja (evals) spremenijo intuicijo v objektivno merilo kakovosti
- Svoje nabore podatkov ustvari iz realnih proizvodnih primerov, ki jih potrdi človek
- Ocenjevalca izberi glede na nalogo: točno za omejene izhode, vključitev za obvezne točke, LLM-as-Judge za nianse
- Pri sodniku nastavi
temperature=0.0, da so ocene ponovljive - Ocenjevanja zaženi pred vsako spremembo poziva ali modela
- Platforma Evals podjetja OpenAI se zapre 30. novembra 2026: Promptfoo, ki ga priporoča OpenAI, prevzame nabore podatkov, pozive, modele in merila v konfiguracijski datoteki