Метрики и бенчмаркове
На тази страница
Урокът е актуализиран на 3 ноември 2026 г. въз основа на документацията на OpenAI: параметрите
temperatureиtop_pсе приемат само при усилие за разсъждение (reasoning effort) отnone, докато моделите GPT-5.6 разсъждават по подразбиране (medium). Заявките, които задават тези параметри, следователно трябва да уточняватreasoning={"effort": "none"}(API Responses) илиreasoning_effort="none"(Chat Completions). Източници: Using GPT-6 · GPT-5.6 Terra.
Измерване на качеството чрез метрики
Освен оценките от типа „LLM като съдия“, съществуват количествени метрики за оценка на различни аспекти на изходните данни от големите езикови модели (LLM). Тяхната стойност не се крие в по-високата точност – един добре конструиран LLM съдия забелязва неща, които никоя формула никога няма да види, – а в тяхната стабилност и ниска цена. Косинусовото сходство връща едно и също число при всяко изпълнение, струва почти нищо и следователно може да се изпълнява върху хиляди случаи при всеки комит. Тогава запазвате LLM съдията за измерения, които наистина го изискват.
Ще прегледаме основните метрики, преди да ги обединим във възпроизводими бенчмаркове.
Сравняване на смисъла, а не на думите
Сравняването на два текста символ по символ става неизползваемо веднага щом формулировката е свободна. Семантичното сходство заобикаля този проблем: всеки текст се преобразува във вектор чрез модел за вграждане (embedding), и ние измерваме ъгъла между двата вектора. Две изречения, които казват едно и също с различни думи, сочат в една и съща посока.
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+
Примерът е поучителен: две изречения без нито една обща дума получават оценка над 0.85. Това е силната страна на метода, но и неговият капан. Семантичното сходство игнорира отрицанието и нюансите на степента – „плащането беше прието“ и „плащането беше отказано“ изглеждат много сходни във векторно пространство. Следователно, никога не го използвайте самостоятелно за валидиране на отговор, когато фактическата точност е от значение.
Когато въпросът е „дали отговорът действително адресира зададения въпрос“, никаква формула не може да замени преценката. Долната оценка за релевантност разбива тази преценка на три отделни въпроса: Дали отговорът е директен? Остава ли фокусиран? Пълен ли е? Това разбиване е по-добро от глобалната оценка, защото Ви показва в коя посока да коригирате промпта – многословен модел и непълен модел изискват противоположни корекции.
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"}
Обърнете внимание на обърнатата формулировка на втория критерий, където 5 означава „липса на поискана информация“. Това позволява събирането на трите оценки в една и съща посока, но е контраинтуитивно за четене: когато добавяте свои собствени критерии, спазвайте тази конвенция, иначе ще получите средни стойности, които възнаграждават недостатъка, който сте възнамерявали да наказвате.
Проверка дали моделът не халюцинира
В приложение за въпроси и отговори, базирано на документи, решаващата метрика не е качеството на писане, а верността спрямо източника. Принципът на контрол е прост: представете на съдията оригиналния контекст и генерирания отговор и го помолете да класифицира всяко твърдение като подкрепено от контекста, липсващо в контекста или противоречащо му. Разликата между тези последни две категории е важна, защото твърдение, което просто липсва, може да бъде точно общо знание, докато твърдение, което противоречи на източника, винаги е грешка.
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"}
Съкращаването на контекста до 3000 символа е ограничение, от което трябва да сте наясно: ако източникът надвишава този размер, перфектно точни твърдения ще бъдат отчетени като неподкрепени просто защото пасажът, който ги обосновава, е бил отрязан. За дълги документи разделяйте и оценявайте по секции, вместо да приемате системни фалшиво положителни резултати.
Създаване на възпроизводим бенчмарк
Бенчмаркът не е просто още една метрика: това е настройка, която фиксира набор от данни и протокол, така че две изпълнения да са сравними. Класът по-долу измерва релевантността, верността (когато контекстът е наличен), латентността и разходите, след което запазва всеки резултат с дата и етикет по версия на промпта.
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 умишлено поставя релевантността и латентността на един ред, защото така всъщност се взема решението. Модел, който печели две стотни от точката в релевантност, докато удвоява времето за отговор, не е по-добрият избор за интерактивно приложение; може да бъде такъв за нощна обработка. Таблицата не решава вместо Вас; тя поставя компромиса точно пред очите Ви.
Накрая, total_cost остава нула в тази имплементация. Попълнете го от полетата за употреба (usage), върнати от API: сравнение на модели, което пропуска разходите, изоставя критерия, който ще реши дискусията с Вашия финансов екип.
Ключови изводи
- Семантичното сходство измерва смисъла, но остава сляпо за отрицанието
- Разбивайте релевантността на отделни критерии, вместо да използвате глобална оценка
- Откривайте халюцинациите, като противопоставите отговора на изходния контекст
- Създавайте възпроизводими бенчмаркове, които измерват качеството, латентността и разходите заедно
- Комбинирайте автоматични метрики и LLM-като-съдия за пълноценна оценка