Автоматизирана оценка на подканите
На тази страница
Урокът е актуализиран на 3 ноември 2026 г. въз основа на документацията на OpenAI: параметрите
temperatureиtop_pсе приемат само при усилие за разсъждение (reasoning effort) със стойностnone, докато моделите GPT-5.6 разсъждават по подразбиране (medium). Следователно заявките, които задават тези параметри, трябва изрично да включватreasoning={"effort": "none"}(Responses API) илиreasoning_effort="none"(Chat Completions). Източници: Използване на GPT-6 · GPT-5.6 Terra.
Автоматизирана оценка на подканите
Автоматизираната оценка е основният камък на зрелия процес за инженерство на подкани (prompt engineering). Тя Ви позволява да откривате регресии, да сравнявате модели и да валидирате промените преди внедряване. Без нея всяка промяна в подканата е сляп хазарт.
Видове оценка
Три семейства оценители разделят труда в зависимост от естеството на очаквания изход и почти винаги ще комбинирате няколко от тях.
Оценка чрез точно съвпадение (Exact Match)
За задачи с един единствен очакван отговор е достатъчно директно сравнение. eval_exact_match нормализира главните/малките букви и интервалите преди сравнението: без тази предпазна мярка „Bug“ и „bug“ биха се броили за грешка, което ще Ви накара да поправяте проблем, който не съществува.
eval_set_match обработва случаи, когато отговорът е множество – например открити entities в документ или категории, присвоени на статия. Тя извежда прецизност (precision) и пълнота (recall), две стойности, които разказват различни истории: висока прецизност с ниска пълнота сигнализира за твърде предпазлив модел, който извлича само онова, в което е сигурен; обратното издава модел, който халюцинира, за да запълни пропуските. F1 ги обобщава удобно, но не ги замества за диагностика.
def eval_exact_match(prediction: str, reference: str) -> bool:
"""Точно съвпадение след нормализация."""
return prediction.strip().lower() == reference.strip().lower()
def eval_set_match(prediction: set, reference: set) -> dict:
"""Съвпадение на множества (entities, категории)."""
tp = len(prediction & reference)
fp = len(prediction - reference)
fn = len(reference - prediction)
precision = tp / (tp + fp) if (tp + fp) > 0 else 0
recall = tp / (tp + fn) if (tp + fn) > 0 else 0
f1 = (2 * precision * recall / (precision + recall)
if (precision + recall) > 0 else 0)
return {"precision": precision, "recall": recall, "f1": f1}
Семантична оценка (Embedding)
За текстови отговори, където формулировката може да варира, точното съвпадение става абсурдно: „Вашата поръчка ще бъде доставена утре“ и „Доставката е планирана за утре“ казват едно и също, но биха получили нулев резултат. Косинусовото сходство между вгражданията (embeddings) измерва семантичната близост, а не съвпадението на символи, връщайки непрекъсната оценка.
Вие задавате прага, над който един отговор се счита за приемлив. Калибрирайте го върху няколко десетки двойки, които сте класифицирали ръчно като „еквивалентни“ или „различни“, след което изберете стойността, която най-добре разделя двете групи: праг, избран на усет, произвежда резултати толкова произволни, колкото липсата на измерване, с добавената илюзия за строгост.
from openai import OpenAI
import numpy as np
client = OpenAI()
def eval_semantic_similarity(prediction: str,
reference: str) -> float:
"""Косинусово сходство между вграждания."""
response = client.embeddings.create(
model="text-embedding-3-large",
input=[prediction, reference]
)
emb_pred = np.array(response.data[0].embedding)
emb_ref = np.array(response.data[1].embedding)
similarity = float(
np.dot(emb_pred, emb_ref) /
(np.linalg.norm(emb_pred) * np.linalg.norm(emb_ref))
)
return similarity
Оценка от LLM (LLM-as-Judge)
Моделът оценява качеството на отговора. Това е единственият жизнеспособен подход, когато липсва референтен отговор: никой няма да напише ръчно „правилния“ отговор за поддръжка за двеста тикета.
Това, което прави един съдия usable, се свежда до няколко неща. Първо, използваният модел: избирате по-способен модел като съдия, тук gpt-5.6-sol, защото съдия на същото ниво като оценявания има тенденцията да валидира собствените му недостатъци. Второ, изискването за обосновка: мотивирането на всяка оценка стабилизира преценката и Ви позволява да откриете оценител, използващ грешен критерий – обосновка,讨论щаща дължината, когато критерият е бил яснота, е червен флаг. Накрая, temperature от 0.1 осигурява стабилност на оценките между различните изпълнения.
def eval_llm_judge(question: str, prediction: str,
criteria: list[str]) -> dict:
"""Оценка от модел-съдия."""
criteria_text = "\n".join(
f"- {c}: score from 1 to 5" for c in criteria
)
response = client.responses.create(
model="gpt-5.6-sol", # По-способен модел като съдия
reasoning={"effort": "none"}, # temperature изисква effort none
instructions="You are an expert, impartial evaluator.",
input=f"""Evaluate this response according to the following criteria:
Question asked: {question}
Response to evaluate: {prediction}
Criteria:
{criteria_text}
For each criterion, give a score from 1 to 5 with justification.""",
text={
"format": {
"type": "json_schema",
"name": "evaluation",
"schema": {
"type": "object",
"properties": {
"scores": {
"type": "array",
"items": {
"type": "object",
"properties": {
"criterion": {"type": "string"},
"score": {"type": "integer"},
"justification": {"type": "string"}
},
"required": ["criterion", "score",
"justification"],
"additionalProperties": False
}
},
"overall_score": {"type": "number"},
"verdict": {"type": "string"}
},
"required": ["scores", "overall_score", "verdict"],
"additionalProperties": False
},
"strict": True
}
},
temperature=0.1
)
return json.loads(response.output_text)
Пълен конвейер за оценка
EvalPipeline сглобява тези строителни блокове: той зарежда тестови набор, изпълнява подканата за всеки случай, прилага всички предоставени оценители и агрегира резултатите. Оценителите се предават като списък от функции, всички извиквани с един и същи подпис; добавянето на метрика следователно не изисква модификация на конвейера и можете да стартирате точно съвпадение, семантично сходство и съдия при едно и също изпълнение, без да плащате три пъти за генериране.
Методът summary също така акумулира консумираните токени. Този привидно второстепенен ред Ви предпазва от често срещан капан: версия на подкана, която печели две точки в оценката, но утроява сметката, не е непременно правилният избор и е по-добре да научите това по време на търговията с компромиси, отколкото когато пристигне месечната фактура.
import json
from dataclasses import dataclass
from pathlib import Path
@dataclass
class TestCase:
"""Тестови случай за оценка."""
input_text: str
expected_output: str = None
metadata: dict = None
class EvalPipeline:
"""Автоматизиран конвейер за оценка."""
def __init__(self, test_suite_path: str):
"""Зарежда тестовия набор от JSON файл."""
data = json.loads(Path(test_suite_path).read_text())
self.test_cases = [TestCase(**tc) for tc in data]
self.results = []
def run(self, prompt_config: dict,
evaluators: list[callable]) -> dict:
"""Изпълнява всички тестове и оценява резултатите."""
self.results = []
for tc in self.test_cases:
# Генериране на отговор
response = client.responses.create(
model=prompt_config["model"],
reasoning={"effort": "none"}, # temperature изисква effort none
instructions=prompt_config["system_prompt"],
input=tc.input_text,
temperature=prompt_config.get("temperature", 0.1)
)
prediction = response.output_text
# Оценка с всеки оценител
scores = {}
for evaluator in evaluators:
score = evaluator(
question=tc.input_text,
prediction=prediction,
reference=tc.expected_output
)
scores[evaluator.__name__] = score
self.results.append({
"input": tc.input_text,
"expected": tc.expected_output,
"prediction": prediction,
"scores": scores,
"tokens": {
"input": response.usage.input_tokens,
"output": response.usage.output_tokens
}
})
return self.summary()
def summary(self) -> dict:
"""Обобщава резултатите от оценката."""
if not self.results:
return {"error": "No results"}
# Агрегиране на оценките по оценител
all_scores = {}
for result in self.results:
for eval_name, score in result["scores"].items():
if eval_name not in all_scores:
all_scores[eval_name] = []
if isinstance(score, (int, float)):
all_scores[eval_name].append(score)
elif isinstance(score, dict) and "f1" in score:
all_scores[eval_name].append(score["f1"])
summary = {
"total_tests": len(self.results),
"average_scores": {
name: sum(scores) / len(scores)
for name, scores in all_scores.items()
if scores
},
"total_token_cost": sum(
r["tokens"]["input"] + r["tokens"]["output"]
for r in self.results
)
}
return summary
Тестови набор: Формат
Форматът на тестовия набор остава умишлено минималистичен: вход, очакван изход и метаданни в свободен формат. Тези метаданни са по-полезни, отколкото изглежда – чрез тагиране на всеки случай по категория, Вие разбивате оценките и откривате, че Вашият класификатор не се проваля на случаен принцип, а върху конкретно семейство заявки, което глобалното средно от 88% не разкрива. Трите примера по-долу също показват какво трябва да съдържа един добър набор: ясни случаи, като срив при стартиране, но и случаи, които граничат с друга категория – въпрос за липсваща функция прилича много на доклад за бъг и именно на тази граница се решава качеството на класификатора.
[
{
"input_text": "My package hasn't arrived",
"expected_output": "complaint",
"metadata": {"category": "delivery"}
},
{
"input_text": "How do I enable dark mode?",
"expected_output": "question",
"metadata": {"category": "feature"}
},
{
"input_text": "The app crashes on startup on iOS 18",
"expected_output": "bug",
"metadata": {"category": "technical"}
}
]
Интеграция в CI/CD
Изпълнявайте оценката при всяка промяна на подканата. Функцията ci_eval_check превръща измерването в предпазна ограда: тя стартира конвейера, сравнява средната оценка с праг и връща булева стойност, която Вашата интеграционна верига интерпретира като успех или провал на билда. Промяна, която сваля прецизността под 85%, вече не достига до продукция, точно както счупен unit тест блокира сливането (merge).
Задайте прага въз основа на оценката, вече постигната от текущата версия, а не от идеал. Задайте го твърде високо и ще осъдите екипа да заобикаля проверката с временни деактивации, които стават постоянни; задайте го твърде ниско и няма да проверявате нищо, докато показвате зелен значок. Накрая, имайте предвид, че наборът трябва да остане представителен за реалния трафик: праг, постигнат върху двадесет случая, написани преди две години, не доказва нищо за днешните заявки.
def ci_eval_check(prompt_config: dict,
test_suite: str,
min_score: float = 0.85) -> bool:
"""CI/CD бариера: проверява дали подканата отговаря на минималната оценка."""
pipeline = EvalPipeline(test_suite)
def accuracy(question, prediction, reference):
return 1.0 if prediction.strip().lower() == reference.strip().lower() else 0.0
results = pipeline.run(prompt_config, [accuracy])
avg_score = results["average_scores"].get("accuracy", 0)
print(f"Average score: {avg_score:.2%}")
print(f"Minimum threshold: {min_score:.2%}")
if avg_score < min_score:
print("FAILURE: score below threshold")
return False
print("SUCCESS: prompt validated")
return True
Табло за оценка (Dashboard)
Проследявайте еволюцията на оценките във времето. Една единствена оценка не казва нищо; поредицата разказва историята на Вашата подкана и отговаря на въпроса, който винаги възниква в срещите: правим ли прогрес? Функцията по-долу генерира Markdown таблица, поставяща рамо до рамо за всяка версия средната оценка, консумираните токени и оценената цена. Форматът не е случаен: той се поставя директно в pull request, правейки сравнението четимо за хора, които никога няма да отворят Вашия код.
def comparison_report(results: dict[str, dict]) -> str:
"""Генерира сравнителен доклад между версиите на подканите."""
report = "# Comparative Evaluation Report\n\n"
report += "| Version | Average Score | Average Tokens | Cost |\n"
report += "|---------|---------------|----------------|------|\n"
for version, data in results.items():
score = data.get("average_scores", {})
score_val = list(score.values())[0] if score else 0
tokens = data.get("total_token_cost", 0)
report += (f"| {version} | {score_val:.2%} | "
f"{tokens} | ${tokens * 5 / 1e6:.4f} |\n")
return report
Настройте Вашите предпазни огради
Изградете набор от двадесет тестови случая за реална подкана, като поставите шепа гранични случаи, вместо двадесет удобни примера: набор, който минава на 100% от първия опит, не Ви учи на нищо. Имплементирайте трите типа оценители и ги стартирайте заедно върху две версии на Вашата подкана. Точното съвпадение дава чиста цифра, семантичното сходство улавя легитимни преформулировки, а съдията осветлява случаите, в които първите две не са съгласни – тези несъгласия са най-богати на уроци за това какво всъщност очаквате от модела.
Сравнете, идентифицирайте печелившата версия, след което настройте CI скрипта, който блокира внедряването, ако оценката спадне. Ще разберете, че системата работи в деня, в който отхвърли промяна, която сте смятали за очевидна.
Ключови изводи
- Автоматизираната оценка е съществена за итерации с увереност
- Комбинирайте оценка чрез точно съвпадение, семантична оценка и LLM-as-judge според нуждите
- Поддържайте тестови набор, който еволюира с Вашето приложение
- Интегрирайте оценката във Вашия CI/CD с минимален праг
- Използвайте по-способен модел като съдия, за да оцените по-евтин модел
- Документирайте оценките на всяка версия, за да проследявате еволюцията
Проверете знанията си
Разширени техники и индустриализация: финалната проверка.
1. Какво съдържа една ефективна системна подкана?
Отговор: Роля, обхват, правила за поведение, формат на изхода и обработка на гранични случаи – написана като спецификация, тествана като код.
2. Кога трябва да използвате self-consistency?
Отговор: При проблеми с разсъждение, които имат проверими отговори: генерирайте множество независими разсъждения и запазете отговора на мнозинството – вариацията става съюзник.
3. Какво гарантира JSON режимът с налагане на схема?
Отговор: Изход, строго съответстващ на схемата (типове, задължителни полета, enums) – валидиран от страна на API и повторено валидиран в кода (JSON Schema, Zod) за верига без изненади.
4. Какво е grounding?
Отговор: Закотвяне на отговорите в предоставени факти (документи, извлечени данни), а не в паметта на модела – с изискването да се цитират или въздържат от външни източници.
5. Каква е целта на каталог с версионирани подкани?
Отговор: Да третира подканите като артефакти: версии, A/B тестове, автоматизирани оценки при всяка промяна – знаете какво работи в продукция и защо.
Финалният цикъл на курса – версиониране, тестване, автоматична оценка – трансформира занаятчийското инженерство на подкани в екипна практика.