дорожка · 08.10.2026 · проверка качества

Как проверить, что модель справляется с задачей

Как узнать, что модель правда справляется с твоей задачей, а не просто понравилась на трёх примерах. Пять ступеней: как собрать проверочный набор с правильными ответами, какие числа считать и как их читать, как проверять свободный текст правилами и моделью-судьёй, как отличить настоящее улучшение от случайности и как ловить поломки при каждом изменении. Все примеры на Python запускаются у тебя без доступа к модели и без дополнительных библиотек: ответы модели в них записаны заранее, числа учебные.

Все дорожки — /put. Прошлая — как получить от модели ответ строго по форме.

1 Проверочный набор: на чём вообще проверять

Зачем это в работе. Вчера ты научился получать от модели ответ строго по форме. Но правильная форма не говорит, верен ли ответ по сути. Пока проверка идёт «на глаз» — попробовал три письма, понравилось, — любая правка запроса или замена модели может незаметно сделать хуже. Чтобы знать, а не надеяться, нужен набор примеров с заранее известными правильными ответами и привычка прогонять по нему каждую версию.

Такой набор называют проверочным (eval set, от слова evaluation — оценка). Каждый пример в нём — это вход, который получит модель (например, текст письма), и эталон — правильный ответ, который заранее записал человек. Программа отдаёт модели входы по очереди, сравнивает ответы с эталонами и считает, сколько совпало. Это и есть оценка, или «эвал» на жаргоне разработчиков.

Брать входы нужно настоящие, из своей работы, а не придумывать. Придуманные письма получаются чистыми и однозначными, а настоящие бывают с опечатками, с двумя просьбами сразу, вообще без просьбы. Отдельно стоит собрать трудные случаи — те, на которых легко перепутать категорию: «посылка пришла мятая, хочу вернуть» звучит про доставку, а по сути это возврат. И нужно, чтобы каждая категория встречалась хотя бы несколько раз, иначе о ней набор ничего не скажет.

Эталон записывают до того, как посмотрят на ответ модели. Если сначала прочитать ответ, а потом решать, верен ли он, человек невольно соглашается с уверенно написанным текстом. Полезно, чтобы трудные примеры разметили два человека независимо: где они расходятся, там правило разметки сформулировано нечётко, и его надо дописать, прежде чем винить модель.

Набор делят на две части. Рабочая — на ней ты подбираешь формулировку запроса и смотришь ошибки. Контрольная — её не открывают во время подбора и прогоняют только в конце, чтобы честно узнать результат. Если подбирать запрос, глядя на все примеры, он подстроится под них, и цифра окажется лучше, чем будет на новых письмах. Не путай проверочный набор с обучающими данными (training data): на обучающих модель учат, меняя её веса, а проверочный только измеряет и саму модель не меняет.

Подробный пример. Ниже двенадцать писем с эталонной категорией и пометкой «трудное». Код считает, сколько примеров в каждой категории и сколько трудных, а затем один раз делит набор на рабочую и контрольную части с фиксированным зерном — числом, от которого зависит перемешивание, чтобы деление каждый раз выходило одинаковым:

import random
from collections import Counter

# Проверочный набор: настоящие письма с правильным ответом (эталоном).
# Поле "trud" помечает трудные случаи, которые легко перепутать.
nabor = [
    {"id": 1,  "tekst": "Верните деньги за сломанный чайник",        "etalon": "возврат",  "trud": False},
    {"id": 2,  "tekst": "Курьер не приехал второй день",              "etalon": "доставка", "trud": False},
    {"id": 3,  "tekst": "Как поменять адрес в профиле?",              "etalon": "другое",   "trud": False},
    {"id": 4,  "tekst": "Посылка пришла мятая, хочу вернуть",         "etalon": "возврат",  "trud": True},
    {"id": 5,  "tekst": "Где мой заказ 5521?",                        "etalon": "доставка", "trud": False},
    {"id": 6,  "tekst": "Спасибо, всё пришло!",                       "etalon": "другое",   "trud": True},
    {"id": 7,  "tekst": "Привезли не тот цвет, обменяйте",            "etalon": "возврат",  "trud": True},
    {"id": 8,  "tekst": "Можно доставку на субботу?",                 "etalon": "доставка", "trud": False},
    {"id": 9,  "tekst": "Деньги за отменённый заказ так и не пришли", "etalon": "возврат",  "trud": True},
    {"id": 10, "tekst": "Курьер нагрубил",                            "etalon": "другое",   "trud": True},
    {"id": 11, "tekst": "Хочу сдать неподошедшие кроссовки",          "etalon": "возврат",  "trud": False},
    {"id": 12, "tekst": "Трек-номер не обновляется неделю",           "etalon": "доставка", "trud": False},
]

