КПД

⚙️ Метод

MMD есть мера различия между двумя распределениями P, Q. Задается некоторый положительно определенный кернел k, и MMD определяется как:

k(P, Q) =
\mathbb{E}_{x,x'\sim P}[k(x,x')]
+ \mathbb{E}_{y,y'\sim Q}[k(y,y')]
- 2\mathbb{E}_{x\sim P,\,y\sim Q}[k(x,y)]

Кернел k может быть линейным, RBF или чем-то еще.

Далее вопрос — что мы хотим туда подставлять и как?

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

- 🌐 Для безусловной генерации в непрерывном пространстве подаются все позиции.
- 💬 Для условной — только позиции ответа.
- 🎭 Для маскированной диффузии — только с позиций маскированных токенов.

И все попарно усредняется по всей последовательности.

MMD можно разбить на три члена:

- 🤝 real–generated — способствует тому, что признаки из распределения P похожи на Q.
- 🎲 generated–generated — способствует разнообразию внутри распределения P.
- 🗑️ real–real — нахрен не сдался, и его можно выкинуть.

Для дискретных диффузионных моделей дифференцировать через категорическое распределение не представляется возможным. Потому используется REINFORCE для оптимизации. Чтобы уменьшить дисперсию градиента, сэмплируется группа MMD-батчей для конкретного примера и оптимизируется policy-gradient суррогат.

Для непрерывных диффузионных моделей важно делать self-conditioning (обусловливание на прошлые выходы модели). В процессе обучения важно подавать такие примеры, backprop делается только через последний шаг генерации. Чтобы уменьшить число шагов на инференсе, дополнительно предлагается iterative refinement distillation (IRD), где студент в один шаг пытается воспроизвести несколькошагового MMD-учителя.

🧪 Эксперименты

Метод валидируется на предобученных MDLM для дискретных моделей и ELF поверх разных энкодеров в непрерывном случае.

• MDLM-MMD достигает лучшего качества, измеряемого по gPPL / Энтропия, против DiDi и IDLM бейзлайнов.
• ELF-MMD / ELF-MMD-IRD также оказывается лучше ELF\*, FMLM\* на разном числе шагов.

Кроме того, выводы обобщаются и на GSM8k для случая условной генерации.

Подход масштабируется и на более-менее серьезные модельки, в частности, DMax поверх LLada-2.0-Mini. MMD-модель на наборе математических и кодовых бенчей не уступает базовой модели и DMax, при этом выдавая больше tokens-per-forward — т. е. обещает более быструю генерацию. И учить недолго — порядка 2 H100 ГПУ-часов.

❤️ Выводы

Мораль сей басни такова — любите MMD, друзья.

А вообще, можно энкодить все на языке brainfuck и иметь Тьюринг-полную систему.

🛠 Метод

Типичный scaling law имеет вид:

L(N, D) = A N^α + B D^β + c

🔄 Скейлинг по рекурсии

Ранее делали попытки вывести scaling law для looped-моделей, считая, что эффективное количество параметров N_eff масштабируется линейно с глубиной рекурсии либо убывает как-то степенным образом. Но на практике на самом деле быстро наступает насыщение, потому авторы предлагают экспоненциальное затухание, ограниченное сверху (κ₁, κ₂ — некоторые константы, R — глубина рекурсии).

N_eff(R) = N + κ₁ N_loop (1 − e^(−(R−1)/κ₂))

И опыт показывает, что такое лучше согласуется с экспериментом.

🧩 Скейлинг по рекурсии для MoE

Для MoE ситуация несколько интереснее, потому что при повторном прогоне могут активироваться другие эксперты, потому несколько прогонов могут извлечь больше информации. В пределе бесконечного числа экспертов ожидаем, что эффективное число параметров должно линейно масштабироваться с глубиной рекурсии. Отсюда возникает идея сделать константы κ₁, κ₂ функциями от m — разреженности модели.

N_eff(R, m) = N_act + κ₁(m) N_loop (1 − e^(−(R−1)/κ₂(m)))

κⱼ(m) = κⱼ m

🧪 Эксперименты

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

📈 Наблюдение 1. Масштабирование рекурсии приводит к выходу на плато, но чем больше экспертов, тем выше польза (прирост N_eff против R = 1).

⏳ Наблюдение 2. Чем дольше мы учим и чем больше разреженность, тем полезнее делать больше рекурсий.

💾 Наблюдение 3. Чем больше у нас VRAM и рекурсия, тем выгоднее иметь высокую разреженность.

