Automātiskā uzvedņu novērtēšana
Šajā lapā
Nodarbība atjaunināta 2026. gada 3. novembrī, pamatojoties uz OpenAI dokumentāciju: parametri
temperatureuntop_ptiek pieņemti tikai ar spriešanas piepūli (reasoning effort) vērtībānone, savukārt GPT-5.6 modeļi pēc noklusējuma veic spriešanu (medium). Tādēļ izsaukumiem, kas iestata šos parametrus, ir jānorādareasoning={"effort": "none"}(Responses API) vaireasoning_effort="none"(Chat Completions). Avoti: Using GPT-6 · GPT-5.6 Terra.
Automātiskā uzvedņu novērtēšana
Automātiskā novērtēšana ir nobriedušas uzvedņu inženierijas cauruļvada stūrakmens. Tā ļauj tev atklāt regresijas, salīdzināt modeļus un validēt izmaiņas pirms izvietošanas. Bez tās katra uzvednes izmaiņa ir akls risks.
Novērtēšanas veidi
Trīs novērtētāju grupas sadala darbu atkarībā no sagaidāmās izvades rakstura, un tu gandrīz vienmēr apvienosi vairākus no tiem.
Precīzas atbilstības novērtēšana (Exact Match)
Uzdevumiem ar vienu paredzētu atbildi pietiek ar tiešu salīdzinājumu. eval_exact_match normalizē lielumu un atstarpes pirms salīdzināšanas: bez šīs piesardzības “Kļūda” un “kļūda” tiktu uzskatītas par kļūdu, liekot tev labot problēmu, kas nepastāv.
eval_set_match apstrādā gadījumus, kad atbilde ir kopa — dokumentā atrastās vienības, rakstam piešķirtās kategorijas. Tā aprēķina precizitāti un pilnīgumu (recall), divus rādītājus, kas stāsta dažādus stāstus: augsta precizitāte ar zemu pilnīgumu liecina par pārāk piesardzīgu modeli, kas izgūst tikai to, par ko ir pārliecināts; pretējais gadījums nodevīgi norāda uz modeli, kas halucinē, lai aizpildītu tukšumus. F1 rādītājs tos ērti apkopo, bet diagnozes noteikšanai tos neaizstāj.
def eval_exact_match(prediction: str, reference: str) -> bool:
"""Precīza atbilstība pēc normalizācijas."""
return prediction.strip().lower() == reference.strip().lower()
def eval_set_match(prediction: set, reference: set) -> dict:
"""Kopu atbilstība (vienības, kategorijas)."""
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}
Semantiskā novērtēšana (Iegulšana/Embedding)
Teksta atbildēm, kurās formulējums var atšķirties, precīza atbilstība kļūst absurda: “Jūsu pasūtījums tiks piegādāts rīt” un “Piegāde ir ieplānota uz rītdienu” saka to pašu, taču saņemtu nulles vērtējumu. Kosinus līdzība starp iegulšanām (embeddings) mēra semantisko tuvumu, nevis rakstzīmju sakritību, atgriežot nepārtrauktu vērtējumu.
Tu nosaki slieksni, virs kuras atbilde tiek uzskatīta par pieņemamu. Kalibrē to dažiem desmitiem pāru, kurus esi manuāli klasificējis kā “ekvivalentus” vai “atšķirīgus”, un izvēlies vērtību, kas vislabāk atdala abas grupas: slieksnis, kas izvēlēts pēc nojautas, rada tikpat patvaļīgus rezultātus kā jebkura mērījuma neesamība, tikai ar papildu rigorozitātes ilūziju.
from openai import OpenAI
import numpy as np
client = OpenAI()
def eval_semantic_similarity(prediction: str,
reference: str) -> float:
"""Kosinus līdzība starp iegulšanām."""
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
LLM novērtēšana (LLM kā tiesnesis)
Modelis novērtē atbildes kvalitāti. Tas ir vienīgais dzīvotspējīgais piegājiens, ja nav atsauces: neviens nerakstīs ar roku “pareizo” atbalsta atbildi diviem simtiem biļešu.
Lai tiesnesis būtu lietojams, ir svarīgi vairāki aspekti. Pirmkārt, izmantotais modelis: tu izvēlies spējīgāku modeli kā tiesnesi, šeit gpt-5.6-sol, jo tiesnesis tajā pašā līmenī kā vērtējamais mēdz apstiprināt paša trūkumus. Otrkārt, prasība pēc pamatojuma: katra vērtējuma motivēšana stabilizē spriedumu un ļauj pamanīt, ja novērtētājs izmanto nepareizu kritēriju — pamatojums, kas apspriež garumu, lai gan kritērijs bija skaidrība, ir brīdinājuma zīme. Visbeidzot, temperature iestatījums 0.1 nodrošina vērtējuma stabilitāti dažādos izpildes reizēs.
def eval_llm_judge(question: str, prediction: str,
criteria: list[str]) -> dict:
"""Novērtēšana, izmantojot tiesneša modeli."""
criteria_text = "\n".join(
f"- {c}: vērtējums no 1 līdz 5" for c in criteria
)
response = client.responses.create(
model="gpt-5.6-sol", # Spējīgāks modelis kā tiesnesis
reasoning={"effort": "none"}, # temperature prasa effort none
instructions="Tu esi eksperts, objektīvs novērtētājs.",
input=f"""Novērtē šo atbildi atbilstoši šādiem kritērijiem:
Uzdots jautājums: {question}
Novērtējamā atbilde: {prediction}
Kritēriji:
{criteria_text}
Katram kritērijam piešķir vērtējumu no 1 līdz 5 ar pamatojumu.""",
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)
Pilns novērtēšanas cauruļvads
EvalPipeline apvieno šos būvblokus: tas ielādē testu kopu, palaiž uzvedni katram gadījumam, pielieto visus nodrošinātos novērtētājus un apkopo rezultātus. Novērtētāji tiek padoti kā funkciju saraksts, visi tiek izsaukti ar vienādu signatūru; tādējādi metrikas pievienošana neprasa cauruļvada modificēšanu, un tu vari vienā izpildē palaist precīzu atbilstību, semantisko līdzību un tiesnesi, nemaksājot par ģenerēšanu trīs reizes.
Metode summary arī uzkrāj patērētos tokenus. Šī šķietami sekundārā rindiņa pasargā tevi no izplatīta slazda: uzvednes versija, kas iegūst divus punktus, bet trīskāršo rēķinu, ne vienmēr ir pareizā izvēle, un to ir labāk uzzināt kompromisu brīdī, nevis tad, kad pienāk ikmēneša rēķins.
import json
from dataclasses import dataclass
from pathlib import Path
@dataclass
class TestCase:
"""Testa gadījums novērtēšanai."""
input_text: str
expected_output: str = None
metadata: dict = None
class EvalPipeline:
"""Automātisks novērtēšanas cauruļvads."""
def __init__(self, test_suite_path: str):
"""Ielādē testu kopu no JSON faila."""
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:
"""Izpilda visus testus un novērtē rezultātus."""
self.results = []
for tc in self.test_cases:
# Ģenerē atbildi
response = client.responses.create(
model=prompt_config["model"],
reasoning={"effort": "none"}, # temperature prasa effort none
instructions=prompt_config["system_prompt"],
input=tc.input_text,
temperature=prompt_config.get("temperature", 0.1)
)
prediction = response.output_text
# Novērtē ar katru novērtētāju
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:
"""Apkopo novērtēšanas rezultātus."""
if not self.results:
return {"error": "Nav rezultātu"}
# Apvieno vērtējumus pēc novērtētāja
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
Testu kopas formāts
Testu kopas formāts ir apzināti minimālists: ievade, sagaidāmā izvade un brīvas formas metadati. Šie metadati ir noderīgāki, nekā šķiet — marķējot katru gadījumu pēc kategorijas, tu sadali vērtējumus un atklāj, ka tavs klasifikators neizdodas nejauši, bet gan konkrētā pieprasījumu saimē, ko globāls vidējais rādītājs 88% apmērā neatklāj. Trīs zemāk minētie piemēri arī parāda, kam jābūt labā kopā: skaidri gadījumi, piemēram, lietotnes avārija starta brīdī, bet arī gadījumi, kas robežojas ar citu kategoriju — jautājums par trūkstošu funkciju izskatās ļoti līdzīgs kļūdas ziņojumam, un tieši uz šīs robežas tiek izlemta klasifikatora kvalitāte.
[
{
"input_text": "Mana sūtījums nav ieradies",
"expected_output": "sūdzība",
"metadata": {"category": "piegāde"}
},
{
"input_text": "Kā ieslēgt tumšo režīmu?",
"expected_output": "jautājums",
"metadata": {"category": "funkcija"}
},
{
"input_text": "Lietotne avārijas režīmā startē uz iOS 18",
"expected_output": "kļūda",
"metadata": {"category": "tehniska"}
}
]
Integrācija CI/CD
Palaid novērtēšanu pie katras uzvednes izmaiņas. Funkcija ci_eval_check pārvērš mērījumus drošības barjerā: tā palaiž cauruļvadu, salīdzina vidējo vērtējumu ar slieksni un atgriež buļa vērtību, ko tavas integrācijas ķēde interpretē kā būves veiksmi vai neveiksmi. Izmaiņas, kas samazina precizitāti zem 85%, vairs nenonāk produkcijā, tieši tāpat kā bojāts vienību tests bloķē sapludināšanu.
Iestati slieksni, balstoties uz vērtējumu, ko jau sasniegusi pašreizējā versija, nevis uz ideālu. Iestatīsi to pārāk augstu, un tu nosodi komandu apiet pārbaudi ar pagaidu atspējojumiem, kas kļūst pastāvīgi; iestatīsi pārāk zemu, un tu neko nepārbaudīsi, tikai izrādīsi zaļu nozīmīti. Visbeidzot, paturi prātā, ka kopai jāpaliek reprezentatīvai attiecībā uz reālo satiksmi: slieksnis, kas sasniegts divdesmit gadījumos, kas uzrakstīti pirms diviem gadiem, nepierāda neko par šodienas pieprasījumiem.
def ci_eval_check(prompt_config: dict,
test_suite: str,
min_score: float = 0.85) -> bool:
"""CI/CD vārti: pārbauda, vai uzvedne sasniedz minimālo vērtējumu."""
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"Vidējais vērtējums: {avg_score:.2%}")
print(f"Minimālais slieksnis: {min_score:.2%}")
if avg_score < min_score:
print("NEVEIKSME: vērtējums zem sliekšņa")
return False
print("VEIKSME: uzvedne validēta")
return True
Novērtēšanas panelis
Izseko vērtējuma evolūciju laika gaitā. Viens vērtējums nepasaka neko; sērija stāsta tavas uzvednes stāstu un atbild uz jautājumu, kas vienmēr rodas sapulcēs: vai mēs virzāmies uz priekšu? Zemāk esošā funkcija ģenerē Markdown tabulu, kas blakus izvieto katras versijas vidējo vērtējumu, patērētos tokenus un aplēstās izmaksas. Formāts nav nejaušs: to var tieši ielīmēt vilkšanas pieprasījumā (pull request), padarot salīdzinājumu lasāmu cilvēkiem, kuri nekad neatvērs tavu kodu.
def comparison_report(results: dict[str, dict]) -> str:
"""Ģenerē salīdzinošu ziņojumu starp uzvedņu versijām."""
report = "# Salīdzinošs novērtēšanas ziņojums\n\n"
report += "| Versija | Vidējais vērtējums | Vidējie tokeni | Izmaksas |\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
Izveido savas drošības barjeras
Izveido divdesmit testu gadījumu kopu reālai uzvednei, iekļaujot dažus robežgadījumus, nevis divdesmit ērtus piemērus: kopa, kas pirmajā mēģinājumā iziet cauri ar 100%, tev neko nemāca. Implementē visus trīs novērtētāju veidus un palaid tos kopā divām uzvednes versijām. Precīza atbilstība dod tīru skaitli, semantiskā līdzība uztver likumīgu pārfrazēšanu, un tiesnesis izgaismo gadījumus, kur pirmie divi nesakrīt — šīs neatbilstības ir visbagātākās ar mācībām par to, ko tu patiesībā sagaidi no modeļa.
Salīdzini, identificē uzvarošo versiju, tad iestatiet CI skriptu, kas bloķē izvietošanu, ja vērtējums krītas. Tu zināsi, ka sistēma strādā tajā dienā, kad tā noraida izmaiņas, kuras tev šķita acīmredzamas.
Galvenās atziņas
- Automātiskā novērtēšana ir būtiska, lai iterētu ar pārliecību
- Pēc vajadzības apvieno precīzu, semantisku un LLM-kā-tiesnesis novērtēšanu
- Uzturi testu kopu, kas attīstās līdzīgi tavai lietotnei
- Integrē novērtēšanu savā CI/CD ar minimālo slieksni
- Izmanto spējīgāku modeli kā tiesnesi, lai novērtētu lētāku modeli
- Dokumentē katras versijas vērtējumus, lai izsekotu evolūciju
Pārbaudi savas zināšanas
Padziļinātas tehnikas un industrializācija: noslēdzošā pārbaude.
1. Ko satur efektīva sistēmas uzvedne?
Atbilde: Lomu, darbības jomu, uzvedības noteikumus, izvades formātu un robežgadījumu apstrādi — rakstītu kā specifikāciju, testētu kā kodu.
2. Kad jāizmanto paškonsekvence (self-consistency)?
Atbilde: Spriešanas uzdevumos ar pārbaudāmām atbildēm: ģenerē vairākus neatkarīgus spriešanas procesus un paturi vairākuma atbildi — variācija kļūst par sabiedroto.
3. Ko garantē JSON režīms ar shēmas piespiešanu?
Atbilde: Izvadi, kas stingri atbilst shēmai (tipi, obligātie lauki, enumi) — validētu API pusē un atkārtoti validētu kodā (JSON Schema, Zod), lai nodrošinātu ķēdi bez pārsteigumiem.
4. Kas ir pamatojums (grounding)?
Atbilde: Atbilžu enkurošana sniegtajos faktos (dokumentos, iegūtos datos), nevis modeļa atmiņā — ar prasību citēt vai atturēties no ārējiem avotiem.
5. Kāds ir versijēta uzvedņu kataloga mērķis?
Atbilde: Uztvert uzvednes kā artefaktus: versijas, A/B testi, automātiska novērtēšana pie katras izmaiņas — tu zini, kas darbojas produkcijā un kāpēc.
Kursa noslēdzošais cikls — versionē, testē, automātiski novērtē — pārvērš amatniecisku uzvedņu inženieriju komandas praksē.