print("категории:", dict(Counter(x["etalon"] for x in nabor)))
print("трудных:", sum(x["trud"] for x in nabor), "из", len(nabor))

# Делим один раз и с фиксированным зерном: рабочая часть для подбора запроса,
# контрольная — только для итоговой проверки.
rng = random.Random(42)
ids = [x["id"] for x in nabor]
rng.shuffle(ids)
kontrol = sorted(ids[:4])
print("контрольная часть:", kontrol)
print("рабочая часть:", sorted(ids[4:]))

У меня вышло так: возвратов 5, доставки 4, «другого» 3, трудных 5 из 12. В контрольную часть попали письма 3, 6, 8 и 9 — среди них есть все три категории и два трудных случая. Если бы при другом зерне туда попали только простые письма, контрольная часть показала бы завышенный результат; поэтому после деления состав стоит проверить глазами. Двенадцать примеров — учебный размер; для настоящей работы начинают с нескольких десятков и пополняют набор по ходу дела.

Где обычно ошибаются.

  • Придумывают примеры сами вместо того, чтобы взять настоящие. Модель хорошо справляется с аккуратными выдуманными письмами и спотыкается на живых.
  • Подбирают запрос на всём наборе, а потом на нём же меряют итог. Получается экзамен, вопросы которого ученик видел заранее.
  • Пишут эталон, глядя на ответ модели. Тогда набор измеряет не правильность, а то, насколько человек согласен с моделью.

Проверочный набор (eval set). Примеры с заранее известными правильными ответами, на которых измеряют качество.

Оценка (evaluation, эвал). Прогон модели по проверочному набору и подсчёт совпадений с эталонами.

Эталон. Правильный ответ к примеру, записанный человеком до просмотра ответа модели.

Трудный случай. Пример, на котором легко ошибиться; такие собирают специально.

Разметка. Работа человека, который проставляет эталоны по ясному правилу.

Рабочая часть. Примеры, на которых подбирают запрос и разбирают ошибки.

Контрольная часть. Примеры, которые не трогают при подборе и прогоняют только для итоговой проверки.

Обучающие данные (training data). Данные, на которых модель учат; проверочный набор модель не меняет.

2 Что считать: доля верных, таблица ошибок, точность и полнота

Зачем это в работе. Одно число «модель права в 80% случаев» прячет главное: где именно она ошибается и во что это обходится. Пропущенное срочное письмо и лишнее письмо в ручной очереди — ошибки разной цены. Простые метрики, то есть способы посчитать качество одним числом, нужно уметь выбирать под задачу и читать вместе.

Самая простая метрика — доля верных ответов (accuracy): сколько ответов совпало с эталоном, делённое на число примеров. Её ловушка — неравные категории. Если девять писем из десяти про доставку, «модель», которая всегда отвечает «доставка», получит долю верных 0,9 и при этом не найдёт ни одного возврата.

Поэтому смотрят таблицу ошибок (confusion matrix). Её строки — как правильно, столбцы — что ответила модель. На главной диагонали, где строка и столбец совпадают, стоят верные ответы, а в остальных клетках видно, что с чем путается: например, возвраты, которые модель записала в доставку. По этой таблице сразу понятно, какую часть инструкции дописывать.

Для каждой категории считают ещё два числа. Точность (precision) отвечает на вопрос: когда модель сказала «возврат», как часто это правда возврат. Полнота (recall): из всех настоящих возвратов какую долю модель нашла. Они тянут в разные стороны: если чаще говорить «возврат», полнота растёт, а точность падает. Какая важнее, решает цена ошибки: для срочных писем важнее полнота — пропустить хуже, чем лишний раз проверить.

Не путай точность (precision) с долей верных (accuracy): по-русски обе иногда называют «точностью», но первая считается для одной категории по ответам модели, а вторая — для всего набора сразу. Ещё одно соседнее понятие — F1, одно число, которое объединяет точность и полноту; оно удобно для сравнения, но, как любое среднее, снова прячет, какая из двух проседает.

Подробный пример. Двенадцать эталонов и двенадцать ответов модели (ответы учебные, записаны заранее). Код считает долю верных, строит таблицу ошибок и точность с полнотой по каждой категории:

from collections import Counter

