Metryki i punkty odniesienia
Na tej stronie
Lekcja zaktualizowana 3 listopada 2026 r. na podstawie dokumentacji OpenAI: parametry
temperatureitop_psą akceptowane wyłącznie przy wysiłku rozumowania (reasoning effort) ustawionym nanone, podczas gdy modele GPT-5.6 domyślnie przeprowadzają rozumowanie (medium). Wywołania ustawiające te parametry muszą zatem określaćreasoning={"effort": "none"}(API Responses) lubreasoning_effort="none"(Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.
Pomiar jakości za pomocą metryk
Poza ocenami typu LLM-as-Judge istnieją metryki ilościowe służące do ewaluacji różnych aspektów wyjść modeli językowych (LLM). Ich wartość nie polega na większej dokładności – dobrze skonstruowany sędzia LLM dostrzega rzeczy, których żadna formuła nigdy nie wychwyci – lecz na stabilności i niskim koszcie. Podobieństwo kosinusowe zwraca dokładnie tę samą liczbę przy każdym uruchomieniu, kosztuje niemal nic i dlatego może być stosowane do tysięcy przypadków przy każdym commicie. Sędzią LLM posługujesz się wtedy, gdy potrzebujesz oceny wymiarów, które tego rzeczywiście wymagają.
Przejrzymy kluczowe metryki, zanim złożymy je w powtarzalne punkty odniesienia (benchmarki).
Porównywanie znaczenia, a nie słów
Porównywanie dwóch tekstów znak po znaku staje się bezużyteczne, gdy tylko frazowanie jest dowolne. Podobieństwo semantyczne omija ten problem: każdy tekst jest konwertowany na wektor przez model osadzania (embedding), a my mierzymy kąt między tymi dwoma wektorami. Dwa zdania mówiące to samo innymi słowami wskazują ten sam kierunek.
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+
Przykład jest pouczający: dwa zdania nie mające ani jednego wspólnego słowa osiągają wynik powyżej 0,85. To siła tej metody, ale i jej pułapka. Podobieństwo semantyczne ignoruje przeczenia i niuanse stopnia – „płatność została zaakceptowana“ i „płatność została odrzucona“ wyglądają bardzo podobnie w przestrzeni wektorowej. Nigdy więc nie używaj tej metryki w izolacji do walidacji odpowiedzi, gdzie liczy się dokładność faktograficzna.
Gdy pytanie brzmi: „czy odpowiedź rzeczywiście dotyczy postawionego pytania“, żadna formuła nie zastąpi osądu. Poniższy wynik relewancji rozbija ten osąd na trzy odrębne pytania: Czy odpowiedź jest bezpośrednia? Czy pozostaje w temacie? Czy jest kompletna? Taki rozkład jest lepszy niż wynik globalny, ponieważ wskazuje kierunek korekty promptu – model gadatliwy i model niekompletny wymagają przeciwnych działań naprawczych.
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"}
Zwróć uwagę na odwrócone sformułowanie drugiego kryterium, gdzie 5 oznacza „brak nieżądzanych informacji“. Pozwala to sumować trzy wyniki w tym samym kierunku, ale jest to intuicyjnie mylące przy czytaniu: gdy dodajesz własne kryteria, zachowaj tę konwencję, inaczej otrzymasz średnie, które nagradzają wadę, którą zamierzałeś ukarać.
Weryfikacja, czy model nie halucynuje
W aplikacji typu Q&A opartej na dokumentach decydującą metryką nie jest jakość pisania, lecz wierność źródłu. Zasada kontroli jest prosta: przedstaw sędziowi oryginalny kontekst i wygenerowaną odpowiedź, a następnie poproś o sklasyfikowanie każdego stwierdzenia jako popartego przez kontekst, nieobecnego w kontekście lub sprzecznego z nim. Rozróżnienie między tymi dwoma ostatnimi kategoriami ma znaczenie, ponieważ stwierdzenie jedynie nieobecne może być trafną wiedzą ogólną, podczas gdy stwierdzenie sprzeczne ze źródłem jest zawsze błędem.
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"}
Skrócenie kontekstu do 3000 znaków to limit, którego musisz być świadomy: jeśli źródło przekracza ten rozmiar, całkowicie trafne stwierdzenia zostaną policzone jako niepoparte wyłącznie dlatego, że fragment je uzasadniający został ucięty. W przypadku długich dokumentów podziel tekst i przeprowadź ewaluację sekcjami, zamiast godzić się na systematyczne fałszywe wyniki pozytywne.
Tworzenie powtarzalnego benchmarku
Benchmark to nie tylko kolejna metryka: to konfiguracja, która zamraża zbiór danych i protokół, tak aby dwa uruchomienia były ze sobą porównywalne. Poniższa klasa mierzy relewancję, wierność (gdy dostępny jest kontekst), opóźnienie (latencję) i koszt, a następnie przechowuje każdy wynik z datą i etykietą wersji promptu.
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)
Wyjście metody compare celowo umieszcza relewancję i latencję w tej samej linii, ponieważ tak właśnie podejmuje się decyzje. Model, który zyskuje dwie setne punktu w relewancji, podwajając czas odpowiedzi, nie jest lepszym wyborem dla aplikacji interaktywnej; może nim być dla przetwarzania nocnego. Tabela nie decyduje za ciebie; stawia kompromis bezpośrednio przed twoimi oczami.
Na koniec, total_cost w tej implementacji pozostaje równe zero. Uzupełnij je na podstawie pól usage zwracanych przez API: porównanie modeli pomijające koszt pomija kryterium, które rozstrzygnie dyskusję z twoim zespołem finansowym.
Kluczowe wnioski
- Podobieństwo semantyczne mierzy znaczenie, ale pozostaje ślepe na przeczenia
- Rozbijaj relewancję na odrębne kryteria zamiast stosować wynik globalny
- Wykrywaj halucynacje, konfrontując odpowiedź z kontekstem źródłowym
- Twórz powtarzalne benchmarki mierzące jednocześnie jakość, latencję i koszt
- Łącz automatyczne metryki z podejściem LLM-as-Judge, aby uzyskać kompletną ewaluację