Mõõdikud ja võrdlusalused
Sellel lehel
Tund uuendatud 3. novembril 2026 OpenAI dokumentatsiooni põhjal: parameetreid
temperaturejatop_paktsepteeritakse ainult siis, kui arutluse jõupingutus (reasoning effort) on määratud väärtuseganone, samas kui GPT-5.6 mudelid kasutavad vaikimisi arutlust (medium). Seetõttu peavad need parameetrid määravad päringud sisaldama seadetreasoning={"effort": "none"}(API Responses) võireasoning_effort="none"(Chat Completions). Allikad: Using GPT-6 · GPT-5.6 Terra.
Kvaliteedi mõõtmine mõõdikute abil
Lisaks LLM-kohtuniku hinnetele eksisteerivad kvantitatiivsed mõõdikud, millega hinnata suurte keelemudelite (LLM) väljundite erinevaid aspekte. Nende väärtus ei seisne selles, et need oleksid täpsemad – hästi koostatud LLM-kohtunik märkab nüansse, mida ükski valem kunagi ei taba –, vaid selles, et need on stabiilsed ja odavad. Koosiinussarnasus annab igal käivitamisel täpselt sama tulemuse, maksab peaaegu mitte midagi ja seetõttu saab seda käitada tuhandete juhtumite peal iga koodimuudatuse korral. LLM-kohtuniku jäta alles mõõtmete jaoks, mis seda tõeliselt vajavad.
Enne kui koondame need korratavateks võrdlusalusteks, vaatame üle olulisemad mõõdikud.
Tähenduse võrdlemine, mitte sõnade
Tekstide võrdlemine tähemärgi haaval muutub kasutuks niipea, kui sõnastus on vaba. Semantiline sarnasus lahendab selle probleemi: iga tekst teisendatakse manustamismudeli (embedding model) abil vektoriks ja mõõdetakse nende kahe vektori vahelist nurka. Kaks lauset, mis väljendavad sama mõtet erinevate sõnadega, osutavad samas suunas.
import openai
import numpy as np
client = openai.OpenAI()
def cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
"""Calculates the cosine similarity between two vectors."""
a = np.array(vec_a)
b = np.array(vec_b)
return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))
def semantic_similarity(text_a: str, text_b: str) -> float:
"""Measures the semantic similarity between two texts."""
response = client.embeddings.create(
model="text-embedding-3-large",
input=[text_a, text_b],
)
vec_a = response.data[0].embedding
vec_b = response.data[1].embedding
return cosine_similarity(vec_a, vec_b)
# Example
score = semantic_similarity(
"The cat is on the rug.",
"A feline is resting on the carpet.",
)
print(f"Similarity: {score:.3f}") # ~0.85+
Näide on õpetlik: kaks lauset, millel pole ühtegi ühist sõna, saavad hindeks üle 0,85. See on meetodi tugevus, kuid samas ka selle lõks. Semantiline sarnasus ignoreerib eitamist ja astme nüansse – laused „makse aktsepteeriti“ ja „makse lükati tagasi“ näivad vektorruumis väga sarnased. Seetõttu ära kasuta seda kunagi üksi vastuse valideerimisel, kui oluline on faktiline täpsus.
Kui küsimus on „kas vastus tegelikult käsitleb esitatud küsimust“, ei asenda ühtegi valemit inimlik hinnang. Allpool toodud asjakohasuse hinne jaotab selle hinnangu kolmeks eraldiseisvaks küsimuseks: kas vastus on otsene? Kas see püsib teemas? Kas see on täielik? See jaotus on parem kui üldhinne, sest see ütleb sulle, millises suunas prompti parandada – sõnaohtrale mudelile ja puudulikule mudelile on vaja vastupidiseid parandusi.
def relevance_score(
question: str,
answer: str,
context: str | None = None,
) -> dict:
"""Evaluates whether the answer is relevant to the question."""
prompt = (
"Evaluate the relevance of this answer.\n\n"
f"Question: {question}\n"
)
if context:
prompt += f"Context provided: {context[:1000]}\n"
prompt += (
f"Answer: {answer}\n\n"
"Criteria:\n"
"1. Does the answer directly address the question? (0-5)\n"
"2. Does the answer contain unrequested information? (0-5, 5=none)\n"
"3. Is the answer complete? (0-5)\n\n"
"Respond in JSON with keys: direct, focus, completeness."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.0,
)
import json
try:
scores = json.loads(response.output_text)
average = sum(scores.values()) / (len(scores) * 5)
return {"score": average, "details": scores}
except (json.JSONDecodeError, TypeError):
return {"score": 0, "error": "Parsing failed"}
Pane tähele teise kriteeriumi pööratud sõnastust, kus 5 tähendab „soovimatu teabe puudumine“. See võimaldab liita kolm hinnet samas suunas, kuid on lugemisel ebaloomulik: kui lisad oma kriteeriume, pea sellest konventsioonist kinni, muidu saad keskmisi, which premeerivad vigu, mida tahtsid karistada.
Veendumine, et mudel ei luuleta
Dokumentidel põhinevas küsimuste ja vastuste rakenduses ei ole otsustavaks mõõdikuks kirjutamise kvaliteet, vaid truudus allikale. Kontrollprintsiip on lihtne: esita kohtunikule algne kontekst ja genereeritud vastus ning palu tal liigitada iga väide kas kontekstiga põhjendatuks, kontekstist puuduvaks või sellega vastuolus olevaks. Viimase kahe kategooria eristamine on oluline, sest pelgalt puuduv väide võib olla üldteadmistes korrektne, samas kui allikaga vastuolus olev väide on alati viga.
def detect_hallucinations(
context: str,
answer: str,
) -> dict:
"""Detects statements not supported by the context."""
prompt = (
"Analyze this answer and identify any statement "
"that is NOT supported by the provided context.\n\n"
f"Context: {context[:3000]}\n\n"
f"Answer: {answer}\n\n"
"For each statement in the answer, indicate:\n"
"- supported: the statement is in the context\n"
"- unsupported: the statement is not in the context\n"
"- invented: the statement contradicts the context\n\n"
"Respond in JSON with the key statements (list) and "
"fidelity_score (0 to 1)."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.0,
)
import json
try:
return json.loads(response.output_text)
except json.JSONDecodeError:
return {"fidelity_score": 0, "error": "Parsing failed"}
Konteksti kärpimine 3000 märgini on piirang, millest pead teadlik olema: kui allikas ületab selle suuruse, loetakse täiesti täpsed väited põhjendamatuks lihtsalt seetõttu, et neid õigustav lõik on ära lõigatud. Pikkade dokumentide puhul jaga need osadeks ja hinda iga osa eraldi, selle asemel et leppida süstemaatiliste valepositiivsete tulemustega.
Korratava võrdlusaluse koostamine
Võrdlusalus (benchmark) ei ole lihtsalt järjekordne mõõdik: see on seadistus, mis külmutab andmestiku ja protokolli, et kahe käivituse tulemused oleksid võrreldavad. Allpool olev klass mõõdab asjakohasust, truudust (kui kontekst on olemas), latentsust ja kulu, salvestades iga tulemuse kuupäevaga ja märgistatuna prompti versiooni järgi.
from dataclasses import dataclass, field
import time
@dataclass
class BenchmarkResult:
model: str
prompt_version: str
scores: dict
avg_latency: float
total_cost: float
date: str = field(default_factory=lambda: time.strftime("%Y-%m-%d"))
class Benchmark:
"""Reusable benchmark for comparing models and prompts."""
def __init__(self, name: str, dataset: list[dict]):
self.name = name
self.dataset = dataset
self.results: list[BenchmarkResult] = []
def run(
self,
model: str,
system_prompt: str,
prompt_version: str,
) -> BenchmarkResult:
"""Runs the benchmark with a given model and prompt."""
relevance_scores = []
hallucination_scores = []
latencies = []
cost = 0
for case in self.dataset:
start = time.perf_counter()
response = client.responses.create(
model=model,
instructions=system_prompt,
input=case["input"],
)
latency = time.perf_counter() - start
latencies.append(latency)
# Evaluate
relevance = relevance_score(
case["input"], response.output_text
)
relevance_scores.append(relevance["score"])
if case.get("context"):
halluc = detect_hallucinations(
case["context"], response.output_text
)
hallucination_scores.append(
halluc.get("fidelity_score", 0)
)
result = BenchmarkResult(
model=model,
prompt_version=prompt_version,
scores={
"relevance": sum(relevance_scores) / len(relevance_scores),
"fidelity": (
sum(hallucination_scores) / len(hallucination_scores)
if hallucination_scores else None
),
},
avg_latency=sum(latencies) / len(latencies),
total_cost=cost,
)
self.results.append(result)
return result
def compare(self) -> str:
"""Compares all benchmark results."""
lines = [f"Benchmark: {self.name}\n"]
for r in self.results:
lines.append(
f" {r.model} (prompt {r.prompt_version}) | "
f"Relevance: {r.scores['relevance']:.2f} | "
f"Latency: {r.avg_latency:.2f}s"
)
return "\n".join(lines)
Funktsiooni compare väljund asetab tahtlikult asjakohasuse ja latentsuse samale reale, sest nii tehakse tegelikult otsuseid. Mudel, mis võidab asjakohasuses kaks sajandikku, kuid kahekordistab vastamisaega, ei ole interaktiivse rakenduse jaoks parem valik; öiseks töötlemiseks võib olla küll. Tabel ei otsusta sinu eest; see toob kompromissi otse sinu silme ette.
Lõpuks jääb total_cost selles teostuses nulliks. Täida see API poolt tagastatud kasutusväljadest: mudelite võrdlus, mis jätab kõrvale kulu, jätab välja kriteeriumi, mis lahendab arutelu sinu finantsmeeskonnaga.
Peamised punktid
- Semantiline sarnasus mõõdab tähendust, kuid jääb pimedaks eitamise suhtes
- Jaota asjakohasus eraldiseisvateks kriteeriumideks, mitte üldhindeks
- Tuvasta luulud, vastandades vastuse allika kontekstile
- Loo korratavad võrdlusalused, mis mõõdavad üheaegselt kvaliteeti, latentsust ja kulu
- Kombineeri automaatseid mõõdikuid ja LLM-kohtunikku terviklikuks hindamiseks