etalon = ["возврат","доставка","другое","возврат","доставка","другое",
          "возврат","доставка","возврат","другое","возврат","доставка"]
otvet  = ["возврат","доставка","другое","доставка","доставка","возврат",
          "возврат","доставка","доставка","доставка","возврат","доставка"]

verno = sum(e == o for e, o in zip(etalon, otvet))
print(f"доля верных (accuracy): {verno}/{len(etalon)} = {verno/len(etalon):.2f}")

# Таблица ошибок: строка — как правильно, столбец — что ответила модель.
kat = ["возврат", "доставка", "другое"]
para = Counter(zip(etalon, otvet))
print("\nэталон \\ ответ".ljust(18) + "".join(k.ljust(10) for k in kat))
for e in kat:
    print(e.ljust(18) + "".join(str(para[(e, o)]).ljust(10) for o in kat))

print()
for k in kat:
    tp = para[(k, k)]
    skazal = sum(1 for o in otvet if o == k)
    bylo = sum(1 for e in etalon if e == k)
    print(f"{k:9} точность {tp}/{skazal} = {tp/skazal if skazal else 0:.2f}   полнота {tp}/{bylo} = {tp/bylo:.2f}")

Доля верных 8 из 12, то есть 0,67. Таблица показывает, откуда потери: два возврата ушли в доставку, а из трёх писем «другое» модель узнала только одно. Отсюда цифры по категориям: у доставки полнота 1,00 — модель не пропустила ни одной, — но точность 0,57, потому что туда же свалились чужие письма. У «другого» наоборот: точность 1,00, полнота 0,33. Вывод для работы конкретный: модель слишком охотно ставит «доставку», и в инструкцию нужно добавить, что повреждённый или не тот товар — это возврат, даже если в письме упомянут курьер.

Где обычно ошибаются.

  • Смотрят только на долю верных при неравных категориях и радуются высокому числу, за которым стоит «всегда отвечай самым частым».
  • Считают метрики, но не открывают сами ошибочные примеры. Число говорит, что плохо, а понять почему можно только прочитав письма.
  • Сравнивают версии по F1 или по доле верных и не замечают, что важная категория просела, а неважная выросла.

Метрика. Способ выразить качество одним числом.

Доля верных (accuracy). Число ответов, совпавших с эталоном, делённое на число примеров.

Таблица ошибок (confusion matrix). Таблица «как правильно — что ответила модель», где видно, что с чем путается.

Главная диагональ. Клетки таблицы ошибок, где ответ совпал с эталоном.

Точность (precision). Доля правильных среди тех случаев, когда модель назвала эту категорию.

Полнота (recall). Доля найденных моделью среди всех настоящих случаев этой категории.

F1. Одно число, объединяющее точность и полноту.

Неравные категории. Случай, когда одной категории в данных намного больше остальных; доля верных тогда обманывает.

3 Свободный текст: правила и модель-судья

Зачем это в работе. Категорию легко сравнить с эталоном, а пересказ письма, ответ клиенту или вывод по документу — нет: правильных формулировок много, и дословное совпадение почти не случается. Для такого текста проверку строят в два слоя: сначала простые правила, которые проверяет код, потом оценка по критериям, которую часто поручают другой модели.

Правила — это всё, что можно проверить без понимания смысла: ответ не длиннее ста слов; в нём есть номер заказа из письма; нет запрещённых фраз вроде обещания компенсации; цитата, на которую он ссылается, дословно встречается в документе. Такие проверки дешёвые, быстрые и не ошибаются, поэтому их ставят первыми и выжимают из них всё, что можно.

Для смысла используют модель-судью (LLM-as-a-judge): другой запрос к модели, который получает вход, ответ и критерии — рубрику, то есть список того, что считается хорошим ответом, — и выносит вердикт. Надёжнее просить простой вердикт по одному критерию («ответ называет срок возврата: да или нет»), чем общий балл от 1 до 10: «да или нет» проще сверить с человеком, а разница между семёркой и восьмёркой у судьи плавает.

Судья — тоже модель, и у него есть перекосы. В исследованиях модели-судьи (например, в работе авторов MT-Bench 2023 года) описаны три: перекос по позиции (position bias) — при сравнении двух ответов судья чаще выбирает стоящий на определённом месте; перекос по длине — длинный ответ кажется лучше; и предпочтение ответов, похожих на собственный стиль модели. Против перекоса по позиции задают сравнение дважды, поменяв ответы местами, и засчитывают только совпавшие вердикты.

