Маленькие модели, которые помещаются в телефон или отвечают за доли цента, почти никогда не учат с нуля только на текстах из интернета. Их учат у большой модели: она подсказывает не одно правильное слово, а то, насколько вероятны все варианты. Это называется дистилляцией знаний (knowledge distillation): большая модель — учитель, маленькая — ученик. Разберём, почему вероятности учителя несут больше информации, чем готовый текст, как считается потеря и зачем в ней температура, почему направление сравнения распределений меняет поведение ученика, чем обучение на текстах учителя отличается от обучения на собственных ответах ученика и где дистилляция незаметно портит модель. Опираемся на дорожку о функции потерь и о выборе слова. Все примеры — игрушечные расчёты на numpy; код на странице мы запускали, выводы взяты из этих запусков.
Все дорожки — /put. Прошлая — обучение на предпочтениях.
Зачем это в работе. В описаниях многих небольших открытых моделей прямо сказано, что их учили у большой: в техническом отчёте Gemma 2 (Google, 2024) маленькие версии обучены дистилляцией, в отчёте DeepSeek-R1 (2025) умение рассуждать перенесли в модели семейств Qwen и Llama, дообучив их на примерно 800 тысячах примеров, написанных большой моделью. Если ты выбираешь маленькую модель или хочешь сделать свою дешёвую модель под узкую задачу, нужно понимать, что именно ученик получает от учителя и чего получить не может.
Как это устроено. При обычном обучении на тексте у каждой позиции есть одна правильная метка: слово, которое стояло в тексте. Модель получает сигнал «подними вероятность этого токена», и всё. Это называют жёсткой меткой (hard label): вектор, где у верного токена единица, у остальных нули. Учитель же на той же позиции выдаёт полное распределение вероятностей по словарю — мягкую метку (soft target). В ней видно, какие ещё продолжения разумны и насколько, а какие бессмысленны.
Идею сжатия большой модели в маленькую через её ответы описали Бучилэ, Каруана и Никулеску-Мизил (2006, «Model Compression»), а форму с мягкими метками и температурой, которой пользуются до сих пор, — Хинтон, Виньялс и Дин (2015, «Distilling the Knowledge in a Neural Network»). Они назвали знание, которое лежит в вероятностях неверных вариантов, «тёмным знанием» (dark knowledge): например, что «ковре» похоже на правильный ответ, а «луне» — нет.
Почему это помогает маленькой модели. На один пример мягкая метка несёт больше информации, чем жёсткая, поэтому ученику нужно меньше примеров, и сигнал меньше шумит: если в тексте случайно стояло редкое слово, учитель всё равно покажет, что обычно здесь пишут. Ограничение тоже важное: ученик учится повторять учителя, а не правду. Если учитель ошибается или уверенно выдумывает, мягкие метки передадут и это.
Чем дистилляция отличается от квантования: квантование сжимает те же самые веса, храня числа грубее, а дистилляция обучает другую, меньшую сеть с нуля или с более раннего состояния. Отличие от обычного дообучения на образцах: там образцы пишут люди, здесь их источник — модель, и можно брать не только текст, но и вероятности.
Подробный пример. Фраза «Кошка спит на ...», шесть вариантов следующего слова. Учитель выдал логиты (сырые оценки до перевода в вероятности), мы переводим их в вероятности и считаем энтропию — сколько бит неопределённости в распределении:
import numpy as np
# Продолжение фразы «Кошка спит на ...»: шесть вариантов следующего слова
WORDS = ["диване", "ковре", "окне", "кровати", "столе", "луне"]
TEACHER = np.array([3.0, 2.6, 2.2, 2.0, 0.5, -3.0]) # логиты большой модели-учителя
def softmax(z, T=1.0):
e = np.exp((z - z.max()) / T); return e / e.sum()
def kl(p, q): return float(np.sum(p * np.log(p / q)))
def bits(p): return float(-np.sum(p * np.log2(p)))
from common import *
hard = np.eye(len(WORDS))[0] # жёсткая метка: в тексте стояло «диване»
print("жёсткая метка:", dict(zip(WORDS, [int(x) for x in hard])))
for T in (1, 2, 4):
p = softmax(TEACHER, T)
print(f"T={T}: " + " ".join(f"{w} {x:.3f}" for w, x in zip(WORDS, p)) + f" энтропия {bits(p):.2f} бит")
У нас этот код напечатал:
жёсткая метка: {'диване': 1, 'ковре': 0, 'окне': 0, 'кровати': 0, 'столе': 0, 'луне': 0}
T=1: диване 0.389 ковре 0.261 окне 0.175 кровати 0.143 столе 0.032 луне 0.001 энтропия 2.04 бит
T=2: диване 0.291 ковре 0.239 окне 0.195 кровати 0.177 столе 0.083 луне 0.015 энтропия 2.30 бит
T=4: диване 0.235 ковре 0.212 окне 0.192 кровати 0.183 столе 0.126 луне 0.052 энтропия 2.47 бит
Жёсткая метка говорит только «диване» и имеет нулевую энтропию: никакой информации о других вариантах. Мягкая метка при обычной температуре 1 говорит больше: «ковре» вероятно почти так же (0,261), «окне» и «кровати» допустимы, «столе» маловероятно, «луне» почти исключено (0,001). Именно эта лестница и есть то, чему ученик учится сверх текста. При температуре 2 и 4 распределение становится ровнее, и разница между «столе» и «луне» видна лучше: о температуре — следующая ступень.
Где обычно ошибаются.
Дистилляция знаний (knowledge distillation). обучение маленькой модели повторять выходы большой.
Учитель и ученик (teacher, student). большая обученная модель, которая подсказывает, и маленькая, которая учится.
Жёсткая метка (hard label). один верный токен: единица у него и нули у остальных.
Мягкая метка (soft target). полное распределение вероятностей учителя по всем вариантам.
Тёмное знание (dark knowledge). информация о том, какие неверные варианты похожи на верный, скрытая в малых вероятностях.
Логиты (logits). сырые оценки модели для каждого токена до перевода в вероятности функцией softmax.
Энтропия. средняя неопределённость распределения в битах: ноль, если вариант один, и больше, если вариантов много и они близки.
Зачем это в работе. Если ты сам запускаешь дистилляцию в библиотеке вроде TRL или пишешь цикл обучения, тебе придётся выбрать температуру, вес между мягкой и жёсткой потерей и решить, умножать ли на T². От этих трёх ручек зависит, научится ли ученик чему-то кроме самого вероятного слова и не утонет ли сигнал в шуме.
Как это устроено. Сначала логиты и учителя, и ученика делят на одну и ту же температуру T и только потом переводят в вероятности. При T больше единицы распределение становится ровнее: малые вероятности растут, и ученик лучше видит, как учитель упорядочил маловероятные варианты. При T = 1 эта информация почти не влияет на обучение, потому что вероятности вроде 0,001 дают крошечный вклад в потерю.
Затем считают расстояние между распределениями — расхождение Кульбака–Лейблера (Kullback–Leibler divergence, KL). KL(p‖q) — это то, насколько в среднем распределение ученика q хуже описывает варианты, чем распределение учителя p; оно равно нулю, только если q совпадает с p. Это та же перекрёстная энтропия из прошлой дорожки, только целью служит не один токен, а всё распределение учителя, и из неё вычтена энтропия учителя, которая от ученика не зависит.
Ловушка с масштабом. Градиент KL по логитам ученика равен (q − p) / T, и при высокой температуре оба распределения становятся ровными, разница между ними сжимается, и градиент падает примерно как 1/T². Хинтон и соавторы поэтому предложили умножать мягкую потерю на T², чтобы её вклад не зависел от выбранной температуры. Итоговая потеря обычно смесь: α · T² · KL(p_T ‖ q_T) + (1 − α) · обычная потеря на жёсткой метке, где α — доля мягкой части.
Чем это отличается от температуры при генерации из дорожки о выборе слова: там температура меняет то, какие слова модель выберет при ответе, а здесь она применяется только во время обучения, чтобы сделать сигнал учителя заметнее. После обучения ученик отвечает с обычной температурой.
Подробный пример. Ученик пока ошибается: он считает «окне» самым вероятным и почти не различает «ковре» и «столе». Считаем KL и длину вектора градиента при разных температурах, без множителя и с ним:
from common import *
student = np.array([2.0, 0.0, 2.5, 0.0, 0.0, 0.0]) # ученик пока путает «ковре» и «окне»
for T in (1, 2, 4, 8):
p, q = softmax(TEACHER, T), softmax(student, T)
grad = (q - p) / T # градиент KL(p||q) по логитам ученика
print(f"T={T}: KL={kl(p, q):.3f} норма градиента {np.linalg.norm(grad):.4f} после умножения на T²: {np.linalg.norm(grad) * T * T:.4f}")
У нас этот код напечатал:
T=1: KL=0.528 норма градиента 0.4270 после умножения на T²: 0.4270
T=2: KL=0.193 норма градиента 0.1175 после умножения на T²: 0.4702
T=4: KL=0.068 норма градиента 0.0342 после умножения на T²: 0.5477
T=8: KL=0.021 норма градиента 0.0098 после умножения на T²: 0.6281
Без поправки сигнал при T = 8 в сорок с лишним раз слабее, чем при T = 1 (0,0098 против 0,4270), хотя ошибка ученика та же: при неизменном шаге обучения он почти перестал бы учиться. После умножения на T² величина градиента остаётся одного порядка, от 0,43 до 0,63. Поэтому температуру можно менять, не подбирая заново шаг обучения и вес α. Обрати внимание и на то, что KL при высокой температуре мало: это не значит, что ученик хорош, просто сравнивают сглаженные распределения.
Где обычно ошибаются.
Температура дистилляции (T). делитель логитов во время обучения, который сглаживает распределения учителя и ученика.
Расхождение Кульбака–Лейблера (KL divergence). мера того, насколько одно распределение хуже описывает варианты, чем другое; ноль при полном совпадении.
Множитель T². поправка, которая возвращает градиенту мягкой потери прежнюю величину при высокой температуре.
Коэффициент α. доля мягкой потери в смеси с обычной потерей на жёсткой метке.
Перекрёстная энтропия (cross-entropy). средний минус логарифм вероятности, которую модель дала правильному варианту или распределению.
Градиент по логитам. направление и сила, с которыми надо сдвинуть сырые оценки ученика, чтобы уменьшить потерю.
Проверочный набор. примеры, на которых не учили и по которым сравнивают модели честно.
Зачем это в работе. KL несимметрична: KL(учитель ‖ ученик) и KL(ученик ‖ учитель) — разные числа и разное поведение после обучения. Когда ученик заметно меньше учителя, он не может повторить всё, и направление KL решает, как он будет ошибаться: выдавать иногда бессмыслицу или стать уже и однообразнее. В статьях о дистилляции языковых моделей это одна из главных настроек.
Как это устроено. Прямая KL, KL(p‖q), усредняет по вариантам учителя. Если учитель даёт варианту заметную вероятность, а ученик почти ноль, штраф огромный, потому что в формуле стоит логарифм p / q. Значит, ученик обязан покрыть все варианты учителя, а за лишнюю вероятность там, где учитель ничего не ставил, штраф маленький. Это поведение называют покрытием мод (mode-covering): ученик размазывается шире, чем надо.
Обратная KL, KL(q‖p), усредняет по вариантам ученика. Теперь дорого класть вероятность туда, где у учителя её почти нет, а пропустить один из хороших вариантов дёшево. Ученик выбирает одну область, которую может описать хорошо, и сосредотачивается на ней — это поиск моды (mode-seeking). Для генерации текста это часто лучше: ответ получается связнее, хотя разнообразие падает.
Где это применяется. В работе MiniLLM (Гу и соавторы, 2023) дистилляцию языковых моделей строят на обратной KL именно ради того, чтобы маленький ученик не порождал текст с низкой вероятностью у учителя. В работе об обобщённой дистилляции по политике ученика (GKD, Агарвал и соавторы, 2023) направление KL сделано настраиваемым, включая промежуточные варианты. Обычная потеря Хинтона из прошлой ступени — прямая KL.
Ограничение. Если ученик достаточно велик, чтобы повторить учителя почти точно, разница между направлениями мала: обе KL равны нулю в одной точке. Выбор становится важен именно тогда, когда ученик заметно слабее.
Подробный пример. У учителя два хороших способа начать ответ (токены 1–2 и 7–8), а между ними бессмыслица (4–5) с маленькой вероятностью. Ученик слабый: он умеет только распределение с одной «горкой» — задаётся центром и шириной. Перебираем центр и ширину и ищем лучшего ученика по каждой KL:
import numpy as np
# Учитель: два хороших способа начать ответ (токены 1–2 и 7–8), между ними — бессмыслица (4–5)
p = np.array([.02, .22, .22, .03, .01, .01, .03, .22, .22, .02]); p /= p.sum()
x = np.arange(len(p))
def student(mu, s): # слабый ученик умеет только «одну горку»
q = np.exp(-(x - mu) ** 2 / (2 * s * s)) + 1e-6; return q / q.sum()
grid = [(mu, s) for mu in np.linspace(0, 9, 91) for s in np.linspace(0.3, 12, 118)]
fwd = min(grid, key=lambda m: np.sum(p * np.log(p / student(*m)))) # KL(учитель || ученик)
rev = min(grid, key=lambda m: np.sum(student(*m) * np.log(student(*m) / p))) # KL(ученик || учитель)
for name, (mu, s) in (("прямая KL", fwd), ("обратная KL", rev)):
q = student(mu, s)
print(f"{name}: центр {mu:.1f}, ширина {s:.1f}; масса на хороших токенах {q[[1,2,7,8]].sum():.2f}, на бессмыслице 4–5 {q[[4,5]].sum():.2f}")
print(f"у учителя: хорошие {p[[1,2,7,8]].sum():.2f}, бессмыслица {p[[4,5]].sum():.2f}")
У нас этот код напечатал:
прямая KL: центр 4.5, ширина 12.0; масса на хороших токенах 0.40, на бессмыслице 4–5 0.21
обратная KL: центр 7.5, ширина 0.7; масса на хороших токенах 0.88, на бессмыслице 4–5 0.00
у учителя: хорошие 0.88, бессмыслица 0.02
По прямой KL лучший ученик встал посередине и растянулся почти в ровную полосу (ширина упёрлась в верхний край перебора): на хорошие токены он кладёт только 0,40 вероятности, а на бессмыслицу 0,21 — в десять раз больше, чем учитель (0,02). По обратной KL ученик выбрал одну горку у токенов 7–8, узкую, кладёт на хорошие токены 0,88, как учитель, и ноль на бессмыслицу, но второй хороший способ начать ответ потерял полностью. Это и есть цена каждого направления: прямая KL даёт разнообразие с мусором, обратная — качество с однообразием.
Где обычно ошибаются.
Прямая KL (forward KL). KL(учитель ‖ ученик): штрафует ученика за пропущенные варианты учителя.
Обратная KL (reverse KL). KL(ученик ‖ учитель): штрафует ученика за вероятность там, где у учителя её нет.
Мода. область распределения с высокой вероятностью; у нас их две.
Покрытие мод (mode-covering). поведение ученика, который растягивается на все моды сразу и кладёт вероятность между ними.
Поиск моды (mode-seeking). поведение ученика, который выбирает одну моду и описывает её точно.
Асимметрия KL. свойство расхождения: KL(p‖q) и KL(q‖p) обычно не равны.
MiniLLM. метод дистилляции языковых моделей на обратной KL, описанный в 2023 году.
Зачем это в работе. На практике дистилляцию языковых моделей делают тремя способами, и у каждого своя цена: обучение на сгенерированных учителем текстах, обучение на вероятностях учителя по тем же текстам и обучение по политике ученика, когда ученик пишет сам, а учитель оценивает каждый его токен. Выбор зависит от того, есть ли у тебя доступ к вероятностям учителя, сколько места под данные и насколько длинные ответы ученик будет писать.
Как это устроено. Самый простой способ — дистилляция на уровне последовательностей (sequence-level distillation, Ким и Раш, 2016): учитель генерирует ответы на набор вопросов, а ученика обычно дообучают на этих текстах как на образцах. Нужен только текст, поэтому так можно учиться даже у модели, доступной через API без вероятностей. Так устроен перенос рассуждений в отчёте DeepSeek-R1: маленькие модели обучали на текстах, написанных большой, без обучения с подкреплением.
Второй способ — потеря на вероятностях учителя по токенам, как в двух прошлых ступенях. Он информативнее, но требует, чтобы у учителя и ученика был один и тот же словарь токенов, и упирается в хранение. Мы посчитали: при словаре в 150 тысяч токенов и 2 байтах на число полные распределения для миллиарда токенов занимают 300 ТБ, а если хранить только 20 самых вероятных вариантов (номер 4 байта плюс вероятность 2 байта), — 120 ГБ. Поэтому вероятности либо считают на лету, запуская учителя рядом, либо обрезают до верхних вариантов (top-k) и теряют хвост, где как раз и лежит часть тёмного знания.
Общая слабость первых двух способов: ученик учится только на текстах учителя, а пишет потом сам. Стоит ему ошибиться на одном токене, и он оказывается в продолжении, какого в данных не было, — там он ведёт себя хуже, ошибается снова, и ошибки накапливаются. Это называют смещением экспозиции (exposure bias); в теории подражания его разобрали Росс, Гордон и Багнелл (2011) в методе DAgger. Лекарство — дистилляция по политике ученика (on-policy distillation): ученик генерирует ответы сам, учитель на каждом токене этих ответов показывает своё распределение, и ученик учится именно в тех местах, куда он реально попадает. Этот подход описан в работе GKD (Агарвал и соавторы, 2023).
Ограничение способа по политике ученика: учитель должен работать во время обучения, на каждом шаге, и выдавать вероятности. Это дороже по вычислениям и невозможно, если учитель доступен только как закрытый API без вероятностей.
Подробный пример. Упрощённая задача вместо текста: 30 шагов нужно держаться на дорожке (позиция 0), каждый шаг — влево, на месте или вправо. Учитель никогда не ошибается и всегда возвращает к нулю, поэтому в его «текстах» есть только позиция 0. Ученик слабее: в 10% шагов действует случайно, а там, где не видел подсказок, тоже действует наугад.
import numpy as np
# Задача: 30 шагов держаться на дорожке (позиция 0). Шаг: −1, 0 или +1. Учитель всегда возвращает к 0.
# Ученик слабее: в 10% шагов действует случайно. Где он не видел примеров, он тоже действует случайно.
STEPS, EPS, RUNS = 30, 0.10, 4000
teacher = lambda x: int(-np.sign(x))
def run(table, rng, collect=None):
x, on = 0, 0
for _ in range(STEPS):
if collect is not None: collect.add(x)
a = rng.integers(-1, 2) if (rng.random() < EPS or x not in table) else table[x]
x = max(-6, min(6, x + a)); on += (x == 0)
return on / STEPS
rng = np.random.default_rng(1)
offline = {0: 0} # из текстов учителя: он всегда на 0 и всегда «стоит»
print(f"обучение на текстах учителя: доля шагов на дорожке {np.mean([run(offline, rng) for _ in range(RUNS)]):.2f}")
table = dict(offline)
for r in range(1, 3): # по политике ученика: ученик ходит сам, учитель подписывает
seen = set(); [run(table, rng, seen) for _ in range(200)]
table.update({s: teacher(s) for s in seen})
print(f"раунд {r}: состояний с подсказкой {len(table)}, доля шагов на дорожке {np.mean([run(table, rng) for _ in range(RUNS)]):.2f}")
У нас этот код напечатал:
обучение на текстах учителя: доля шагов на дорожке 0.71
раунд 1: состояний с подсказкой 13, доля шагов на дорожке 0.93
раунд 2: состояний с подсказкой 13, доля шагов на дорожке 0.93
Ученик, обученный только на текстах учителя, держится на дорожке 71% шагов: стоит ему один раз сойти, он не знает, как вернуться, потому что учитель никогда не показывал состояния «я уже съехал». После одного раунда, где ученик ходил сам, а учитель подписал все посещённые позиции правильным действием, доля выросла до 93% — ученик научился возвращаться. Второй раунд ничего не добавил: все 13 позиций уже были с подсказкой. В языковой модели «позиция вне дорожки» — это начало ответа с ошибкой, после которого надо уметь исправиться, а таких начал в текстах сильного учителя почти нет.
Где обычно ошибаются.
Дистилляция на уровне последовательностей (sequence-level distillation). ученика учат на готовых текстах, сгенерированных учителем.
Синтетические данные. обучающие примеры, написанные моделью, а не людьми.
Top-k вероятностей. хранение только k самых вероятных вариантов учителя вместо всего словаря.
Смещение экспозиции (exposure bias). ухудшение модели, которая на обучении видела только чужие правильные продолжения, а при работе продолжает свои ошибки.
Дистилляция по политике ученика (on-policy distillation). ученик пишет сам, учитель оценивает его токены, обучение идёт там, куда ученик реально попадает.
Политика (policy). правило, по которому модель выбирает следующий шаг или токен; у языковой модели это её распределение вероятностей.
DAgger. метод обучения подражанием, где учитель подписывает состояния, в которые попал сам ученик.
GKD. обобщённая дистилляция знаний по политике ученика с настраиваемым направлением KL, описанная в 2023 году.
Зачем это в работе. Дистилляцию часто подают как способ «получить большую модель по цене маленькой». В реальности ученик наследует ошибки учителя, а фильтры, которыми их пытаются убрать, меняют состав данных. Ещё есть предел, когда учитель слишком силён для ученика, и юридическая сторона: не каждую модель разрешено использовать как учителя. Об этом надо знать до того, как собирать данные.
Как это устроено. Первое — копирование ошибок. Ученик повторяет учителя, включая выдумки и уверенный тон при незнании. Поэтому синтетические данные обычно фильтруют: в задачах с проверяемым ответом (математика, код с тестами) оставляют только решения, где ответ сошёлся, — это выборка с отклонением (rejection sampling). Но фильтр отбрасывает задачи, которые учитель не решил ни разу, а это в первую очередь трудные задачи. Ученик получает набор, сдвинутый в сторону лёгкого.
Второе — разрыв в размере. Мирзаде и соавторы (2019) показали, что слишком сильный учитель может давать ученику результат хуже, чем учитель средней силы, и предложили промежуточного «ассистента учителя» (teacher assistant): большая модель учит среднюю, средняя — маленькую. Механизм тот же, что в третьей ступени: если ученик не может повторить распределение учителя, он повторяет его плохо и непредсказуемо.
Третье — разные словари токенов. Потеря на вероятностях по токенам требует совпадения словарей; если учитель и ученик из разных семейств, остаётся учить по текстам. Четвёртое — условия использования. Условия OpenAI запрещают использовать ответы её моделей для разработки конкурирующих моделей, у других поставщиков есть похожие пункты; лицензии открытых моделей тоже различаются. Это нужно проверить в тексте условий конкретной модели до обучения, а не после.
Как это проверяют. Сравнивают ученика не с учителем, а с независимым набором задач, отдельно по уровням трудности; смотрят, сколько задач выбросил фильтр и каких; проверяют, не попали ли проверочные задачи в синтетические данные — учитель мог видеть их при своём обучении и выписать почти дословно.
Подробный пример. 10 000 задач разной трудности. Учитель решает задачу трудности d с вероятностью 0,95 − 0,8·d, пишет на каждую 4 решения, а проверка кодом оставляет только верные. Смотрим, что остаётся:
import numpy as np
# 10 000 задач разной трудности. Учитель решает задачу трудности d с вероятностью 0.95 − 0.8·d.
# На каждую задачу учитель пишет 4 решения; проверка кодом оставляет только верные.
rng = np.random.default_rng(2)
d = rng.random(10_000)
ok = rng.random((10_000, 4)) < (0.95 - 0.8 * d)[:, None]
kept = ok.any(axis=1)
print(f"без фильтра неверных решений в данных: {1 - ok.mean():.1%}")
print(f"после фильтра задач осталось: {kept.mean():.1%}")
for lo, hi in ((0, .33), (.33, .66), (.66, 1)):
m = (d >= lo) & (d < hi)
print(f"трудность {lo:.2f}–{hi:.2f}: задач осталось {kept[m].mean():.1%}, верных решений на задачу в среднем {ok[m].sum(1).mean():.2f}")
У нас этот код напечатал:
без фильтра неверных решений в данных: 45.0%
после фильтра задач осталось: 88.8%
трудность 0.00–0.33: задач осталось 99.8%, верных решений на задачу в среднем 3.26
трудность 0.33–0.66: задач осталось 95.0%, верных решений на задачу в среднем 2.24
трудность 0.66–1.00: задач осталось 72.3%, верных решений на задачу в среднем 1.14
Без фильтра 45% решений в данных были бы неверными, и ученик выучил бы эти ошибки. Фильтр убирает все неверные решения и сохраняет 88,8% задач, — выглядит хорошо. Но по трудности картина разная: лёгкие задачи сохранились почти все (99,8%) и в среднем с 3,26 верного решения на задачу, а трудные — только 72,3% и с 1,14 решения. В итоговом наборе на одну трудную задачу приходится втрое меньше примеров, чем на лёгкую, а самые трудные исчезли совсем. Если после этого ученик хорошо проходит средний тест, это ещё не значит, что он справится с трудными задачами.
Где обычно ошибаются.
Выборка с отклонением (rejection sampling). генерация нескольких ответов и отбор только тех, что прошли проверку.
Проверяемый ответ. ответ, правильность которого можно проверить автоматически: числом, тестами или сравнением с эталоном.
Перекос к лёгким задачам. сдвиг состава данных после фильтра, когда трудные задачи выпадают чаще.
Разрыв в размере (capacity gap). ситуация, когда ученик слишком мал, чтобы повторить распределение учителя.
Ассистент учителя (teacher assistant). модель промежуточного размера, через которую знание передают от большой модели к маленькой.
Утечка проверочных данных (contamination). попадание тестовых задач в обучающие данные, из-за которого оценка становится завышенной.
Условия использования (terms of use). правила поставщика модели, которые могут запрещать обучение других моделей на её ответах.
Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.