Samodejno vrednotenje pozivov
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.
Samodejno vrednotenje pozivov
Samodejno vrednotenje je temelj zrelega procesa inženiringa pozivov. Omogoča ti odkrivanje regresij, primerjavo modelov in validacijo sprememb pred uvedbo v proizvodno okolje. Brez njega je vsaka sprememba poziva slepa stava.
Vrste vrednotenja
Tri družine evalvatorjev si delijo delo glede na naravo pričakovanega izhoda in skoraj vedno boš kombiniral več njih.
Vrednotenje z natančnim ujemanjem (Exact Match)
Za naloge z enim samim pričakovanim odgovorom zadostuje neposredna primerjava. eval_exact_match pred primerjavo normalizira velike in male črke ter presledke: brez tega previdnostnega ukrepa bi „Bug” in „bug” štela za napako, kar bi te poslalo popravljati težavo, ki ne obstaja.
eval_set_match obravnava primere, kjer je odgovor množica – entitete, najdene v dokumentu, ali kategorije, dodeljene članku. Izpelje natančnost (precision) in priklic (recall), dve številki, ki pripovedujeta različni zgodbi: visoka natančnost z nizkim priklicem signalizira preveč previden model, ki izvleče le tisto, kar je gotov; obratno razkriva model, ki halucinira, da bi zapolnil vrzeli. F1 ju priročno povzame, a ju ne nadomešča pri diagnostiki.
def eval_exact_match(prediction: str, reference: str) -> bool:
"""Natančno ujemanje po normalizaciji."""
return prediction.strip().lower() == reference.strip().lower()
def eval_set_match(prediction: set, reference: set) -> dict:
"""Ujemanje množic (entitete, kategorije)."""
tp = len(prediction & reference)
fp = len(prediction - reference)
fn = len(reference - prediction)
precision = tp / (tp + fp) if (tp + fp) > 0 else 0
recall = tp / (tp + fn) if (tp + fn) > 0 else 0
f1 = (2 * precision * recall / (precision + recall)
if (precision + recall) > 0 else 0)
return {"precision": precision, "recall": recall, "f1": f1}
Semantično vrednotenje (Vdelave/Embedding)
Za besedilne odgovore, kjer se lahko formulacija spreminja, postane natančno ujemanje absurdno: „Vaše naročilo bo dostavljeno jutri” in „Dostava je načrtovana za jutri” pomenita isto, a bi dobila oceno nič. Kosinusna podobnost med vdelavami (embeddings) meri semantično bližino namesto ujemanja znakov in vrača zvezno oceno.
Nastaviš prag, nad katerim se odgovor šteje za sprejemljiv. Umeri ga na nekaj ducatih parih, ki si jih ročno razvrstil kot „enakovredne” ali „različne”, nato izberi vrednost, ki najbolje loči obe skupini: prag, izbran po občutku, proizvede rezultate, ki so prav tako poljubni kot brez merjenja, z dodano iluzijo strogosti.
from openai import OpenAI
import numpy as np
client = OpenAI()
def eval_semantic_similarity(prediction: str,
reference: str) -> float:
"""Kosinusna podobnost med vdelavami."""
response = client.embeddings.create(
model="text-embedding-3-large",
input=[prediction, reference]
)
emb_pred = np.array(response.data[0].embedding)
emb_ref = np.array(response.data[1].embedding)
similarity = float(
np.dot(emb_pred, emb_ref) /
(np.linalg.norm(emb_pred) * np.linalg.norm(emb_ref))
)
return similarity
Vrednotenje z LLM (LLM-as-Judge)
Model oceni kakovost odgovora. To je edini izvedljiv pristop, ko referenca ne obstaja: nihče ne bo ročno napisal „pravilnega” odgovora podpore za dvesto kartic.
Uporabnost sodnika je odvisna od nekaj dejavnikov. Prvič, uporabljeni model: izbereš zmogljivejši model kot sodnika, tukaj gpt-5.6-sol, saj sodnik na isti ravni kot ocenjevanec pogosto potrdi lastne napake. Drugič, zahteva po utemeljitvi: motiviranje vsake ocene stabilizira presojo in ti omogoča, da opaziš evalvatorja, ki uporablja napačno merilo – utemeljitev, ki razpravlja o dolžini, ko je bilo merilo jasnost, je rdeča zastavica. Končno, temperature na 0,1 zagotavlja stabilnost ocen med različnimi zagoni.
def eval_llm_judge(question: str, prediction: str,
criteria: list[str]) -> dict:
"""Vrednotenje s strani sodniškega modela."""
criteria_text = "\n".join(
f"- {c}: ocena od 1 do 5" for c in criteria
)
response = client.responses.create(
model="gpt-5.6-sol", # Zmogljivejši model kot sodnik
reasoning={"effort": "none"}, # temperature zahteva effort none
instructions="Si strokovni, nepristranski evalvator.",
input=f"""Oceni ta odgovor glede na naslednja merila:
Postavljeno vprašanje: {question}
Odgovor za oceno: {prediction}
Merila:
{criteria_text}
Za vsako merilo dodeli oceno od 1 do 5 z utemeljitvijo.""",
text={
"format": {
"type": "json_schema",
"name": "evaluation",
"schema": {
"type": "object",
"properties": {
"scores": {
"type": "array",
"items": {
"type": "object",
"properties": {
"criterion": {"type": "string"},
"score": {"type": "integer"},
"justification": {"type": "string"}
},
"required": ["criterion", "score",
"justification"],
"additionalProperties": False
}
},
"overall_score": {"type": "number"},
"verdict": {"type": "string"}
},
"required": ["scores", "overall_score", "verdict"],
"additionalProperties": False
},
"strict": True
}
},
temperature=0.1
)
return json.loads(response.output_text)
Celoten cevovod za vrednotenje
EvalPipeline združuje te gradnike: naloži testni niz, zažene poziv za vsak primer, uporabi vse podane evalvatorje in agregira ocene. Evalvatorji so podani kot seznam funkcij, vse klicane z istim podpisom; dodajanje metrike zato ne zahteva spremembe cevovoda, na istem izvajanju pa lahko zaženeš natančno ujemanje, semantično podobnost in sodnika, ne da bi trikrat plačal generiranje.
Metoda summary prav tako akumulira porabljene žetone. Ta navidezno stranska vrstica te ščiti pred pogosto pastjo: različica poziva, ki pridobi dve točki ocene, a potroji račun, ni nujno prava izbira, in bolje je, da to spoznaš ob času kompromisov, kot ko prispe mesečni račun.
import json
from dataclasses import dataclass
from pathlib import Path
@dataclass
class TestCase:
"""Testni primer za vrednotenje."""
input_text: str
expected_output: str = None
metadata: dict = None
class EvalPipeline:
"""Samodejni cevovod za vrednotenje."""
def __init__(self, test_suite_path: str):
"""Naloži testni niz iz datoteke JSON."""
data = json.loads(Path(test_suite_path).read_text())
self.test_cases = [TestCase(**tc) for tc in data]
self.results = []
def run(self, prompt_config: dict,
evaluators: list[callable]) -> dict:
"""Zažene vse teste in ovrednoti rezultate."""
self.results = []
for tc in self.test_cases:
# Generiraj odgovor
response = client.responses.create(
model=prompt_config["model"],
reasoning={"effort": "none"}, # temperature zahteva effort none
instructions=prompt_config["system_prompt"],
input=tc.input_text,
temperature=prompt_config.get("temperature", 0.1)
)
prediction = response.output_text
# Ovrednoti z vsakim evalvatorjem
scores = {}
for evaluator in evaluators:
score = evaluator(
question=tc.input_text,
prediction=prediction,
reference=tc.expected_output
)
scores[evaluator.__name__] = score
self.results.append({
"input": tc.input_text,
"expected": tc.expected_output,
"prediction": prediction,
"scores": scores,
"tokens": {
"input": response.usage.input_tokens,
"output": response.usage.output_tokens
}
})
return self.summary()
def summary(self) -> dict:
"""Povzame rezultate vrednotenja."""
if not self.results:
return {"error": "Ni rezultatov"}
# Agregiraj ocene po evalvatorju
all_scores = {}
for result in self.results:
for eval_name, score in result["scores"].items():
if eval_name not in all_scores:
all_scores[eval_name] = []
if isinstance(score, (int, float)):
all_scores[eval_name].append(score)
elif isinstance(score, dict) and "f1" in score:
all_scores[eval_name].append(score["f1"])
summary = {
"total_tests": len(self.results),
"average_scores": {
name: sum(scores) / len(scores)
for name, scores in all_scores.items()
if scores
},
"total_token_cost": sum(
r["tokens"]["input"] + r["tokens"]["output"]
for r in self.results
)
}
return summary
Testni niz: Oblika
Oblika testnega niza ostaja namerno minimalna: vhod, pričakovani izhod in poljubni metapodatki. Ti metapodatki so koristnejši, kot se zdi – z označevanjem vsakega primera po kategoriji razčleniš ocene in odkriješ, da tvoj klasifikator ne odpoveduje naključno, ampak pri določeni družini zahtevkov, česar globalno povprečje 88 % ne razkrije. Trije spodnji primeri kažejo tudi, kaj bi moral vsebovati dober niz: jasne primere, kot je zrušitev ob zagonu, pa tudi primere, ki mejijo na drugo kategorijo – vprašanje o manjkajoči funkciji je zelo podobno poročilu o napaki in prav na tej meji se odloča o kakovosti klasifikatorja.
[
{
"input_text": "Moj paket še ni prispel",
"expected_output": "pritožba",
"metadata": {"category": "dostava"}
},
{
"input_text": "Kako vklopim temni način?",
"expected_output": "vprašanje",
"metadata": {"category": "funkcija"}
},
{
"input_text": "Aplikacija se zruši ob zagonu na iOS 18",
"expected_output": "napaka",
"metadata": {"category": "tehnično"}
}
]
Integracija CI/CD
Vrednotenje zaženi ob vsaki spremembi poziva. Funkcija ci_eval_check spremeni merjenje v varovalko: zažene cevovod, primerja povprečno oceno s pragom in vrne boolovo vrednost, ki jo tvoja integracijska veriga razume kot uspeh ali neuspeh gradnje. Sprememba, ki zniža natančnost pod 85 %, ne pride več v proizvodno okolje, prav tako kot pokvarjen enotski test blokira združitev.
Prag nastavi glede na oceno, ki jo je dosegla trenutna različica, ne glede na ideal. Če ga nastaviš previsoko, obsodiš ekipo na obhod preverjanja z začasnimi onemogočitvami, ki postanejo trajne; če prenizko, ne preverjaš ničesar, medtem ko prikazuješ zeleno značko. Končno imej v mislih, da mora niz ostati reprezentativen za realni promet: prag, dosežen na dvajsetih primerih, napisanih pred dvema letoma, ne dokazuje ničesar o današnjih zahtevkih.
def ci_eval_check(prompt_config: dict,
test_suite: str,
min_score: float = 0.85) -> bool:
"""Vrata CI/CD: preveri, ali poziv dosega minimalno oceno."""
pipeline = EvalPipeline(test_suite)
def accuracy(question, prediction, reference):
return 1.0 if prediction.strip().lower() == reference.strip().lower() else 0.0
results = pipeline.run(prompt_config, [accuracy])
avg_score = results["average_scores"].get("accuracy", 0)
print(f"Povprečna ocena: {avg_score:.2%}")
print(f"Najnižji prag: {min_score:.2%}")
if avg_score < min_score:
print("NEUSPEH: ocena pod pragom")
return False
print("USPEH: poziv validiran")
return True
Nadzorna plošča za vrednotenje
Sledi razvoju ocen skozi čas. Ena sama ocena ne pove nič; zaporedje pripoveduje zgodbo tvojega poziva in odgovarja na vprašanje, ki se vedno pojavi na sestankih: napredujemo? Spodnja funkcija ustvari tabelo Markdown, ki za vsako različico drug ob drugem postavi povprečno oceno, porabljene žetone in ocenjeni strošek. Oblika ni naključna: prilepi se neposredno v zahtevo za združitev (pull request), kar primerjavo naredi berljivo za ljudi, ki nikoli ne bodo odprli tvoje kode.
def comparison_report(results: dict[str, dict]) -> str:
"""Generira primerjalno poročilo med različicami pozivov."""
report = "# Primerjalno poročilo o vrednotenju\n\n"
report += "| Različica | Povprečna ocena | Povprečni žetoni | Strošek |\n"
report += "|---------|---------------|----------------|------|\n"
for version, data in results.items():
score = data.get("average_scores", {})
score_val = list(score.values())[0] if score else 0
tokens = data.get("total_token_cost", 0)
report += (f"| {version} | {score_val:.2%} | "
f"{tokens} | ${tokens * 5 / 1e6:.4f} |\n")
return report
Vzpostavi svoje varovalke
Zgradi niz dvajsetih testnih primerov za pravi poziv, pri čemer vključi peščico robnih primerov namesto dvajsetih udobnih primerov: niz, ki prvič prestane s 100 %, te ne nauči ničesar. Implementiraj tri vrste evalvatorjev in jih skupaj zaženi na dveh različicah svojega poziva. Natančno ujemanje da čisto številko, semantična podobnost ujame legitimne preoblikovanja, sodnik pa osvetli primere, kjer se prva dva ne strinjata – ta nesoglasja so najbolj bogata z lekcijami o tem, kaj dejansko pričakuješ od modela.
Primerjaj, identificiraj zmagovalno različico, nato nastavi skript CI, ki blokira uvedbo, če ocena pade. Sistem bo deloval tisti dan, ko bo zavrnil spremembo, za katero si mislil, da je očitna.
Ključne ugotovitve
- Samodejno vrednotenje je bistveno za iteracije z zaupanjem
- Po potrebi kombiniraj vrednotenje z natančnim ujemanjem, semantično vrednotenje in vrednotenje z LLM kot sodnikom
- Vzdržuj testni niz, ki se razvija s tvojo aplikacijo
- Vrednotenje integriraj v svoj CI/CD z najnižjim pragom
- Kot sodnika za ocenjevanje cenejšega modela uporabi zmogljivejši model
- Dokumentiraj ocene vsake različice za sledenje razvoju
Preveri svoje znanje
Napredne tehnike in industrializacija: končni preizkus.
1. Kaj vsebuje učinkovit sistemski poziv?
Odgovor: Vlogo, obseg, pravila obnašanja, format izhoda in obravnavo robnih primerov – zapisano kot specifikacija, testirano kot koda.
2. Kdaj bi moral uporabiti samodoslednost (self-consistency)?
Odgovor: Pri problemih razmišljanja z preverljivimi odgovori: generiraj več neodvisnih razmišljanj in obdrži odgovor večine – varianca postane zaveznik.
3. Kaj zagotavlja način JSON z uveljavljanjem sheme?
Odgovor: Izhod, ki strogo ustreza shemi (tipi, zahtevana polja, enumi) – validiran na strani API-ja in ponovno validiran v kodi (JSON Schema, Zod) za verigo brez presenečenj.
4. Kaj je utemeljevanje (grounding)?
Odgovor: Sidranje odgovorov v podanih dejstvih (dokumenti, pridobljeni podatki) namesto v spominu modela – z zahtevo po navajanju virov ali vzdržanju od zunanjih virov.
5. Kakšen je namen kataloga različic pozivov?
Odgovor: Obravnava pozivov kot artefaktov: različice, testi A/B, samodejna vrednotenja ob vsaki spremembi – veš, kaj teče v proizvodnem okolju in zakaj.
Zadnja zanka tečaja – različica, test, samodejno vrednotenje – spremeni obrtniški inženiring pozivov v timsko prakso.