Главное ограничение: судье нельзя верить, пока его не сверили с человеком. Берут несколько десятков примеров, размечают их вручную и смотрят согласие — долю случаев, где судья и человек решили одинаково, — а главное, какие ошибки судья пропускает. Судья, который хвалит всё подряд, даёт красивую цифру и не ловит брак.

Подробный пример. Код ниже не обращается к модели: вердикты судьи и человека записаны заранее, они учебные. Сначала сверяем десять вердиктов «годен или брак», потом проверяем перекос по позиции на восьми сравнениях «какой ответ лучше», заданных дважды в разном порядке:

# Сверяем модель-судью с ручной разметкой и проверяем перекос по позиции.
# Все оценки — учебные, записаны заранее, чтобы код запускался без модели.

chelovek = ["годен","годен","брак","годен","брак","годен","брак","годен","годен","брак"]
sudya    = ["годен","годен","годен","годен","брак","годен","годен","годен","годен","брак"]

sovpalo = sum(c == s for c, s in zip(chelovek, sudya))
print(f"согласие с человеком: {sovpalo}/{len(chelovek)}")
propustil = sum(c == "брак" and s == "годен" for c, s in zip(chelovek, sudya))
print(f"брак, который судья пропустил: {propustil} из {chelovek.count('брак')}")

# Тот же вопрос «какой ответ лучше, A или B?» задали дважды,
# во второй раз поменяв ответы местами. Записываем, кого судья назвал лучшим.
pryamo   = ["A","A","B","A","A","A","B","A"]   # порядок: сначала A, потом B
naoborot = ["A","B","B","A","B","A","A","B"]   # порядок: сначала B, потом A
ustoichivo = sum(p == n for p, n in zip(pryamo, naoborot))
print(f"\nодинаковый выбор при обмене местами: {ustoichivo}/{len(pryamo)}")
pervyi = sum(p == "A" for p in pryamo) + sum(n == "B" for n in naoborot)
print(f"выбрал ответ, стоявший первым: {pervyi} раз из {2*len(pryamo)}")

Согласие 8 из 10 выглядит прилично, но вторая строка важнее: из четырёх бракованных ответов судья пропустил два, то есть половину брака. Как контролёр он пока бесполезен. Во второй части только 4 сравнения из 8 дали одинаковый выбор при обмене местами, а ответ, стоявший первым, судья выбрал 10 раз из 16. Это признак перекоса по позиции: половина его вердиктов зависит от порядка, а не от качества. Что делать: сузить критерий, добавить в запрос судьи пример брака, повторить сверку.

Где обычно ошибаются.

  • Сразу зовут модель-судью, хотя половину требований можно проверить простым кодом без ошибок и без затрат.
  • Смотрят только на общее согласие с человеком и не считают, сколько брака судья пропустил.
  • Просят «оцени ответ от 1 до 10» без критериев и потом сравнивают версии по разнице в полбалла.

Проверка правилом. Проверка кодом того, что не требует понимания смысла: длина, наличие номера, запрещённые фразы.

Модель-судья (LLM-as-a-judge). Отдельный запрос к модели, который оценивает ответ по заданным критериям.

Рубрика. Список критериев, по которым судья решает, хорош ли ответ.

Вердикт. Решение судьи по одному критерию, лучше всего в виде «да или нет».

Перекос по позиции. Склонность судьи выбирать ответ, стоящий на определённом месте, независимо от качества.

Перекос по длине. Склонность судьи считать более длинный ответ лучшим.

Согласие. Доля примеров, где судья и человек решили одинаково.

4 Разброс: когда улучшение настоящее, а когда случайность

Зачем это в работе. Ты поменял одну фразу в запросе, и доля верных выросла с 0,75 до 0,80. Это улучшение или совпадение? На маленьком наборе и со случайностью внутри модели такие разницы часто возникают сами собой. Без простой проверки разброса легко неделю «улучшать» запрос, гоняясь за шумом.

Первый источник разброса — сама модель. Как мы видели на позапрошлой дорожке, при температуре выше нуля следующий токен выбирается случайно, поэтому один и тот же запрос может дать разные ответы. Многие сервисы не обещают полной повторяемости даже при нулевой температуре. Значит, один прогон набора — это одно случайное измерение; чтобы увидеть разброс, набор прогоняют несколько раз и смотрят, насколько гуляет результат.

Второй источник — размер набора. На двадцати примерах один пример — это пять процентных пунктов: одно случайно угаданное письмо двигает результат с 0,75 до 0,80. Чем меньше набор, тем шире полоса, в которой результат может оказаться просто по везению.

