Rādītāji un etaloni
Š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āpēc izsaukumos, kuros iestatīti šie parametri, ir jānorādareasoning={"effort": "none"}(API Responses) vaireasoning_effort="none"(Chat Completions). Avoti: Using GPT-6 · GPT-5.6 Terra.
Kvalitātes mērīšana ar rādītājiem
Papildus LLM-as-Judge vērtējumiem eksistē kvantitatīvi rādītāji, lai novērtētu dažādus LLM izejas aspektus. To vērtība nav precizitātē – labi izveidots LLM tiesnesis saskata to, ko neviena formula nespēs, – bet gan stabilitātē un lētumā. Kosinusu līdzība katrā izpildes reizē atgriež tieši to pašu skaitli, maksā gandrīz neko un tāpēc ar katru kodu versiju (commit) var pārbaudīt tūkstošiem gadījumu. LLM tiesnesi tad atstāj tiem aspektiem, kuriem tas tiešām ir nepieciešams.
Pirms šo rādītāju apvienošanas reproducējamos etalonos (benchmarks), apskatīsim būtiskākos no tiem.
Nozīmes salīdzināšana, nevis vārdu
Tekstu salīdzināšana raksts pa rakstam kļūst nelietojama, tiklīdz formulējums ir brīvs. Semantiskā līdzība šo problēmu apej: katrs teksts, izmantojot iegulšanas (embedding) modeli, tiek pārvērsts vektorā, un mēs mērām leņķi starp abiem vektoriem. Divi teikumi, kas saka to pašu dažādiem vārdiem, norāda vienā virzienā.
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+
Piemērs ir pamācošs: divi teikumi bez kopīgiem vārdiem saņem vērtējumu virs 0,85. Šī ir metodes stiprā puse, bet arī tās slazds. Semantiskā līdzība ignorē noliegumu un pakāpes nianses – „maksājums tika akceptēts” un „maksājums tika noraidīts” vektoru telpā izskatās ļoti līdzīgi. Tāpēc nekad neizmanto to vienu pašu, lai validētu atbildi, kur svarīga faktiska precizitāte.
Kad jautājums ir „vai atbilde tiešām adresē uzdoto jautājumu”, neviena formula neaizstāj spriedumu. Zemāk esošais atbilstības (relevance) rādītājs šo spriedumu sadala trīs atsevišķos jautājumos: vai atbilde ir tieša? Vai tā paliek fokusā? Vai tā ir pilnīga? Šāda sadalīšana ir labāka par vispārēju vērtējumu, jo tā norāda, kurā virzienā labot uzvedni (prompt) – daudzrunīgs modelis un nepilnīgs modelis prasa pretējas korekcijas.
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"}
Ņem vērā otrā kritērija apgriezto formulējumu, kur 5 nozīmē „nav neprasītas informācijas”. Tas ļauj saskaitīt trīs vērtējumus vienā virzienā, taču lasot tas ir pretrunā ar intuīciju: kad pievieno savus kritērijus, ievēro šo konvenciju, citādi iegūsi vidējos rādītājus, kas atlalgo trūkumu, kuru vēlējies sodīt.
Pārliecināšanās, ka modelis nehalucinē
Lietotnēs, kas balstītas uz dokumentiem un jautājumu-atbilžu sistēmām, izšķirošais rādītājs nav rakstīšanas kvalitāte, bet gan uzticamība avotam. Kontroles princips ir vienkāršs: pasniedz tiesnesim oriģinālo kontekstu un ģenerēto atbildi, un liec tam klasificēt katru apgalvojumu kā konteksta apstiprinātu, kontekstā neesošu vai tam pretrunīgu. Atšķirība starp pēdējām divām kategorijām ir svarīga, jo apgalvojums, kas vienkārši nav kontekstā, var būt precīzas vispārīgas zināšanas, savukārt apgalvojums, kas ir pretrunā ar avotu, vienmēr ir kļūda.
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"}
Konteksta saīsināšana līdz 3000 rakstzīmēm ir robeža, par ko tev jāzina: ja avots pārsniedz šo apjomu, patiesi precīzi apgalvojumi tiks uzskatīti par neatbalstītiem vienkārši tāpēc, ka tos pamatojošais fragments tika nogriezts. Garu dokumentu gadījumā sadali tos un vērtē pa sadaļām, nevis pieņem sistemātiskus viltus pozitīvus rezultātus.
Reproducējama etalona (Benchmark) izveide
Etalons nav tikai vēl viens rādītājs: tā ir iestatne, kas iesaldē datu kopu un protokolu, lai divi izpildes cikli būtu salīdzināmi. Tālāk redzamā klase mēra atbilstību, uzticamību (ja pieejams konteksts), latentumu un izmaksas, pēc tam saglabā katru rezultātu ar datumu un uzvednes versijas marķējumu.
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)
Funkcijas compare izvade apzināti izvieto atbilstību un latentumu vienā rindā, jo tieši tā tiek pieņemts lēmums. Modelis, kas iegūst divus simtdaļpunktus atbilstībā, bet dubulto atbildes laiku, interaktīvai lietotnei nav labāka izvēle; tas varētu būt piemērots nakts apstrādei. Tabula nepieņem lēmumu tavā vietā; tā nostāda kompromisu tieši tavu acu priekšā.
Visbeidzot, šajā implementācijā total_cost paliek nulle. Aizpildi to no API atgrieztajiem lietojuma (usage) laukiem: modeļu salīdzinājums, kas izlaiž izmaksas, izlaiž kritēriju, kas izšķirs diskusiju ar tavu finanšu komandu.
Galvenās atziņas
- Semantiskā līdzība mēra nozīmi, bet paliek akla pret noliegumu
- Sadali atbilstību atsevišķos kritērijos, nevis izmanto vispārēju vērtējumu
- Atklāj halucinācijas, konfrontējot atbildi ar avota kontekstu
- Izveido reproducējamus etalonus, kas vienlaikus mēra kvalitāti, latentumu un izmaksas
- Apvieno automātiskos rādītājus un LLM-as-Judge, lai iegūtu pilnvērtīgu novērtējumu