Премини към основното съдържание
Български— Изберете език
Меню

Оценяване на вашия финално настроен модел

Урок 10 от 16 Обновен 2 ноември 2026 г. Напреднало
На тази страница
  1. Защо оценяването е от съществено значение
  2. Изграждане на тестови набор
  3. Автоматизирано оценяване
  4. Специализирани метрики
  5. Човешко оценяване
  6. Доклад за оценяването
  7. Ключови изводи

Актуализация от 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 като съдия“ е добър компромис между двете
  • Дефинирайте измерими критерии, преди да започнете
  • Ниска стойност на загубата не гарантира качество за производство