⚖️ Наблюдение 4. При фиксированном бюджете на вычисления при нехватке памяти лучше инвестировать в рекурсию, при обилии — в разреженность MoE.

Потом пытаются понять, как это скажется на масштабе при обучении на downstream.

Учат бейзлайновый MoE и вдвое меньший как по числу активных, так и по числу общих параметров. При фиксированном бюджете обучения удаётся выжать около паритета при R = 4, 5 на MMLU/GSM8k, но уступая всё же в среднем по бенчам.

💡 Выводы

Вопрос оптимального масштабирования Looped MoE, безусловно, интересен, ибо потенциально даёт путь к более мощным, но компактным по общему числу параметров моделям. Однако, судя по экспериментам, всё же при заданном числе FLOPs на инференсе при том же претрейне Looped-модель будет слабее более жирной.

⚙️ Метод

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

Задачи можно разделить на:

- 🔢 decode-heavy — когда генерируется длинный ответ, цепочки рассуждений и тому подобное;
- 📚 prefill-heavy — объёмный вход, но короткий ответ.

Можно ожидать, что в первом случае важнее сохранить точность на этапе декода, а во втором — на префилле. И действительно, оказывается, что при прогоне более интенсивного этапа в более низкой точности (а другого — в bf16, скажем) качество просаживается заметно сильнее, чем если делать наоборот. Сжатие и на префилле, и на декоде (в NVFP4) ожидаемо даёт ещё большую ошибку.

Format disaggregated quantization предлагает следующее. Исходно у нас есть квантизованные веса в какой-то точности (NVFP4, LUT-3bit, LUT-2bit). На префилле переквантовываем веса в NVFP4 (для LUT-форматов) и используем эффективные GEMM для FP4. На декоде — weight-only квантизация.

LUT* — lookup table

🔬 FULLY-DISAGGREGATED QUANTIZATION

Чтобы улучшить качество, предлагается дообучать специализированные квантизованные модели под префилл и декод.

Делается это следующим образом:

- 🔹 Промпт прогоняем через prefill-модель, а ответ — через decode-модель. Каждая из экспертных моделей инициализируется весами исходной модели.
- 🔹 Лосс считаем только по токенам ответа, но градиент через KV протечёт и в prefill-модель, позволяя оптимизировать и качество префилла.
- 🔹 Prefill- и decode-модели учатся через QAD (Quantization Aware Distillation) — через KL между логитами квантизованных моделей и исходной модели.

Это позволяет немного поднять качество.

💽 OFFLOADED DISAGGREGATED PREFILL

Чтобы не грузить две модели в памяти, префилльные блоки можно подгружать по очереди, набирая KV-кэш, а затем сгружать обратно на диск. Если префилл и генерация достаточно долгие, то замедление от перекачки весов с SSD в VRAM не сильно замедляет инференс, зато позволяет экономить память ускорителя вычислений.

🛠️ Prefillers

А ещё можно обучать специальный NVFP4-префиллер под заданную замороженную квантизованную модель, дабы заранее компенсировать ошибку квантования.

📊 Эксперименты

Метод валидируют на семействах Qwen3 / Gemma3. В качестве decode-heavy задач рассматриваются всякие математические задачи (AIME, MATH500), а для prefill-heavy — long-context-бенчмарки из RULER.

Format disaggregation консистентно даёт лучшее качество, чем наивная weight + activation-квантизация, при примерно той же скорости как префилла, так и декода. Full disaggregation даёт некоторое улучшение качества, а оффлоадинг позволяет сэкономить VRAM.

Для больших моделей (Qwen3.8-2.4T, Kimi-K3) дезагрегация в W4A4 даёт небольшой, но всё же прирост качества.

Обучение префиллеров для разных GGUF-квантов Qwen3.8-27B позволяет при той же скорости инференса на декоде заметно поднять качество, особенно в случае сильного сжатия, как IQ1_S и IQ1_M.

✅ Выводы

Результат важный и практически интересный. Как будто то, к чему стоит стремиться всем инференс-провайдерам, балансирующим между качеством и скоростью.

🛠️ Метод

Авторы предлагают довольно интересную схему генерации негативного условия:

- 📝 Берём задачу.
- 🤖 Текущая student-модель обычным образом генерирует начальное решение.
- 🧩 Затем модели дают и исходную задачу, и её собственное решение и отдельным meta-prompt просят придумать инструкцию, которая могла бы направить рассуждение по плохому пути.
- ⚠️ Полученная инструкция добавляется к задаче и используется для построения negative teacher.

При этом gold answer не используется. Поэтому модель не обязана знать, где решение действительно ошибочно. Ей нужно найти потенциально уязвимое место или предложить вредную стратегию рассуждения.

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

