Promptide automatiseeritud hindamine
Sellel lehel
Tund uuendatud 3. novembril 2026 OpenAI dokumentatsiooni põhjal: parameetreid
temperaturejatop_paktsepteeritakse ainult siis, kui arutluse jõupingutus (reasoning effort) onnone, samas kui GPT-5.6 mudelid kasutavad vaikimisi arutlust (medium). Seetõttu peavad need parameetrid määravad päringud sisaldama sätetreasoning={"effort": "none"}(Responses API) võireasoning_effort="none"(Chat Completions). Allikad: GPT-6 kasutamine · GPT-5.6 Terra.
Promptide automatiseeritud hindamine
Automatiseeritud hindamine on küpse promptide inseneritöö torustiku nurgakivi. See võimaldab tuvastada taandarenguid, võrrelda mudeleid ja valideerida muudatusi enne kasutuselevõttu. Ilma selleta on iga prompti muutmine pime loterii.
Hindamise tüübid
Kolm hindajate perekonda jagavad töö oodatava väljundi olemuse põhjal ja peaaegu alati kombineerid neist mitut.
Täpse vaste hindamine (Exact Match)
Ülesannete puhul, kus on oodata ühte kindlat vastust, piisab otsesest võrdlusest. eval_exact_match normaliseerib tähestiku suuruse ja tühikud enne võrdlemist: ilma selle ettevaatusabinõuta loetaks „Bug“ ja „bug“ veaks, sundides sind lahendama probleemi, mida tegelikult pole.
eval_set_match käsitleb juhtumeid, kus vastus on hulk – dokumendist leitud üksused, artiklile omistatud kategooriad. See tuletab täpsuse (precision) ja täielikkuse (recall), kaks näitajat, mis räägivad erinevaid lugusid: kõrge täpsus madala täielikkuse juures annab märku liiga ettevaatlikust mudelist, mis ekstraheerib ainult seda, milles on kindel; vastupidine reedab mudelit, mis hallutsineerib lünkade täitmiseks. F1-score võtab need mugavalt kokku, kuid ei asenda neid diagnostikas.
def eval_exact_match(prediction: str, reference: str) -> bool:
"""Täpne vaste pärast normaliseerimist."""
return prediction.strip().lower() == reference.strip().lower()
def eval_set_match(prediction: set, reference: set) -> dict:
"""Hulga vaste (üksused, kategooriad)."""
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}
Semantiline hindamine (Embedding)
Tekstivastuste puhul, kus sõnastus võib varieeruda, muutub täpne vaste absurdseks: „Teie tellimus toimetatakse kohale homme“ ja „Tarne on planeeritud homseks“ ütlevad sama, kuid saaksid null punkti. Kosinussarnasus embeddingute vahel mõõdab semantilist lähedust, mitte tähemärkide kokkulangevust, andes tulemuseks pideva skaalaga hinnangu.
Määrad läve, millest kõrgemat vastust loetakse vastuvõetavaks. Kalibreeri see paarikümnel käsitsi „samaväärseks“ või „erinevaks“ liigitatud paaril ning vali väärtus, mis eraldab kahte rühma kõige paremini: kõhutunde põhjal valitud lävi annab tulemused, mis on sama meelevaldsed kui mõõtmise puudumine, lisades vaid ranguse illusiooni.
from openai import OpenAI
import numpy as np
client = OpenAI()
def eval_semantic_similarity(prediction: str,
reference: str) -> float:
"""Embeddingute vaheline kosinussarnasus."""
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-hindamine (LLM-as-Judge)
Mudel hindab vastuse kvaliteeti. See on ainus elujõuline lähenemine, kui võrdlusandmed puuduvad: keegi ei hakka käsitsi kirjutama „õiget“ tugiteenuse vastust kahele sajale piletile.
Hindaja kasutatavus sõltub mõnest asjast. Esiteks kasutatav mudel: valid hindajaks võimekama mudeli, siin gpt-5.6-sol, sest hinnatavaga sama tasemega hindaja kipub valideerima omaenda vigu. Teiseks nõue põhjenduse järele: iga hinde motiveerimine stabiliseerib otsust ja võimaldab märgata hindajat, kes kasutab vale kriteeriumi – põhjendus, mis arutleb pikkuse üle, kui kriteeriumiks oli selgus, on punane lipp. Lõpuks tagab temperature väärtusega 0.1 hinnete stabiilsuse katsete vahel.
def eval_llm_judge(question: str, prediction: str,
criteria: list[str]) -> dict:
"""Hindamine kohtuniku mudeli poolt."""
criteria_text = "\n".join(
f"- {c}: hinne 1 kuni 5" for c in criteria
)
response = client.responses.create(
model="gpt-5.6-sol", # Võimekam mudel hindajana
reasoning={"effort": "none"}, # temperature nõuab effort none
instructions="Oled ekspert, erapooletu hindaja.",
input=f"""Hinda seda vastust vastavalt järgmistele kriteeriumidele:
Esitatud küsimus: {question}
Hinnatav vastus: {prediction}
Kriteeriumid:
{criteria_text}
Anna iga kriteeriumi kohta hinne 1 kuni 5 koos põhjendusega.""",
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)
Täielik hindamistorustik
EvalPipeline paneb need ehitusplokid kokku: see laadib testikomplekti, käivitab prompti iga juhtumi puhul, rakendab kõiki pakutud hindajaid ja agregeerib tulemused. Hindajad antakse edasi funktsioonide loendina, mida kõiki kutsutakse sama signatuuriga; meetrika lisamine ei nõua seega torustiku muutmist ja saad käivitada täpse vaste, semantilise sarnasuse ja kohtuniku sama täitmise peal, maksmata genereerimise eest kolm korda.
Meetod summary kogub ka tarbitud tokenid. See esmapilgul teisejärguline rida kaitseb sind levinud lõksu eest: prompti versioon, mis võidab kaks punkti, kuid kolmekordistab arvet, pole tingimata õige valik, ja parem on seda mõista kompromisside tegemise ajal kui siis, kui kuuarve saabub.
import json
from dataclasses import dataclass
from pathlib import Path
@dataclass
class TestCase:
"""Testijuhtum hindamiseks."""
input_text: str
expected_output: str = None
metadata: dict = None
class EvalPipeline:
"""Automatiseeritud hindamistorustik."""
def __init__(self, test_suite_path: str):
"""Laadib testikomplekti JSON-failist."""
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:
"""Käivitab kõik testid ja hindab tulemusi."""
self.results = []
for tc in self.test_cases:
# Genereeri vastus
response = client.responses.create(
model=prompt_config["model"],
reasoning={"effort": "none"}, # temperature nõuab effort none
instructions=prompt_config["system_prompt"],
input=tc.input_text,
temperature=prompt_config.get("temperature", 0.1)
)
prediction = response.output_text
# Hinda iga hindajaga
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:
"""Võtab kokku hindamistulemused."""
if not self.results:
return {"error": "Tulemused puuduvad"}
# Agregeeri hinded hindaja kaupa
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
Testikomplekt: formaat
Testikomplekti formaat on tahtlikult minimaalne: sisend, oodatav väljund ja vabas vormis metaandmed. Need metaandmed on kasulikumad, kui esmapilgul tundub – märgistades iga juhtumi kategooria järgi, saad jaotada hinded ja avastada, et sinu klassifikaator ei ebaõnnestu juhuslikult, vaid konkreetsel päringute perekonnal, mida globaalne 88% keskmine ei paljasta. Allpool toodud kolm näidet näitavad ka seda, mida hea komplekt peaks sisaldama: selgeid juhtumeid, nagu rakenduse kokkujooksmine, aga ka juhtumeid, mis piirnevad teise kategooriaga – küsimus puuduva funktsiooni kohta näeb välja nagu veateade ja just sellel piirimail otsustatakse klassifikaatori kvaliteet.
[
{
"input_text": "Mu pakett pole kohale jõudnud",
"expected_output": "kaebus",
"metadata": {"category": "tarne"}
},
{
"input_text": "Kuidas lülitada sisse tume režiim?",
"expected_output": "küsimus",
"metadata": {"category": "funktsioon"}
},
{
"input_text": "Rakendus jookseb kokku käivitamisel iOS 18-l",
"expected_output": "viga",
"metadata": {"category": "tehniline"}
}
]
CI/CD integratsioon
Käivita hindamine iga prompti muutuse korral. Funktsioon ci_eval_check muudab mõõtmise kaitseraudaks: see käivitab torustiku, võrdleb keskmist hinnet lävendiga ja tagastab booli väärtuse, mida sinu integratsiooniahel tõlgendab ehituse õnnestumise või ebaõnnestumisena. Muudatus, mis langetab täpsuse alla 85%, ei jõua enam tootmisse, täpselt nagu katkine ühiktest blokeerib liitmise.
Määra lävend praeguse versiooni juba saavutatud hinde põhjal, mitte ideaalist lähtuvalt. Kui määrad selle liiga kõrgeks, mõistad meeskonna hukka mööduma kontrollist ajutiste keelamistega, mis muutuvad püsivaks; kui liiga madalaks, siis ei kontrolli sa tegelikult midagi, kuvades samal ajal rohelist märki. Lõpuks pea meeles, et komplekt peab jääma reaalse liikluse esinduslikuks: lävend, mis on saavutatud kahekümnel kahe aasta eest kirjutatud juhtumil, ei tõesta midagi tänaste päringute kohta.
def ci_eval_check(prompt_config: dict,
test_suite: str,
min_score: float = 0.85) -> bool:
"""CI/CD värav: kontrollib, kas prompt vastab miinimumhindele."""
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"Keskmine hinne: {avg_score:.2%}")
print(f"Miinimumlävend: {min_score:.2%}")
if avg_score < min_score:
print("EBAÕNNESTUMINE: hinne alla lävendi")
return False
print("ÕNNESTUMINE: prompt valideeritud")
return True
Hindamise armatuurlaud
Jälgi hinde arengut ajas. Üksik hinne ei ütle midagi; seeria räägib sinu prompti loo ja vastab küsimusele, mis koosolekutel alati kerkib: kas me teeme edusamme? Allpool olev funktsioon loob Markdown-tabeli, asetades kõrvuti iga versiooni jaoks keskmise hinde, tarbitud tokenid ja hinnangulise kulu. Formaati pole valitud juhuslikult: see kleepub otse pull request’i, muutes võrdluse loetavaks inimestele, kes sinu koodi kunagi ei ava.
def comparison_report(results: dict[str, dict]) -> str:
"""Genereerib võrdlusaruande prompti versioonide vahel."""
report = "# Võrdlev hindamisaruanne\n\n"
report += "| Versioon | Keskmine hinne | Keskmised tokenid | Kulu |\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
Seadista oma kaitserauad
Koosta kakskümmend testijuhtumit reaalse prompti jaoks, pannes sinna peotäie piirjuhtumeid, mitte kakskümmend mugavat näidet: komplekt, mis läbib esimesel korral 100%, ei õpeta sind midagi. Rakenda kolme tüüpi hindajaid ja käivita need koos oma prompti kahe versiooni peal. Täpne vaste annab puhta numbri, semantiline sarnasus püüab legitiimsed ümbersõnastused ja kohtunik valgustab juhtumeid, kus esimesed kaks ei ole ühel meelel – need lahkarvamused on kõige õpetlikumad selle kohta, mida sa mudelilt tegelikult ootad.
Võrdle, tuvasta võitnud versioon ja seadista seejärel CI-skript, mis blokeerib kasutuselevõtu, kui hinne langeb. Sa tead, et süsteem töötab, kui see lükkab tagasi muudatuse, mida sa pidasid ilmseks.
Peamised punktid
- Automatiseeritud hindamine on enesekindlaks iteratsiooniks hädavajalik
- Kombineeri vajadusel täpset, semantilist ja LLM-kohtuniku hindamist
- Hoolda testikomplekti, mis areneb koos sinu rakendusega
- Integreeri hindamine oma CI/CD-sse miinimumlävendiga
- Kasuta odavama mudeli hindamiseks võimekamat mudelit
- Dokumenteeri iga versiooni hinded arengu jälgimiseks
Testi oma teadmisi
Täiustatud tehnikad ja industrialiseerimine: lõplik kontroll.
1. Mida sisaldab tõhus süsteemi prompt?
Vastus: Roll, ulatus, käitumisreeglid, väljundi formaat ja piirjuhtumite käsitlemine – kirjutatud nagu spetsifikatsioon, testitud nagu kood.
2. Millal peaksid kasutama enese järjepidevust (self-consistency)?
Vastus: Arutlusülesannetel, kus on kontrollitavad vastused: genereeri mitu sõltumatut arutluskäiku ja säilita enamuse vastus – variatsioonist saab liitlane.
3. Mida garanteerib JSON-režiim skeemi jõustamisega?
Vastus: Väljund, mis vastab rangelt skeemile (tüübid, nõutavad väljad, loendid) – valideeritud API tasandil ja uuesti valideeritud koodis (JSON Schema, Zod) üllatusvaba ahela jaoks.
4. Mis on põhjendatus (grounding)?
Vastus: Vastuste ankurdamine esitatud faktidesse (dokumendid, hangitud andmed), mitte mudeli mällu – koos nõudega tsiteerida või hoiduda välistest allikatest.
5. Mis on versioneeritud promptide kataloogi eesmärk?
Vastus: Kohelda prompte artefaktidena: versioonid, A/B-testid, automatiseeritud hindamine iga muudatuse korral – sa tead, mis tootmises töötab ja miks.
Kursuse viimane tsükkel – versioonimine, testimine, automatiseeritud hindamine – muudab käsitööna tehtud promptide inseneritöö meeskondlikuks praktikaks.