Mittarit ja vertailuarvot
Tällä sivulla
Oppitunti päivitetty 3. marraskuuta 2026 OpenAI:n dokumentaation perusteella:
temperaturejatop_phyväksytään vain, kun päättelytaso onnone, kun taas GPT-5.6-mallit käyttävät oletusarvoisesti päättelyä (medium). Näitä parametreja asettavien kutsujen on siksi määritettäväreasoning={"effort": "none"}(API Responses) taireasoning_effort="none"(Chat Completions). Lähteet: Using GPT-6 · GPT-5.6 Terra.
Laadun mittaaminen mittareilla
LLM-tuomari-pisteiden lisäksi käytössä on kvantitatiivisia mittareita, joilla arvioidaan eri näkökulmia LLM:n tuottamasta sisällöstä. Niiden arvo ei piinä tarkkuudessa – hyvin rakennettu LLM-tuomari havaitsee asioita, joita mikään kaava ei koskaan näe – vaan vakaudessa ja edullisuudessa. Kosinimittaus palauttaa täsmälleen saman luvun joka kerta, maksaa lähes nothing, ja siksi se voidaan ajaa tuhansille tapauksille jokaisen commitin yhteydessä. Varaat LLM-tuomarin vain niihin ulottuvuuksiin, jotka sitä todella vaativat.
Katsomme ensin keskeiset mittarit ennen kuin koostamme niistä toistettavia vertailuarvoja.
Merkityksen vertailu sanojen sijaan
Tekstien vertaaminen merkki merkiltä muuttuu käyttökelvottomaksi heti, kun sanamuoto on vapaa. Semanttinen samankaltaisuus ohittaa tämän ongelman: jokainen teksti muunnetaan vektoriksi upotusmallilla, ja mittaamme näiden kahden vektorin välisen kulman. Kaksi lausetta, jotka sanovat saman asian eri sanoilla, osoittavat samaan suuntaan.
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+
Esimerkki on opettavainen: kaksi lausetta, joilla ei ole yhtään yhteistä sanaa, saavat yli 0,85 pistettä. Tämä on menetelmän vahvuus, mutta myös sen ansa. Semanttinen samankaltaisuus ei huomioi kieltosanoja eikä sävyeroja – “maksu hyväksyttiin” ja “maksu hylättiin” näyttävät vektoritasolla hyvin samankaltaisilta. Älä siksi koskaan käytä sitä yksinään validoimaan vastausta, jossa faktuaalinen tarkkuus on tärkeää.
Kun kysymys kuuluu “vastataanko kysymykseen todella”, mikään kaava ei korvaa harkintaa. Alla oleva relevanssipisteet jakaa tämän harkinnan kolmeen erilliseen kysymykseen: Onko vastaus suora? Pysyykö se asiassa? Onko se täydellinen? Tämä erittely on parempi kuin yleispisteet, koska se kertoo, mihin suuntaan kehottaa parantamaan promptia – puhelias malli ja puutteellinen malli vaativat päinvastaisia korjauksia.
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"}
Huomaa toisen kriteerin käänteinen muotoilu, jossa 5 tarkoittaa “ei pyydettyä lisätietoa”. Tämä mahdollistaa kolmen pisteen laskemisen samaan suuntaan, mutta se on lukijalle epäintuitiivista: kun lisäät omia kriteerejäsi, pidä kiinni tästä käytännöstä, muuten saat keskiarvoja, jotka palkitsevat virheen, jonka aiot rangaista.
Varmistetaan, ettei malli hallusinoi
Dokumenttipohjaisessa Q&A-sovelluksessa ratkaiseva mittari ei ole kirjoituksen laatu, vaan uskollisuus lähteelle. Valvontaperiaate on yksinkertainen: esitä tuomarille alkuperäinen konteksti ja generoitu vastaus, ja pyydä sitä luokittelemaan jokainen väittämä joko kontekstin tukemaksi, kontekstista puuttuvaksi tai kontekstin kanssa ristiriidassa olevaksi. Ero näiden kahden viimeisen kategorian välillä on tärkeä, koska pelkästään puuttuva väittämä voi olla tarkkaa yleistietoa, kun taas lähteen kanssa ristiriidassa oleva väittämä on aina virhe.
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"}
Kontekstin typistäminen 3 000 merkkiin on raja, joka sinun on tiedostettava: jos lähde ylittää tämän koon, täysin tarkat väittämät lasketaan tukemattomiksi pelkästään siksi, että ne perusteleva kohta on katkaistu. Pitkille dokumenteille jaa ja arvioi osioittain sen sijaan, että hyväksyisit systemaattisia väärää hälytyksiä.
Toistettavan vertailuarvon kokoaminen
Vertailuarvo ei ole vain yksi mittari lisää: se on asetelma, joka jäädyttää tietoaineiston ja protokollan, jotta kaksi ajoa ovat vertailukelpoisia. Alla oleva luokka mittaa relevanssia, uskollisuutta (kun konteksti on saatavilla), viivettä ja kustannuksia, ja säilyttää jokaisen tuloksen päivämäärineen ja prompt-version tunnisteineen.
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-metodin tuotos asettaa tarkoituksella relevanssin ja viiveen samalle riville, koska päätös tehdään juuri näin. Malli, joka voittaa kaksi sadasosaa relevanssissa mutta kaksinkertaistaa vasteajan, ei ole parempi valinta interaktiiviseen sovellukseen; se saattaa olla sitä yön yli tehtävään käsittelyyn. Taulukko ei päätä puolestasi; se asettaa kompromissin suoraan silmiesi eteen.
Lopuksi, total_cost pysyy nollana tässä toteutuksessa. Täytä se API:n palauttamista käyttö kentistä: mallivertailu, joka jättää kustannukset huomiotta, jättää pois kriteerin, joka ratkaisee keskustelun talousosastosi kanssa.
Keskeiset asiat
- Semanttinen samankaltaisuus mittaa merkitystä, mutta on sokea kieltosanoille
- Jaa relevanssi erillisiin kriteereihin yleispisteiden sijaan
- Havaitse hallusinaatiot asettamalla vastaus vastakkain lähdekontekstin kanssa
- Luo toistettavia vertailuarvoja, jotka mittaavat laatua, viivettä ja kustannuksia yhdessä
- Yhdistä automaattiset mittarit ja LLM-tuomari kokonaisvaltaista arviointia varten