Ширину этой полосы можно прикинуть бутстрэпом (bootstrap). Берём свои результаты «верно или неверно» по каждому примеру и много раз собираем из них новую выборку того же размера, вытягивая примеры случайно с возвращением, то есть один и тот же пример может попасть несколько раз. Для каждой такой выборки считаем долю верных. Если отбросить по 2,5% самых низких и самых высоких из получившихся чисел, оставшиеся 95% и дадут примерный интервал, в котором лежит настоящее качество. Если интервалы старой и новой версии сильно перекрываются, говорить об улучшении рано.

Две версии сравнивают на одних и тех же примерах и смотрят не только на итог, но и на примеры, где версии разошлись: в скольких новая лучше, в скольких хуже. Это парное сравнение точнее, чем сравнение двух общих чисел, потому что убирает разницу в трудности примеров. Для строгого вывода по таким парам существует статистический тест (тест Макнемара), но уже сам подсчёт «лучше в стольких, хуже в стольких» отрезвляет.

Подробный пример. Код из трёх частей, и все данные в нём — симуляция или учебные числа, а не измерения настоящей модели. Сначала одна и та же «модель», которая верна с вероятностью 0,8, пять раз проходит двадцать примеров. Потом бутстрэп для результата 31 из 40. Потом парное сравнение двух запросов на двенадцати примерах:

import random

# 1) Разброс: одна и та же «модель» (верна с вероятностью 0.8) на 20 примерах,
#    пять прогонов. Это симуляция, а не настоящая модель.
rng = random.Random(7)
for progon in range(1, 6):
    verno = sum(rng.random() < 0.8 for _ in range(20))
    print(f"прогон {progon}: {verno}/20 = {verno/20:.2f}")

# 2) Бутстрэп: насколько можно доверять доле верных на 40 примерах.
rez = [1]*31 + [0]*9          # 31 верный из 40
dolya = sum(rez) / len(rez)
rng = random.Random(1)
vyborki = sorted(sum(rng.choice(rez) for _ in rez) / len(rez) for _ in range(2000))
niz, verh = vyborki[50], vyborki[1949]
print(f"\nдоля верных {dolya:.3f}, 95% бутстрэп-интервал примерно {niz:.3f}–{verh:.3f}")

# 3) Парное сравнение двух запросов на одних и тех же примерах.
staryi = [1,1,0,1,1,0,1,1,1,0,1,1]
novyi  = [1,1,1,1,0,1,1,1,1,1,1,1]
luchshe = sum(n > s for s, n in zip(staryi, novyi))
huzhe   = sum(n < s for s, n in zip(staryi, novyi))
print(f"\nстарый {sum(staryi)}/12, новый {sum(novyi)}/12; новый лучше в {luchshe}, хуже в {huzhe}")

Пять прогонов одной и той же модели дали от 0,70 до 0,90. Если бы ты сделал один прогон до правки и один после, ты мог бы увидеть «рост на 20 пунктов» без всякого улучшения. Бутстрэп для 31 из 40 даёт долю 0,775 и интервал примерно от 0,65 до 0,90: на сорока примерах честно можно сказать только «где-то между двумя третями и девятью десятыми». В парном сравнении новый запрос лучше в трёх примерах и хуже в одном: это обнадёживает, но на четырёх расхождениях вывода не сделать — нужны ещё примеры.

Где обычно ошибаются.

  • Делают по одному прогону до и после правки и принимают случайный скачок за результат работы.
  • Сравнивают версии на разных наборах примеров, и разница в трудности примеров выдаёт себя за разницу в качестве.
  • Сообщают результат с точностью до десятых процента, полученный на тридцати примерах.

Разброс. Насколько меняется результат при повторении одного и того же измерения.

Прогон. Однократная проверка версии на всём проверочном наборе.

Процентный пункт. Разница между процентами: от 75% до 80% — это пять пунктов.

Бутстрэп (bootstrap). Способ оценить разброс, много раз пересобирая выборку из своих же результатов с возвращением.

Выборка с возвращением. Случайный выбор, при котором один пример может попасть несколько раз.

Интервал (95%). Полоса, в которой с высокой вероятностью лежит настоящее качество.

Парное сравнение. Сравнение двух версий на одних и тех же примерах с подсчётом, где какая лучше.

Шум. Случайные колебания результата, которые не связаны с изменениями в запросе.

5 Прогон при каждом изменении: регрессии и подгонка под набор

