Metrike i mjerila
Na ovoj stranici
Lekcija ažurirana 3. studenoga 2026. na temelju OpenAI dokumentacije: parametri
temperatureitop_pprihvaćeni su samo uz napor rezoniranja (reasoning effort) odnone, dok modeli GPT-5.6 prema zadanim postavkama rezoniraju (medium). Pozivi koji postavljaju ove parametre stoga moraju specificiratireasoning={"effort": "none"}(API Responses) ilireasoning_effort="none"(Chat Completions). Izvori: Using GPT-6 · GPT-5.6 Terra.
Mjerenje kvalitete metrikama
Osim ocjena tipa LLM-as-Judge, postoje kvantitativne metrike za procjenu različitih aspekata izlaza velikih jezičnih modela. Njihova vrijednost nije u tome što su preciznije – dobro konstruirani LLM sudac uočava stvari koje nijedna formula nikada neće – već u tome što su stabilne i jeftine. Kosinusna sličnost vraća točno isti broj pri svakom pokretanju, košta gotovo ništa i stoga se može pokretati na tisućama slučajeva uz svaku promjenu koda. LLM suca tada čuvaš za dimenzije koje to doista zahtijevaju.
Prije nego što ih sastaviš u reproducibilna mjerila, pregledat ćemo ključne metrike.
Usporedba značenja, a ne riječi
Usporedba dva teksta znak po znak postaje neupotrebljiva čim je formulacija slobodna. Semantička sličnost zaobilazi taj problem: svaki se tekst pomoću modela za ugradnju (embedding) pretvara u vektor, a mi mjerimo kut između ta dva vektora. Dvije rečenice koje govore isto različitim riječima pokazuju u istom smjeru.
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+
Primjer je poučan: dvije rečenice koje nemaju nijednu zajedničku riječ postižu rezultat iznad 0,85. To je snaga ove metode, ali i njezina zamka. Semantička sličnost ignorira negaciju i nijanse stupnja – „plaćanje je prihvaćeno“ i „plaćanje je odbijeno“ vektorski izgledaju vrlo slično. Stoga je nikada nemoj koristiti samostalno za validaciju odgovora gdje je činjenična točnost bitna.
Kada je pitanje „odgovara li odgovor zapravo na postavljeno pitanje“, nijedna formula ne može zamijeniti prosudbu. Donja metrika relevantnosti rastavlja tu prosudbu na tri različita pitanja: Je li odgovor izravan? Ostaje li usredotočen? Je li potpun? Ova raščlamba bolja je od globalne ocjene jer ti govori u kojem smjeru trebaš ispraviti upit – opširan model i nepotpun model zahtijevaju suprotne ispravke.
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"}
Obrati pažnju na obrnutu formulaciju drugog kriterija, gdje 5 znači „nema nezahtijevanih informacija“. To omogućuje zbrajanje triju rezultata u istom smjeru, ali je kontraintuitivno za čitanje: kada dodaješ vlastite kriterije, zadrži ovu konvenciju ili ćeš dobiti prosjeke koji nagrađuju manu koju si htio kazniti.
Provjera halucinacija modela
U aplikaciji za pitanja i odgovore temeljenoj na dokumentima, odlučujuća metrika nije kvaliteta pisanja već vjernost izvoru. Princip kontrole jednostavan je: sucu predložiš izvorni kontekst i generirani odgovor te ga zamoliš da svaku tvrdnju klasificira kao podržanu kontekstom, odsutnu iz konteksta ili kontradiktornu kontekstu. Razlika između ove posljednje dvije kategorije je bitna jer tvrdnja koja je samo odsutna može biti točno opće znanje, dok je tvrdnja koja proturječi izvoru uvijek pogreška.
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"}
Skraćivanje konteksta na 3000 znakova ograničenje je kojeg moraš biti svjestan: ako izvor premašuje ovu veličinu, savršeno točne tvrdnje bit će označene kao nepodržane jednostavno zato što je odlomak koji ih opravdava odrezan. Za duge dokumente podijeli ih i procjenjuj po dijelovima umjesto da prihvatiš sustavne lažno pozitivne rezultate.
Sastavljanje reproducibilnog mjerila
Mjerilo (benchmark) nije samo još jedna metrika: to je postavka koja zamrzava skup podataka i protokol kako bi dva pokretanja bila usporediva. Klasa u nastavku mjeri relevantnost, vjernost (kada je kontekst dostupan), kašnjenje i trošak, a zatim svaki rezultat bilježi s datumom i oznakom verzije upita.
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)
Izlaz funkcije compare namjerno stavlja relevantnost i kašnjenje u isti red jer se tako donosi stvarna odluka. Model koji dobije dvije stotinke boda na relevantnosti uz udvostručenje vremena odgovora nije bolji izbor za interaktivnu aplikaciju; možda jest za noćnu obradu. Tablica ne odlučuje umjesto tebe; stavlja ti kompromis ravno pred oči.
Konačno, total_cost u ovoj implementaciji ostaje nula. Popuni ga iz polja usage koja vraća API: usporedba modela koja izostavlja trošak izostavlja kriterij koji će riješiti raspravu s tvojim financijskim timom.
Ključne točke
- Semantička sličnost mjeri značenje, ali ostaje slijepa na negaciju
- Raščlani relevantnost na zasebne kriterije umjesto globalne ocjene
- Otkrij halucinacije suočavanjem odgovora s izvornim kontekstom
- Stvori reproducibilna mjerila koja zajedno mjere kvalitetu, kašnjenje i trošak
- Kombiniraj automatske metrike i LLM-as-Judge za cjelovitu evaluaciju