Оценяване на вашия финално настроен модел
На тази страница
Актуализация от 2 ноември 2026 г. — Наличност на финална настройка. Услугата за самостоятелна финална настройка на OpenAI се прекратява постепенно: от 7 май 2026 г. организациите, които никога не са я използвали, вече не могат да създават задачи; от 2 юли трябва да сте използвали финално настроен модел през последните 60 дни; а считано от 6 януари 2027 г. никой клиент няма да може да стартира нови задачи. Вече обучените модели остават използваеми до оттеглянето на базовия им модел. Този курс остава полезен за разбиране и използване на съществуващ модел; за нови проекти дайте приоритет на инженерството на подкани (prompt engineering), RAG и оценяването.
Защо оценяването е от съществено значение
Успешната финална настройка не се измерва само със загубата (loss). Истинският въпрос е: вашият финално настроен модел действително ли е по-добър от базовия модел за вашия случай на употреба? Една плавно намаляваща крива доказва единствено, че моделът се е научил да възпроизвежда вашите примери; тя не казва нищо за поведението му при невиждани преди заявки. В този урок ще видите как да изградите строг протокол за оценяване, комбиниращ автоматизирани метрики, оценяване от друг LLM и човешки преглед.
Изграждане на тестови набор
Вашият тестови набор трябва да бъде отделен както от данните за обучение, така и от тези за валидиране. Разликата е важна: наборът за валидиране следи процеса на обучение и следователно влияе върху решенията ви за хиперпараметри, което постепенно го замърсява. Тестовият набор, напротив, се отваря едва след като моделът е фиксиран. Той представлява реалните ситуации, с които моделът ще се сблъска в производствена среда, със същите пропорции на лесни и сложни случаи. Разпределение 80/10/10 на предварително разбъркан корпус е разумна отправна точка.
import json
import random
def prepare_datasets(file: str, ratios: tuple = (0.8, 0.1, 0.1)):
"""Splits data into train/validation/test."""
with open(file, "r") as f:
examples = [json.loads(l) for l in f]
random.shuffle(examples)
n = len(examples)
i1 = int(n * ratios[0])
i2 = int(n * (ratios[0] + ratios[1]))
datasets = {
"train": examples[:i1],
"validation": examples[i1:i2],
"test": examples[i2:]
}
for name, data in datasets.items():
with open(f"{name}.jsonl", "w") as f:
for ex in data:
f.write(json.dumps(ex, ensure_ascii=False) + "\n")
print(f"{name}: {len(data)} examples")
return datasets
prepare_datasets("all_data.jsonl")
Автоматизирано оценяване
Оценяване базирано на метрики
Принципът е прост: за всеки тестов пример премахнете съобщението на асистента – това е очакваният отговор, който моделът не трябва да вижда – подайте останалата част и запазете входа, референтния отговор и генерирания отговор един до друг. Тази структура с три колони е основата за всичко, което следва; използването ѝ за изчисляване на метрики или качествена преценка е просто въпрос на последваща обработка.
from openai import OpenAI
client = OpenAI()
def evaluate_model(model: str, test_examples: list[dict]) -> dict:
"""Evaluates a model on a test set."""
results = []
for ex in test_examples:
# Extract the question (without the expected answer)
input_messages = [
m for m in ex["messages"] if m["role"] != "assistant"
]
expected_answer = next(
m["content"] for m in ex["messages"] if m["role"] == "assistant"
)
# Get the model's response
response = client.responses.create(
model=model,
input=input_messages
)
model_answer = response.output_text
results.append({
"input": input_messages[-1]["content"],
"expected": expected_answer,
"obtained": model_answer
})
return results
Оценяване тип „LLM като съдия“
Мощна техника е използването на високопроизводителен модел за оценяване на качеството на отговорите. Сравнението дума по дума с референтния отговор става неизползваемо веднага щом са приемливи множество формулировки; съдията обаче оценява същината. Качеството на неговата присъда зависи изцяло от точността на подканата: четири критерия, оценени от 1 до 5, принудителен JSON изход и коментар в свободен текст, който ще използвате по-късно, за да разберете неуспехите. Предвидете случаи, в които изходът не може да бъде анализиран, вместо да позволявате на изключение да прекъсне кампанията.
def evaluate_with_judge(results: list[dict]) -> list[dict]:
"""Uses gpt-5.6-sol as a judge to evaluate responses."""
evaluations = []
for r in results:
judge_prompt = f"""Evaluate the quality of the obtained response compared to the expected response.
Question: {r['input']}
Expected response: {r['expected']}
Obtained response: {r['obtained']}
Criteria (rate each from 1 to 5):
1. Accuracy: Is the information correct?
2. Completeness: Are all important points covered?
3. Style: Is the tone and format appropriate?
4. Conciseness: Is the response an appropriate length?
Respond in JSON: {{"accuracy": N, "completeness": N, "style": N, "conciseness": N, "comment": "..."}}"""
response = client.responses.create(
model="gpt-5.6-sol",
input=judge_prompt
)
try:
evaluation = json.loads(response.output_text)
evaluations.append(evaluation)
except json.JSONDecodeError:
evaluations.append({"error": "Response not parseable"})
return evaluations
Специализирани метрики
Двата предишни подхода работят добре за писмени отговори. Щом изходът на вашия модел има фиксирана структура, стават възможни по-преки измервания, които ви спестяват отклонението през съдия.
За класификация
Когато очакваният изход принадлежи към затворено множество – категория на билет, сантимент, код на продукт – точното съвпадение отново става релевантно. Нормализирайте главните/малките букви и интервалите преди сравнението; в противен случай „Urgent“ спрямо „urgent“ ще се брои за грешка и ще изкриви вашия процент.
def classification_metrics(results: list[dict]) -> dict:
"""Calculates precision, recall, and F1 for a classification task."""
correct = sum(
1 for r in results
if r["expected"].strip().lower() == r["obtained"].strip().lower()
)
total = len(results)
precision = correct / total if total > 0 else 0
print(f"Precision: {precision:.2%} ({correct}/{total})")
return {"precision": precision, "correct": correct, "total": total}
За извикване на функции
Извикването на функции се оценява по две оси, които трябва да се измерват отделно. Модел, който избира правилната функция, но греши в параметъра, се проваля различно от такъв, който извиква напълно грешен инструмент: първият проблем се решава с примери за извличане, вторият – с примери за дискриминация. Един единствен глобален резултат би маскирал това разграничение и би ви оставил да работите на сляпо.
def function_calling_metrics(results: list[dict]) -> dict:
"""Evaluates the quality of function calls."""
stats = {"correct_function": 0, "correct_params": 0, "total": 0}
for r in results:
stats["total"] += 1
if r.get("expected_function") == r.get("obtained_function"):
stats["correct_function"] += 1
if r.get("expected_params") == r.get("obtained_params"):
stats["correct_params"] += 1
print(f"Correct function: {stats['correct_function']}/{stats['total']}")
print(f"Correct parameters: {stats['correct_params']}/{stats['total']}")
return stats
Човешко оценяване
Автоматизираното оценяване не улавя всичко. Леко снизходителен тон, фраза, която не се възприема добре от клиентите ви, технически правилен, но неизползваем отговор: тези недостатъци се откриват само с човешко око. Протоколът е прост. Изберете на случаен принцип между двадесет и петдесет отговора, никога случаите, които вече сте маркирали като проблемни, иначе просто ще измервате собствената си селективна пристрастност. След това дефинирайте ясни, измерими критерии и ги формализирайте в стандартизирана скала за оценяване, така че двама рецензенти да съдят едно и също нещо.
Накрая, накарайте няколко души да оценят и изчислете съгласуваността между оценителите. Силното несъгласие не означава непременно лош модел: най-често то разкрива, че вашата скала остава двусмислена и се нуждае от изясняване, преди да можете да направите каквито и да е заключения.
Примерна скала за оценяване
| Criterion | 1 (Poor) | 3 (Acceptable) | 5 (Excellent) |
|---|---|---|---|
| Relevance | Off-topic | Partially relevant | Perfectly targeted |
| Tone | Inappropriate | Acceptable but plain | Perfectly aligned |
| Format | Not followed | Partially followed | Perfectly followed |
Доклад за оценяването
Един последен рефлекс отличава оценяването от вземането на решение: запишете и двете семейства резултати в единен доклад, придружен от ясна препоръка. Прагът, който задавате – тук средна човешка оценка от 4 за преминаване към производство, 3 за итерация върху данните – трябва да бъде избран преди стартирането на кампанията. Решен впоследствие, той винаги се нагажда към резултата, който сте се надявали да получите.
def evaluation_report(auto_results: dict, human_results: dict):
"""Generates a combined evaluation report."""
print("=" * 60)
print("FINE-TUNED MODEL EVALUATION REPORT")
print("=" * 60)
print(f"\nAutomated metrics:")
for k, v in auto_results.items():
print(f" {k}: {v}")
print(f"\nHuman evaluation:")
for k, v in human_results.items():
print(f" {k}: {v}")
print(f"\nRecommendation:")
average_score = sum(human_results.values()) / len(human_results)
if average_score >= 4:
print(" Model is ready for production")
elif average_score >= 3:
print(" Improvements needed—iterate on data")
else:
print(" Insufficient results—rethink your approach")
Ключови изводи
- Винаги отделяйте независим тестови набор (нито за обучение, нито за валидиране)
- Комбинирайте автоматизирано и човешко оценяване
- Оценяването тип „LLM като съдия“ е добър компромис между двете
- Дефинирайте измерими критерии, преди да започнете
- Ниска стойност на загубата не гарантира качество за производство