Измеряем качество: eval-наборы, сравнение версий и регрессии

Eval — это юнит-тесты для недетерминированного кода

Eval (оценка) состоит из четырёх частей:

1. Набор задач — вход для агента. Например, 50 реальных багов.
2. Грейдер — функция, которая решает: задача решена или нет.
3. Прогон — запускаем агента на каждой задаче, иногда по несколько раз.
4. Сравнение — считаем долю успехов и сравниваем со старой версией.

const results = [];
for (const task of tasks) {
  const output = await runAgent(task.input);   // агент отвечает по-разному
  results.push({ id: task.id, pass: grade(output, task) });
}
const passRate = results.filter(r => r.pass).length / results.length;
console.log(`Решено: ${Math.round(passRate * 100)}%`);

Грейдеры, метрики и откуда брать задачи

Виды грейдеров — от самых надёжных к самым гибким:

• Точное совпадение. Ответ равен эталону. Подходит для классификации: «billing», «bug», «question».
• Структура или шаблон. Ответ — валидный JSON с нужными полями, номер заказа подходит под регулярное выражение.
• Запуск кода и тестов. Агент исправил баг — запускаем тесты. Для кода это лучший грейдер: проверяет результат, а не слова.
• LLM-судья (LLM-as-judge). Другая модель оценивает ответ по рубрике — списку критериев. Нужен там, где нет одного правильного ответа: письмо клиенту, объяснение, ревью.

Метрики. Главная — доля успехов (pass rate). Ещё две полезны для агентов:

• pass@k — хотя бы одна из k попыток успешна. Важно, если можно сделать несколько попыток и выбрать лучшую.
• pass^k — все k попыток успешны. Важно для надёжности: агент в проде должен справляться каждый раз, а не иногда.

И не забывайте про цену и время на задачу. Версия на 2% лучше, но вдвое дороже — не всегда победа.

Откуда брать задачи. Лучшие задачи — настоящие: закрытые баги с тестом, частые тикеты, сессии, где агент ошибся. Каждая ошибка агента в работе — кандидат в eval-набор, чтобы она не повторилась.

import json
import statistics

def grade_exact(output: str, case: dict) -> bool:
    return output.strip().lower() == case["expected"].lower()

def run_eval(cases: list[dict], run_agent, grader, repeats: int = 3) -> dict:
    per_case = {}
    for case in cases:
        passes = [grader(run_agent(case["input"]), case) for _ in range(repeats)]
        per_case[case["id"]] = sum(passes) / repeats   # доля успехов на одной задаче
    return {
        "pass_rate": statistics.mean(per_case.values()),
        "per_case": per_case,                         # пригодится для поиска регрессий
    }

with open("evals/tickets.jsonl", encoding="utf-8") as f:
    cases = [json.loads(line) for line in f]

report = run_eval(cases, run_agent=my_agent, grader=grade_exact)
print(f"Решено: {report['pass_rate']:.0%}")

interface EvalCase { id: string; input: string; expected: string }
type Grader = (output: string, c: EvalCase) => boolean;

async function runEval(
  cases: EvalCase[],
  runAgent: (input: string) => Promise,
  grader: Grader,
  repeats = 3,
) {
  const perCase: Record = {};
  for (const c of cases) {
    let ok = 0;
    for (let i = 0; i < repeats; i++) {
      if (grader(await runAgent(c.input), c)) ok++;
    }
    perCase[c.id] = ok / repeats;
  }
  const values = Object.values(perCase);
  return { passRate: values.reduce((s, x) => s + x, 0) / values.length, perCase };
}

const exact: Grader = (out, c) => out.trim().toLowerCase() === c.expected.toLowerCase();

<?php
// Грейдер: прошли ли тесты после правки агента
function gradeByTests(string $workdir, string $testFilter): bool
{
    $cmd = sprintf(
        'cd %s && vendor/bin/phpunit --filter %s 2>&1',
        escapeshellarg($workdir),
        escapeshellarg($testFilter),
    );
    exec($cmd, $output, $exitCode);
    file_put_contents($workdir . '/eval-log.txt', implode("\n", $output));
    return $exitCode === 0;
}

$pass = gradeByTests('/tmp/eval/case-42', 'VatCalculatorTest');
echo $pass ? "PASS\n" : "FAIL\n";

import { spawnSync } from "node:child_process";

// Грейдер: запускаем тесты в копии репозитория, где работал агент
export function gradeByTests(workdir, testPattern) {
  const r = spawnSync("npx", ["vitest", "run", testPattern], {
    cwd: workdir,
    encoding: "utf8",
    timeout: 120_000,       // зависший тест — тоже провал
  });
  return { pass: r.status === 0, log: (r.stdout || "") + (r.stderr || "") };
}

Шум, регрессии и честное сравнение

Шум. Допустим, старая версия решила 14 задач из 20 (70%), новая — 16 из 20 (80%). Кажется, стало лучше. Но при 20 задачах разброс огромный: у той же самой версии в другой день вполне может выйти и 60%, и 85%. Простое правило: погрешность доли примерно равна 2 · √(p·(1−p)/n). Для p = 0,7 и n = 20 это ±20%. Для n = 200 — уже ±6,5%. Чем больше задач, тем меньше шум.

Регрессии. Новая версия может поднять общий процент и при этом сломать важный сценарий. Например, стала лучше писать отчёты, но перестала отказываться от опасной операции. Поэтому смотрят не только на общий процент, но и на каждую задачу отдельно.

A/B-сравнение. Меняйте одну вещь за раз: скил, промпт или модель. Прогоняйте обе версии на одном и том же наборе. Иначе непонятно, что дало эффект.

Риски LLM-судьи. Судья — тоже модель, и у него есть перекосы. Он любит длинные ответы, предпочитает первый вариант при сравнении двух и бывает мягок к текстам своей же модели. Что помогает: конкретная рубрика вместо «оцени качество», перестановка вариантов местами, сверка судьи с оценками людей на 20–30 примерах.

Ты проверяешь ответ службы поддержки. Оцени ответ по рубрике.
Для каждого пункта ответь true или false и коротко объясни.

Рубрика:
1. tone: тон вежливый, без упрёков клиенту.
2. answer: в ответе есть прямой ответ на вопрос клиента.
3. no_promises: нет обещаний, которых нет в правилах (возврат, скидка, сроки).
4. next_step: клиенту понятно, что делать дальше.

Вопрос клиента:
<question>{{question}}</question>

Ответ, который проверяем:
<answer>{{answer}}</answer>

Верни только JSON:
{"tone": {"pass": true, "why": "..."}, "answer": {...}, "no_promises": {...}, "next_step": {...}}

pass@k = 1 − C(n − c, k) / C(n, k)

C(a, b) — число сочетаний «из a по b».
C(n − c, k) / C(n, k) — шанс вытащить k попыток, и все неудачные.