Оценка качества дообученной модели (бенчмарки, BLEU, ROUGE, perplexity)

Оценка качества дообученной модели (бенчмарки, BLEU, ROUGE, perplexity)

Оценка качества — обязательный этап после каждой итерации fine-tuning. Без структурированной системы метрик невозможно понять, стало ли лучше после дообучения, где именно модель ошибается, и когда нужно остановить обучение. Правильная оценка экономит время на ненужные итерации и предотвращает деплой деградировавшей модели.

Иерархия метрик оценки

Уровень 1: Автоматические метрики Быстрые, дешёвые, вычисляются без участия человека. Дают грубую оценку.

Уровень 2: LLM-as-judge Сильная модель (GPT-4o, Claude 3.5 Sonnet) оценивает ответы тестируемой модели. Хорошо коррелирует с человеческой оценкой при правильном промпте.

Уровень 3: Человеческая оценка Золотой стандарт, но дорого. Применяем для финальной валидации и калибровки нижних уровней.

Метрики для задач генерации текста

BLEU (Bilingual Evaluation Understudy):

from nltk.translate.bleu_score import corpus_bleu, SmoothingFunction

references = [[ref.split()] for ref in reference_list]
hypotheses = [hyp.split() for hyp in hypothesis_list]

bleu_4 = corpus_bleu(
    references, hypotheses,
    weights=(0.25, 0.25, 0.25, 0.25),
    smoothing_function=SmoothingFunction().method1
)

BLEU измеряет n-gram overlap между сгенерированным и референсным текстом. Диапазон 0–1 (или 0–100). Хорош для перевода, суммаризации, структурированной генерации. Плохо работает для открытой генерации с множеством корректных вариантов.

ROUGE (Recall-Oriented Understudy for Gisting Evaluation):

from rouge_score import rouge_scorer

scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)

scores = scorer.score(reference, hypothesis)
# scores.rouge1.fmeasure, scores.rouge2.fmeasure, scores.rougeL.fmeasure

• ROUGE-1: unigram overlap
• ROUGE-2: bigram overlap
• ROUGE-L: longest common subsequence (учитывает порядок)

ROUGE лучше BLEU для задач суммаризации.

METEOR — лучше BLEU для русского языка, учитывает морфологические варианты:

from nltk.translate.meteor_score import meteor_score
score = meteor_score([reference.split()], hypothesis.split())

Perplexity: метрика уверенности модели

Perplexity измеряет, насколько «удивлена» модель тестовыми данными:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

def compute_perplexity(model, tokenizer, texts: list[str]) -> float:
    total_loss = 0
    total_tokens = 0

    model.eval()
    with torch.no_grad():
        for text in texts:
            encodings = tokenizer(text, return_tensors="pt").to(model.device)
            outputs = model(**encodings, labels=encodings["input_ids"])
            total_loss += outputs.loss.item() * encodings["input_ids"].shape[1]
            total_tokens += encodings["input_ids"].shape[1]

    avg_loss = total_loss / total_tokens
    return torch.exp(torch.tensor(avg_loss)).item()

# Применение
ppl = compute_perplexity(model, tokenizer, test_texts)
print(f"Perplexity: {ppl:.2f}")

Снижение perplexity на тестовом наборе после fine-tuning означает, что модель лучше «понимает» целевой домен. Рост perplexity на общем бенчмарке — признак catastrophic forgetting.

Метрики для задач классификации и извлечения

from sklearn.metrics import classification_report, f1_score
import json

def evaluate_classification(model_outputs: list, ground_truth: list) -> dict:
    """Оценка классификации через LLM"""
    predictions = []
    for output in model_outputs:
        try:
            # Предполагаем JSON-вывод с полем "category"
            pred = json.loads(output)["category"]
        except:
            pred = "parse_error"
        predictions.append(pred)

    report = classification_report(ground_truth, predictions, output_dict=True)
    return {
        "macro_f1": report["macro avg"]["f1-score"],
        "weighted_f1": report["weighted avg"]["f1-score"],
        "accuracy": report["accuracy"],
        "per_class": {k: v for k, v in report.items() if isinstance(v, dict) and k not in ["macro avg", "weighted avg"]}
    }

LLM-as-judge: практическая реализация

from openai import OpenAI

JUDGE_PROMPT = """Ты — строгий эксперт, оценивающий качество ответов AI-ассистента.

Вопрос: {question}

Ответ ассистента: {answer}

Референсный ответ: {reference}

Оцени ответ по критериям (каждый 1–5):
1. Фактическая точность
2. Полнота охвата темы
3. Структурированность
4. Соответствие стилю

Верни JSON: {{"accuracy": X, "completeness": X, "structure": X, "style": X, "overall": X, "reasoning": "..."}}"""

def llm_judge(question: str, answer: str, reference: str, client: OpenAI) -> dict:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "user",
            "content": JUDGE_PROMPT.format(question=question, answer=answer, reference=reference)
        }],
        response_format={"type": "json_object"},
        temperature=0.1
    )
    return json.loads(response.choices[0].message.content)

Практический пример: комплексная оценка fine-tuned модели

Базовая модель: Llama 3.1 8B Instruct. Fine-tuned модель: QLoRA r=16, 2000 примеров юридических документов.

Perplexity на MMLU выросла на 11% — умеренный catastrophic forgetting. Приемлемо для узкоспециализированного use-case.

Мониторинг после деплоя

import mlflow

# Автоматическое логирование при каждом запросе
def log_inference_quality(prompt, response, user_feedback):
    with mlflow.start_run(run_name="production-monitoring"):
        mlflow.log_metrics({
            "response_length": len(response.split()),
            "refusal_detected": int("не могу" in response.lower()),
            "user_rating": user_feedback.get("rating", -1),
        })

Сроки оценки

• Разработка evaluation pipeline: 3–5 дней
• Автоматическая оценка (все метрики): несколько часов
• LLM-as-judge (1000 примеров): 1–2 дня (стоимость ~$5–20)
• Человеческая оценка (200 примеров): 1 неделя
• Итого на оценку одной итерации: 1–2 недели