Зачем это в работе. Набор и метрики приносят пользу, только если их прогоняют всякий раз, когда что-то меняется: формулировка запроса, модель, схема ответа, настройки поиска по документам. Иначе улучшение в одном месте тихо ломает другое, и узнаёшь об этом от недовольного клиента.

То, что раньше работало и после изменения сломалось, называют регрессией (regression). Общая цифра может расти, а регрессии при этом появляться: новая версия починила пять примеров и сломала два. Поэтому сравнивают по каждому примеру и выводят два списка — что починили и что сломали. Некоторые примеры помечают критичными: их нельзя ломать ни при каком общем росте, например письма с угрозой безопасности или юридические жалобы.

Прогон оформляют скриптом, который можно запустить одной командой и который завершается с кодом ошибки, если порог не пройден. Код завершения (exit code) — число, которое программа сообщает системе по окончании: ноль значит «всё хорошо», не ноль — «стоп». На это число умеют смотреть системы автоматической проверки (CI), которые запускают тесты перед выкаткой — выпуском новой версии к пользователям, — и останавливают её при ненулевом коде.

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

Не путай свой набор с публичными бенчмарками (benchmark) — общедоступными наборами задач, по которым компании сравнивают модели в объявлениях. Бенчмарк меряет общие умения, а не твою задачу; к тому же задачи публичных наборов могли попасть в обучающие данные модели — это называют утечкой (contamination), и тогда высокий балл частично означает, что модель видела ответы. Для выбора модели под свою работу решает прогон твоего набора, а цифры из объявлений — только повод попробовать.

Подробный пример. Результаты двух версий запроса на шести примерах (учебные), два из них помечены критичными. Скрипт печатает, что починили и что сломали, и отказывает в выкатке, если сломан критичный пример:

import sys

# Результаты двух версий запроса по каждому примеру (учебные).
# kritich=True — примеры, которые ломать нельзя ни при каком общем росте.
primery = [
    {"id": 1, "kritich": True,  "staraya": True,  "novaya": True},
    {"id": 2, "kritich": False, "staraya": False, "novaya": True},
    {"id": 3, "kritich": True,  "staraya": True,  "novaya": False},
    {"id": 4, "kritich": False, "staraya": True,  "novaya": True},
    {"id": 5, "kritich": False, "staraya": False, "novaya": True},
    {"id": 6, "kritich": False, "staraya": True,  "novaya": True},
]

st = sum(p["staraya"] for p in primery)
nv = sum(p["novaya"] for p in primery)
print(f"было {st}/{len(primery)}, стало {nv}/{len(primery)}")

pochinili = [p["id"] for p in primery if not p["staraya"] and p["novaya"]]
slomali   = [p["id"] for p in primery if p["staraya"] and not p["novaya"]]
print("починили:", pochinili)
print("сломали:", slomali)

stop = [p["id"] for p in primery if p["kritich"] and p["staraya"] and not p["novaya"]]
if stop:
    print("НЕ ВЫКАТЫВАТЬ: сломаны критичные примеры", stop)
    sys.exit(1)
print("можно выкатывать")

Общая цифра выросла с 4 из 6 до 5 из 6, починены примеры 2 и 5. Но сломан пример 3, а он критичный, поэтому скрипт печатает «НЕ ВЫКАТЫВАТЬ» и завершается с кодом 1 — система проверки остановит выпуск. Проверить код завершения у себя можно, сразу после запуска набрав в терминале echo $?. Дальше работа понятная: открыть пример 3, понять, что новая формулировка в нём сломала, и поправить, не потеряв 2 и 5.

Где обычно ошибаются.

  • Смотрят только на общий рост и пропускают регрессии, которые прячутся за ним.
  • Меняют модель на «более сильную по бенчмаркам» без прогона своего набора.
  • Годами подбирают запрос по одной и той же контрольной части и считают её результат честным.

Регрессия (regression). Поломка того, что раньше работало, после изменения.

Критичный пример. Пример, который нельзя ломать ни при каком общем улучшении.

Код завершения (exit code). Число, которое программа возвращает системе: ноль — успех, не ноль — ошибка.

Автоматическая проверка (CI). Система, которая сама запускает тесты перед выкаткой и останавливает её при ошибке.

Выкатка. Выпуск новой версии к настоящим пользователям.

Подгонка под набор. Улучшение результата на конкретных примерах вместо улучшения в задаче.

Бенчмарк (benchmark). Публичный набор задач для сравнения моделей между собой.

Утечка (contamination). Попадание задач проверочного набора в обучающие данные модели.

Словарь целиком — /slovar, новости — /novosti.