Вместо этого вводят gating на разницу вероятностей референсной модели (с правильной инструкцией) и negative teacher. Если negative teacher не повысил или не сильно повысил вероятность данного токена, то данный токен не влияет на итоговый лосс. Это позволяет избежать штрафа за обычные лингвистические конструкции.

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

Для стабильности накидывают KL-дивергенцию с исходной моделью с каким-то весом, но не ванильный вариант, а importance-weighted estimator на одном примере.

📊 Эксперименты

Свой метод валидируют они на семействе моделей Qwen3 (1.7B, 4B, 8B). Оценивают качество на AIME, HMMT и ещё паре математических бенчей.

Сравниваются с OPSD, Intuitor, TTRL (вариант GRPO).

Учат все на MATH.

Метод выдаёт метрики чуть лучше, чем бейзлайны и исходная модель, и якобы успешно справляется с проблемой overconfidence и исследует больше различных опций.

Из приятного: шаг обучения ещё дешевле, чем у бейзлайнов. GRPO требует сэмплирования группы роллаутов, а тут достаточно одного семпла. А OPSD нужно больше top-k вероятностей для успешной работы.

KL на исходную модель важен: без него обучение разваливается и модель коллапсирует.

💭 Выводы

Идея занимательная. Но валидация будто бы на маленьком масштабе, и работает, наверное, когда модель уже сама по себе достаточно хороша, но иногда её клонит не туда, а такое дообучение позволяет избегать ошибок в некоторых случаях. Нет валидации поверх base/sft чекпоинтов. Неизвестно, насколько оно масштабируется на промышленные RL-сетапы с множеством сред.

⚙️ Метод

💡 Идея довольно проста: некоторую долю r от обучения подаём на вход и пытаемся предсказать несколько следующих токенов, а именно:

- 🔤 Токенизируем текст как обычно.
- 📊 После прогона через матрицу эмбеддингов усредняем s подряд идущих токенов. Проходимся по тексту непересекающимися окнами размера s.
- 🎯 На выходе предсказываем s следующих токенов без учёта порядка.

Итоговый лосс — просто усреднение кросс-энтропии для каждого следующего токена.

💸 Экономия достигается за счёт того, что на обучении мы гоняем в s раз меньше токенов через модель. Т. е. за тот же бюджет прогонов токенов через LLM модель видит в r·s + (1 − r) раз больше данных из корпуса.

После окончания этой стадии переходим к стандартному обучению на исходных токенах.

🧪 Эксперименты

Метод валидируют на трёх dense llama-like моделях (270M, 600M, 3B) и (10B-A1B) MoE.

При заданном количестве FLOPs и даже Wall time по итоговому лоссу оно оказывается лучше бейзлайна, который просто учится на токенах. И вроде даже метрики чуть получше, хоть и все едва лучше рандома.

📈 Оптимальнее всего ставить r в диапазоне от 0.2 до 0.4. Если меньше, то слишком мала доля обучения на усреднённых токенах, чтобы дать выигрыш; если больше — модель не успевает перестроиться на стандартное обучение.

Оптимально по качеству ставить s в диапазоне 5–8.

Можно по отдельности усреднять на входе или предсказывать bag-of и даже так получать выигрыш, но и то и другое вместе работает ещё эффективнее.

Output-усреднение сродни MTP, а MTP вроде бы считается полезным для ускорения сходимости.

🤔 А вот почему input-усреднение хорошо работает, не очень очевидно. Авторы говорят про какую-то регуляризацию, smoothing латентного пространства. Но без чёткого понимания.

Из интересного ещё оказывается, что предсказывать мешок следующих токенов работает лучше, чем пытаться задать какой-то порядок. Явная добавка позиционных эмбеддингов на выход только портит качество.

Всякие манипуляции с RoPE, попытки адаптировать их под усреднение токенов ни к чему не привели.

⚠️ Кроме того, авторы отмечают, что в случае ограниченного количества данных их метод менее data-efficient, так как использует огрублённые токены, тем самым теряя часть информации.

💡 Выводы

Дешёвый и простой способ удешевить претрейн. Вопрос — в масштабируемости на большие сетапы. Кажется, что сильное огрубление токенов работает, пока сама модель ещё очень плоха и ничего не умеет. А когда она начинает выдавать адекватные метрики, слишком много ценной информации может теряться, ограничивая достижимое качество.

Вместо того, чтобы заниматься всякой фигней, типа уравнения Навье-Стокса, лучше бы OpenAI показали робота, который может снимать обои и шпаклевать стены.