Automatiséltas promptų vertinimas
Šiame puslapyje
Pamoka atnaujinta 2026 m. lapkričio 3 d. pagal OpenAI dokumentaciją: parametrai
temperatureirtop_ppriimami tik esantnonelygio samprotavimui, tuo tarpu GPT-5.6 modeliai pagal nutylėjimą samprotauja (medium). Todėl kvietimuose, kuriuose nustatomi šie parametrai, būtina nurodytireasoning={"effort": "none"}(Responses API) arbareasoning_effort="none"(Chat Completions). Šaltiniai: Using GPT-6 · GPT-5.6 Terra.
Automatiséltas promptų vertinimas
Automatinis vertinimas yra brandaus promptų inžinerijos proceso kertinis akmuo. Jis leidžia aptikti regresijas, lyginti modelius ir patvirtinti pakeitimus prieš diegiant. Be jo kiekvienas prompto pakeitimas tampa aklu lošimu.
Vertinimo tipai
Yra trys vertintojų šeimos, kurios pasiskirsto darbą priklausomai nuo tikėtinos išvesties pobūdžio, ir beveik visada jas derinsi tarpusavyje.
Tikslaus atitikimo vertinimas (Exact Match)
Užduotims, turinčioms vieną teisingą atsakymą, pakanka tiesioginio palyginimo. eval_exact_match prieš lyginimą normalizuoja raidžių dydį ir tarpus: be šios atsargumo priemonės „Bug“ ir „bug“ būtų laikomi klaida, ir gaištum laiką taisydami problemą, kurios iš tikrųjų nėra.
eval_set_match tvarko atvejus, kai atsakymas yra aibė – dokumente rastos entitetų grupės arba straipsniui priskirtos kategorijos. Ji apskaičiuoja tikslumą (precision) ir išsamumą (recall) – du rodiklius, pasakojančius skirtingas istorijas: didelis tikslumas esant mažam išsamumui rodo pernelyg atsargų modelį, kuris ištraukia tik tai, dėl ko yra visiškai tikras; priešingas atvejis išduoda modelį, kuris haliucinuoja, kad užpildytų spragas. F1 balas juos patogiai apibendrina, tačiau diagnozuojant jų nepakeičia.
def eval_exact_match(prediction: str, reference: str) -> bool:
"""Tikslus atitikimas po normalizavimo."""
return prediction.strip().lower() == reference.strip().lower()
def eval_set_match(prediction: set, reference: set) -> dict:
"""Aibių atitikimas (entitetai, kategorijos)."""
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}
Semantinis vertinimas (Embedding)
Tekstiniams atsakymams, kuriuose formuluotės gali skirtis, tikslus atitikimas tampa beprasmis: „Jūsų užsakymas bus pristatytas rytoj“ ir „Pristatymas suplanuotas rytoj“ reiškia tą patį, tačiau gautų nulį balų. Kosinusinis panašumas tarp įterpinių (embeddings) matuoja semantinį artumą, o ne simbolių sutapimą, ir grąžina tęstinį balą.
Nustatai slenkstį, viršijantį kurį atsakymas laikomas priimtinu. Sureguliuok jį pagal kelias dešimtis porų, kurias rankiniu būdu klasifikavai kaip „ekvivalentiškas“ arba „skirtingas“, tada pasirink reikšmę, geriausiai atskiriančią šias dvi grupes: slenkstis, parinktas „iš nuojautos“, duoda tokius pat savavališkus rezultatus kaip ir jokio matavimo nebuvimas, tik su papildoma griežtumo iliuzija.
from openai import OpenAI
import numpy as np
client = OpenAI()
def eval_semantic_similarity(prediction: str,
reference: str) -> float:
"""Kosinusinis panašumas tarp įterpinių."""
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 vertinimas (LLM-as-Judge)
Modelis įvertina atsakymo kokybę. Tai vienintelis tinkamas būdas, kai nėra etaloninio atsakymo: niekas nerašys rankiniu būdu „teisingo“ palaikymo atsakymo dviem šimtams bilietų.
Kad vertintojas būtų naudojamas, svarbu keletas dalykų. Pirma, naudojamas modelis: kaip vertintoją pasirenki pajėgesnį modelį, čia gpt-5.6-sol, nes tos pačios klasės vertintojas linkęs pateisinti savo paties trūkumus. Antra, reikalavimas pagrįsti: kiekvieno balo motyvavimas stabilizuoja vertinimą ir leidžia pastebėti, kai vertintojas taiko neteisingą kriterijų – jei kriterijus buvo aiškumas, o pagrindime kalbama apie ilgį, tai raudona vėliava. Galiausiai, temperature nustatymas ties 0.1 užtikrina balų stabilumą tarp paleidimų.
def eval_llm_judge(question: str, prediction: str,
criteria: list[str]) -> dict:
"""Vertinimas naudojant vertintojo modelį."""
criteria_text = "\n".join(
f"- {c}: balas nuo 1 iki 5" for c in criteria
)
response = client.responses.create(
model="gpt-5.6-sol", # Pajėgesnis modelis kaip vertintojas
reasoning={"effort": "none"}, # temperature reikalauja effort none
instructions="Esi ekspertas, nešališkas vertintojas.",
input=f"""Įvertink šį atsakymą pagal šiuos kriterijus:
Užduotas klausimas: {question}
Vertinamas atsakymas: {prediction}
Kriterijai:
{criteria_text}
Kiekvienam kriterijui suteik balą nuo 1 iki 5 su pagrindimu.""",
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)
Pilna vertinimo grandinė
EvalPipeline sujungia šiuos statybinius blokus: ji įkelia testų rinkinį, paleidžia promptą kiekvienu atveju, taiko visus pateiktus vertintojus ir agreguoja balus. Vertintojai perduodami kaip funkcijų sąrašas, visi kviečiami su tuo pačiu parašu; todėl naujo metrikos pridėjimas nereikalauja grandinės modifikacijos, ir gali vienu vykdymu paleisti tikslų atitikimą, semantinį panašumą bei vertintoją, nemokėdamas už generavimą tris kartus.
Metodas summary taip pat kaupia sunaudotus tokenus. Ši iš pirmo žvilgsnio antraeilė eilutė apsaugo tave nuo dažnos spąstų: prompto versija, kuri gauna dviem balais daugiau, bet trigubina sąskaitą, nebūtinai yra tinkamas pasirinkimas, ir geriau tai suprasti prekybos offais metu nei gavus mėnesio sąskaitą.
import json
from dataclasses import dataclass
from pathlib import Path
@dataclass
class TestCase:
"""Testo atvejis vertinimui."""
input_text: str
expected_output: str = None
metadata: dict = None
class EvalPipeline:
"""Automatinė vertinimo grandinė."""
def __init__(self, test_suite_path: str):
"""Įkelia testų rinkinį iš JSON failo."""
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:
"""Paleidžia visus testus ir įvertina rezultatus."""
self.results = []
for tc in self.test_cases:
# Generuoti atsakymą
response = client.responses.create(
model=prompt_config["model"],
reasoning={"effort": "none"}, # temperature reikalauja effort none
instructions=prompt_config["system_prompt"],
input=tc.input_text,
temperature=prompt_config.get("temperature", 0.1)
)
prediction = response.output_text
# Vertinti su kiekvienu vertintoju
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:
"""Apibendrina vertinimo rezultatus."""
if not self.results:
return {"error": "Nėra rezultatų"}
# Agreguoti balus pagal vertintoją
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
Testų rinkinys: formatas
Testų rinkinio formatas sąmoningai paliktas minimalus: įvestis, tikėtina išvestis ir laisvos formos metaduomenys. Šie metaduomenys yra naudingesni, nei gali atrodyti – pažymėjęs kiekvieną atvejį kategorija, gali suskaidyti balus ir atrasti, kad tavo klasifikatorius suklysta ne atsitiktinai, o konkrečioje užklausų šeimoje, ko neatskleidžia bendras 88 % vidurkis. Toliau pateikti trys pavyzdžiai taip pat parodo, ką turėtų turėti geras rinkinys: aiškius atvejus, pavyzdžiui, programos strigtį, bet ir atvejus, kurie ribojasi su kita kategorija – klausimas apie trūkstamą funkciją labai panašus į klaidos pranešimą, ir būtent šioje riboje sprendžiama klasifikatoriaus kokybė.
[
{
"input_text": "Mano siunta neatvyko",
"expected_output": "skundas",
"metadata": {"category": "pristatymas"}
},
{
"input_text": "Kaip įjungti tamsųjį režimą?",
"expected_output": "klausimas",
"metadata": {"category": "funkcija"}
},
{
"input_text": "Programa stringa paleidžiant iOS 18",
"expected_output": "klaida",
"metadata": {"category": "techninis"}
}
]
Integracija su CI/CD
Leisk vertinimą kiekvieną kartą pakeitus promptą. Funkcija ci_eval_check paverčia matavimą apsaugine juosta: ji paleidžia grandinę, palygina vidutinį balą su slenksčiu ir grąžina loginę reikšmę, kurią tavo integracijos grandinė interpretuoja kaip sėkmingą ar nepavykusį surinkimą. Pakeitimas, kuris sumažina tikslumą žemiau 85 %, nebepatenka į gamybą, lygiai taip pat kaip sugedęs unit testas blokuoja sujungimą.
Nustatyk slenkstį pagal jau pasiektą dabartinės versijos balą, o ne pagal idealą. Nustačius per aukštai, pasmerki komandą apeiti patikrą laikinai išjungiant, kas tampa nuolatine praktika; nustačius per žemai, nieko netikrini, tik rodai žalią ženklelį. Galiausiai, atmink, kad rinkinys turi išlikti reprezentatyvus realiam srautui: slenkstis, pasiektas dvidešimtyje prieš dvejus metus parašytų atvejų, nieko neįrodo apie šiandienos užklausas.
def ci_eval_check(prompt_config: dict,
test_suite: str,
min_score: float = 0.85) -> bool:
"""CI/CD vartai: tikrina, ar promptas atitinka minimalų balą."""
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"Vidutinis balas: {avg_score:.2%}")
print(f"Minimalus slenkstis: {min_score:.2%}")
if avg_score < min_score:
print("NESĖKMĖ: balas žemiau slenksčio")
return False
print("SĖKMĖ: promptas patvirtintas")
return True
Vertinimo skydelis
Stebėk balų evoliuciją laikui bėgant. Vienas balas nieko nepasako; serija pasakoja tavo prompto istoriją ir atsako į klausimą, kuris visada iškyla susirinkimuose: ar mes darome pažangą? Toliau pateikta funkcija sukuria „Markdown“ lentelę, kurioje greta kiekvienai versijai pateikiamas vidutinis balas, sunaudoti tokenai ir numatoma kaina. Formatas nėra atsitiktinis: jis tiesiogiai įklijuojamas į „pull request“, todėl palyginimas yra skaitomas tiems, kurie niekada neatidarys tavo kodo.
def comparison_report(results: dict[str, dict]) -> str:
"""Generuoja lyginamąją ataskaitą tarp promptų versijų."""
report = "# Lyginamoji vertinimo ataskaita\n\n"
report += "| Versija | Vidutinis balas | Vid. tokenai | Kaina |\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
Nustatyk savo apsaugines ribas
Sukurk dvidešimties testų atvejų rinkinį realiam promptui, įtraukdamas keletą ribinių atvejų, o ne dvidešimt patogų pavyzdžių: rinkinys, kuris pirmu bandymu praeina 100 %, tavęs nieko neišmoko. Įdiek tris vertintojų tipus ir paleisk juos kartu dviem savo prompto versijoms. Tikslus atitikimas duoda švarų skaičių, semantinis panašumas pagauna teisėtus performulavimus, o vertintojas apšviečia atvejus, kai pirmieji du nesutaria – būtent šie nesutapimai yra turtingiausi pamokomis apie tai, ko iš tikrųjų tikiesi iš modelio.
Palygink, nustatyk laimėtoją, tada nustatyk CI scenarijų, kuris blokuoja diegimą, jei balas krenta. Sužinosi, kad sistema veikia, tą dieną, kai ji atmes pakeitimą, kuris tau atrodė akivaizdus.
Svarbiausi punktai
- Automatiséltas vertinimas yra būtinas norint iteruoti su pasitikėjimu
- Derink tikslaus atitikimo, semantinį ir LLM-as-judge vertinimą pagal poreikį
- Palaikyk testų rinkinį, kuris vystosi kartu su tavo aplikacija
- Integruok vertinimą į savo CI/CD su minimaliu slenksčiu
- Naudok pajėgesnį modelį kaip vertintoją vertinant pigesnį modelį
- Dokumentuok kiekvienos versijos balus, kad stebėtum evoliuciją
Patikrink savo žinias
Pažangūs metodai ir industrializacija: galutinis patikrinimas.
1. Ką turi turėti efektyvus sistemos promptas?
Atsakymas: Vaidmenį, apimtį, elgesio taisykles, išvesties formatą ir ribinių atvejų tvarkymą – parašytą kaip specifikaciją, testuojamą kaip kodą.
2. Kada turėtum naudoti savarankišką nuoseklumą (self-consistency)?
Atsakymas: Samprotavimo problemoms su patikrinamais atsakymais: generuok kelis nepriklausomus samprotavimus ir palik daugumos atsakymą – variacija tampa sąjungininku.
3. Ką garantuoja JSON režimas su schemos užtikrinimu?
Atsakymas: Išvestį, griežtai atitinkančią schemą (tipai, privalomi laukai, enumai) – patikrintą API pusėje ir iš naujo patikrintą kode (JSON Schema, Zod), kad grandinėje nebūtų siurprizų.
4. Kas yra pagrindimas (grounding)?
Atsakymas: Atsakymų inkaravimas pateiktuose faktuose (dokumentuose, gautuose duomenyse), o ne modelio atmintyje – su reikalavimu cituoti arba susilaikyti nuo išorinių šaltinių.
5. Kokia yra versionuoto promptų katalogo paskirtis?
Atsakymas: Traktuoti promptus kaip artefaktus: versijos, A/B testai, automatiniai vertinimai kiekvienam pakeitimui – žinai, kas veikia gamyboje ir kodėl.
Galutinis kurso ciklas – versijavimas, testavimas, automatinis vertinimas – paverčia amatininkišką promptų inžineriją komandos praktika.