Rodikliai ir lyginamieji testai
Šiame puslapyje
Pamoka atnaujinta 2026 m. lapkričio 3 d. remiantis „OpenAI“ dokumentacija: parametrai
temperatureirtop_ppriimami tik esant „none“ lygio samprotavimui, tuo tarpu GPT-5.6 modeliai pagal nutylėjimą samprotauja („medium“). Todėl kvietimuose, kuriuose nustatomi šie parametrai, būtina nurodytireasoning={"effort": "none"}(API Responses) arbareasoning_effort="none"(Chat Completions). Šaltiniai: Using GPT-6 · GPT-5.6 Terra.
Kokybės matavimas rodikliais
Be „LLM-as-Judge“ įvertinimų, egzistuoja kiekybiniai rodikliai, skirti įvairiems LLM atsakymų aspektams vertinti. Jų vertė slypi ne tikslume – gerai sukurtas LLM vertintojas pastebi tai, ko jokia formulė niekada nepamatys, – bet stabilume ir pigume. Kosinusinis panašumas kiekvieno vykdymo metu grąžina tą patį skaičių, kainuoja beveik nieko, todėl gali būti taikomas tūkstančiams atvejų su kiekvienu kodu įtraukimu (commit). Tuomet LLM vertintoją palieki tiems aspektams, kuriems jis iš tiesų reikalingas.
Prieš surinkdami juos į atkuriamus lyginamuosius testus (benchmarks), apžvelgsime esminius rodiklius.
Reikšmės, o ne žodžių palyginimas
Tekstų lyginimas simbolis po simbolio tampa nebetinkamas, kai frazuotė yra laisva. Semantinį panašumą naudojant ši problema išsprendžiama: kiekvienas tekstas embedding modelio paverčiamas vektoriumi, ir mes matuojame kampą tarp šių dviejų vektorių. Du sakiniai, reiškiantys tą patį skirtingais žodžiais, rodo ta pačia kryptimi.
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+
Pavyzdys yra pamokomas: du sakiniai, neturintys nė vieno bendro žodžio, gauna daugiau nei 0,85 balo. Tai yra šio metodo stiprybė, bet ir jo spąstai. Semantinis panašumas ignoruoja neigimą ir laipsnio niuansus – „mokėjimas buvo priimtas“ ir „mokėjimas buvo atmestas“ vektorių erdvėje atrodo labai panašiai. Todėl niekada nenaudok jo vieno patvirtindamas atsakymą, kai svarbus faktinis tikslumas.
Kai kyla klausimas „ar atsakymas iš tiesų atsako į užduotą klausimą“, jokia formulė nepakeis sprendimo. Toliau pateiktas aktualumo įvertis šį sprendimą suskaido į tris atskirus klausimus: ar atsakymas tiesioginis? Ar jis lieka temos ribose? Ar jis išsamus? Šis suskaidymas yra geriau nei bendras įvertis, nes nurodo, kuria kryptimi reikia taisyti promptą – išsamus modelis ir neišsamus modelis reikalauja priešingų taisymų.
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"}
Atkreipk dėmesį į antrojo kriterijaus apverstą formuluotę, kur 5 reiškia „nėra nepageidaujamos informacijos“. Tai leidžia sudėti tris įverčius ta pačia kryptimi, tačiau skaitymui tai nėra intuityvu: kai pridėsi savo kriterijų, laikykis šios konvencijos, kitaip gausi vidurkius, kurie apdovanoja trūkumą, kurį ketinai bausti.
Tikrinimas, ar modelis nehaliucinuoja
Dokumentais pagrįstoje klausimų ir atsakymų (Q&A) programoje lemiamas rodiklis yra ne rašymo kokybė, bet ištikimybė šaltiniui. Kontrolės principas paprastas: pateiki vertintojui originalų kontekstą ir sugeneruotą atsakymą, ir prašai klasifikuoti kiekvieną teiginį kaip pagrįstą kontekstu, kontekste nerastą arba prieštaraujantį jam. Skirtumas tarp šių dviejų pastarųjų kategorijų yra svarbus, nes teiginys, kuris tiesiog nerastas, gali būti tikslus bendras žinojimas, tuo tarpu teiginys, prieštaraujantis šaltiniui, visada yra klaida.
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"}
Konteksto sutrumpinimas iki 3000 simbolių yra riba, kurios turi būti aware: jei šaltinis viršija šį dydį, visiškai tikslūs teiginiai bus suskaičiuoti kaip nepagrįsti vien todėl, kad juos pagrindžianti ištrauka buvo nukirpta. Ilgiems dokumentams skaidyk ir vertink pagal skyrius, užuot priėmęs sistemingus klaidingus teigiamus rezultatus.
Atkuriamo lyginamojo testo (Benchmark) sudarymas
Lyginamasis testas nėra tiesiog dar vienas rodiklis: tai sąranka, kuri užfiksuoja duomenų rinkinį ir protokolą taip, kad du vykdymai būtų palyginami. Toliau pateikta klasė matuoja aktualumą, ištikimybę (kai kontekstas prieinamas), delsą ir kainą, tada kiekvieną rezultatą išsaugo su data ir prompto versijos žyma.
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)
compare išvestis sąmoningai pateikia aktualumą ir delsą toje pačioje eilutėje, nes būtent taip iš tikrųjų priimamas sprendimas. Modelis, kuris įgyja du šimtąsias aktualumo balo dalis, bet padvigubina atsako laiką, nėra geresnis pasirinkimas interaktyviai programai; jis gali toks būti naktiniam apdorojimui. Lentelė nepriima sprendimo už tave; ji pateikia kompromisą tiesiai prieš tavo akis.
Galiausiai, šiame įgyvendinime total_cost lieka lygus nuliui. Užpildyk jį iš API grąžinamų naudojimo laukų: modelio palyginimas, neįtraukiantis kainos, palieka nuošalyje kriterijų, kuris išspręs diskusiją su tavo finansų komanda.
Svarbiausi punktai
- Semantinis panašumas matuoja reikšmę, bet lieka aklas neigimui
- Suskaidyk aktualumą į atskirus kriterijus, užuot naudojęs bendrą įvertį
- Aptik haliucinacijas priešindamas atsakymą su šaltinio kontekstu
- Kurk atkuriamus lyginamuosius testus, kurie vienu metu matuoja kokybę, delsą ir kainą
- Derink automatinius rodiklius ir LLM-as-Judge, kad gautum išsamų įvertinimą