КПД

🔬 Метод

Рассматривают 4 пары конфигураций квантизации:
📌 MXFP8/MXINT8
📌 MXFP6/MXINT6
📌 MXFP4/MXINT4
📌 NVFP4/NVINT4

MX-варианты квантизуются группами по 32 веса с E8M0 скейлами, а NV группами по 16 весов с E4M3 скейлами. И на FP / INT сетку значений, соответственно.

Исходя из предположения о гауссовости распределений, выводят формулы для ошибки квантизации (вернее SNR). Откуда следует, что при большом значении отношения максимального элемента к стандартному отклонению (при per-tensor квантизации или больших группах) предпочтительнее FP, а при малых группах - INT.

Реальные веса и активации не совсем гауссовы, но их можно сделать более гауссовыми Адамаровыми вращениями.

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

Эмпирически проверяют полученные законы на весах/активациях и градиентах Llama-3.1-8B. Оказывается, что без вращений FP форматы лучше, за исключением случая NVINT против NVFP. C вращениями MXINT8 лучше MXFP8, MXINT6 хуже MXFP6, MXINT4 хуже MXFP4, NVINT4 лучше NVFP4.

Затем смотрят на KL-дивергенцию c исходной моделью, утверждая что бенчи шумные и не репрезентативные. Без поворотов FP обычно лучше, с поворотами - наоборот,

Затем учат 1B и 3B модельки на 100B/200B токенах. MXFP8/MXINT8 по лоссу и бенчам +/- как исходная модель, лосс MXINT на тютельку ниже.

Потом говорят, что INT формат предпочтительнее, потому что жрет меньше энергии.

💡 Выводы

Данный результат в некоторой степени показывает, что зря NVIDIA (в угоду маркетингу? 💲) похерили поддержку INT в новых архитектурах. Особенно с учетом того, что при маленьких группах FP - не выигрышный вариант. Протокол сравнения немного вызывает вопросы - все-таки 0-шоты в post-training режиме тоже было бы не лишним привести. Ну и то, что Адамаровы вращения прямо сильно вредят float-у и помогают int-у тоже немного удивительно.

INT v.s. FP: A Comprehensive Study of Fine-Grained Low-bit Quantization Formats
[Статья] [Код]

Введение

С увеличением потребности в удешевлении обучения и инференса все более остро стоит вопрос об обучении в более низкой точности. Одна зеленая компания сначала внедрила аппаратную поддержку FP8, а затем и FP4.

Однако почему FP, а не INT 🤔? NVIDIA в статьях и блогпостах никак не обосновывала данный выбор, потому мотивация остается тайной, покрытой мраком 🌚.

И группа ребят-тиктокеров 🕺 решила сравнить INT и FP в сопоставимых условиях.

Точность имеет значение

У наиболее распространенного на данный момент для обучения формата bfloat16 всего 7️⃣ бит на мантиссу. Обычно полагается, что такой формат lossless с точки зрения обучения и инференса (есть работы указывающие на сложность в воспроизводимости результатов в bf16).

Однако для некоторых слоев и тензоров, могут быть интересные последствия.

Некоторое время назад, обучая модельку, мы обнаружили, что веса при RMS нормах вообще не сдвинулись с места. При этом градиент тек по ним, и оптимизатор вполне себе их захватывал.

А дело в том, что в момент инициализации веса при RMS норме равны 1, и если обновление по величине не превышает 1e-3, то вес никогда не изменится.

В bfloat16: 1 + 1e-3 = 1

Собственно для таких ситуаций и нужна мастер копия в fp32.

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

Метод валидируют путем дообучения Dream-7B-Base, которую сначала учили на авторегрессию, а затем на диффузию.

Разметку для обучения собирают с помощью Gemini переформатируя примеры из Slim Orca в требуемый вид (план + ветви рассуждения). Неудачные примеры выбрасывают.

В качестве бейзлайнов берут просто авторегрессию, текстовую диффузию, и ускоренную диффузию Fast-dLLM.

Качество оценивают на AlpacaEval c LLM-as-a-judge, следуя некоему стандартному протоколу. Дабы получить лучший результат и честное сравнение для каждого из вариантов учат 2, 4, 8, или 16 эпох и выбирают лучшую модель. Для авторегрессии оптимальны 2 эпохи, для диффузионных постановок полезно учить подольше - 16 эпох.

Planned диффузия по качеству не сильно уступает авторегрессии, но при этом работает быстрее. В среднем удается добиться в 2.3 раза меньшего числа forward пассов по сравнению с AR, но конечное ускорение несколько меньше - 1.8x для независимых потоков, и 1.3x при dense-attention.

PD-DA несколько лучше по качеству, чем просто PD, но и медленнее (нельзя пропустить вычисления attention-а в некоторых блоках).

Далее ablaтят необходимость <topic> и <sync> тегов. При пропуске <topic> качество просаживается сильно, но от потери <sync> не сильно страдает и получается к тому же еще быстрее.

Кроме того, пробуют подавать на инференсе диффузии меньше или больше токенов, чем “спланировала” авторегрессия. Оптимальное качество достигается когда их столько же. Но если важна скорость - можно подавать более короткие цепочки [MASK] с умеренной просадкой.

💡 Выводы

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

🔬 Метод

Авторегрессия в стандартной постановке предсказывается следующий токен на основе предыдущих, а маскированная диффузия - вероятность [MASK] токена стать токеном из словаря при условии окружающих токенов. Авторегрессия предсказывает по токену за раз, диффузия может сразу несколько, но для лучшего качества требуется обыкновенно несколько прогонов через модель.

Planned diffusion работает следующим образом:

1️⃣ Сначала авторегрессионно генерируется некий контекст и черновик для дальнейшей генерации. Предполагается, что есть несколько ветвей рассуждения, которые можно генерировать независимо, и для каждой из авторегрессия предсказывает сколько токенов надо расшумить.
2️⃣ Затем диффузия, имея контекст и заданное количество [MASK] токенов, генерирует какую-то ветвь.
3️⃣Затем происходит синхронизация и генерируется заключение.

Контекст размечается специальными <topic> (</topic>) тегами. Асинхронные параллельные блоки <async> (</async>) тегами. Точка синхронизации - <sync> тегом.

Рассматривают два случая - когда токены в параллельных ветвях не смотрят 🙈 друг на друга (PD), и когда смотрят 👀 (PD-DA).

Обучение происходит следующим образом - в последовательности в нужном формате (с разметкой) зашумляют до некоторого уровня ветви рассуждения, и модель учится одновременно на авторегрессионный и диффузионный лосс (то есть предсказывать правильно план и рассуждения).

На инференсе при авторегрессионой генерации можно использовать сгенерированный ранее KV-кэш, но для текущего шага диффузии из-за full attention все токены в ветви рассуждения генерируются по новой.

При декодировании диффузией используют энтропийный порядок - декодируются первыми те токены, где модель более уверенна.

PLANNED DIFFUSION
[Статья] [Кода нет, во[MASK}но, [MASK]ируется]

Введение

На текущий момент авторегрессия и диффузия являются доминирующими парадигмами в мире генеративного ИИ. Первая преобладает в языковых и прочих задачах, предполагающих работу с последовательностями, вторая - при генерации изображений и видео. И еще были попытки и как-то комбинировать.

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

Выкатили на Хабр лонгрид про EvoPress 💪, представленный на ICML прошедшим летом.

🔬 Метод

Существенным затруднением при квантизации БЯМ является наличие выбросов в весах и неравномерный диапазон значений в разных входных и выходных каналах.

Можно упрощать квантизацию с помощью поворотов или масштабирования (как в SmoothQuant). И предложенный метод похож на SmoothQuant, но с добавлением скейлинга на выходе.

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

Оптимизировать эту меру предлагается через модифицированный итеративный алгоритм Sinkhorn-Knopp (который в оригинале используется для приведения матрицы к двойной стохастической).

Сами итерации выглядят довольно просто - считаем стандарные отклонения строк и столбцов, делим на них, и повторяем до посинения сходимости.

Метод можно комбинировать с data-aware алгоритмами - типа GPTQ и AWQ.

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

Метод валидируют на моделях семейства Qwen-3 (включая 235B) и DeepSeek-V2.5 (V3 не смогли поместить на один хост, по всей видимости)

SINQ несколько превосходит data-free методы (bnb, HQQ) по качеству.

Замеряют не только стандартные бенчи, но и flip-ы (долю токенов, где argmax отличается у исходной и квантизованной модели), коя есть более устойчивая и монотонная мера.

SINQ с AWQ немного лучше data-free версии.

Квантизуются модели достаточно быстро - от 3с до 50с для 32B Квена 3. Для больших моделей почему-то не приводят время.

В качестве бейзлайнов фигурирует HIGGS. Но результаты подозрительно плохие, хуже, чем однородная int квантизация. Вероятно, забыли про Адамаровы повороты.

Кернелов под дополительный скейлинг на выходе пока не завезли. Замеров скорости нет.

💡 Выводы

Поиск скейлов предложенным образом выглядит концептуально новым. Дешевизна и простота метода при наличии удобных интеграций может снискать ему популярность. Однако кажется, что бейзлайны плоховато заведены судя по метрикам. Ну и оверхед на квантизацию, полезность при MXFP4/NVFP4 квантизации тоже немаловажны.

SINQ: Sinkhorn-Normalized Quantization for Calibration-Free Low-Precision LLM Weights
[Статья] [Код]

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

И авторы сегодняшней статьи (народное название алкашки 🥂 тут не причем, это от фамилии Sinkhorn) предлагают типа дешевое и эффективное решение.

Кринжовые задачки из GSM8k

🔬 Метод

В качестве метода квантизации предлагают использовать NVFP (а чего вы еще хотели от ребят из NVIDIA). Квантизация weight-only (активации не трогают).

LoRA адаптер встраивается в параллель к модели как в QLoRA.

RL осуществляется посредством пресловутого GRPO и его модификации DAPO.

Из интересного и нового - зашумление весов, которое способствует exploration 👀. Квантизация - своего рода тоже шум, но детерминированный, а хочется каждый раз какой-то новый. Можно добавлять аддитивный к весам, но это дорого, потому что требует хранить де-факто тензоров на еще одну копию модели в half-precision, а хотелось держать в памяти только квантизованную модели. Потому шум в конечном итоге накладывается в RMS-норме перед проекциями и он эквивалентен мультипликативному шуму.

Величина шума постепенно убывает с некоего максимального значение (1e-2) до минимального (5e-4) по экспоненциальному расписанию.

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

Метод валидируют на моделях семейства Квен-2.5. В качестве датасетов для обучения используют GSM8k и BigMath. Модели квантизуют через AWQ.

Качество замеряют на GSM8k, AIME24, AIME25, AMC, MATH 500.

NVFP квантизация перед началом обучения немного снижает качество, но меньше, чем NF4 из bits-and-bytes (стоит заметить, что битность NVFP4 больше). В процессе дообучения квантизованная модель с адаптером становится лучше half_precision + LoRA. Здесь, правда, имеет место опасение, что бейзлайно плохо заведен.

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

От выбора ранга LoRA результат не сильно меняется.

Декларируемое ускорение обучения - до 2x (на H100) против bf16 на маленьких батчах, и порядка 20% на батче размера 8 (длина последовательности 2k). NF4, напротив, работает медленее, чем bfloat16. Ускорение NVFP4 достигается за счет того, что авторы генерируют роллауты в memory-bound режиме, с эффективным Marlin-like кернелом. Большие батчи не влезают или авторы не пробовали 🤔?

💡 Выводы

Дообучение квантизованных моделей с LoRA адаптерами выглядит как рабочее и доступное решение для энтузиастов заалайнить модельку. Данная статья рассматривала сценарий memory-bound по весам модели. Интересно, насколько хорошо предложенная стратегия заведется в compute-bound режиме, при weight + activation NVFP4 квантизации (дабы задействовать всю мощь FP4 вычислений) и на очень длинных контекстах (где в первую очередь важно квантизовать кэш).

QERL: BEYOND EFFICIENCY – QUANTIZATION-ENHANCED REINFORCEMENT LEARNING FOR LLMS
[Статья] [Код]

Введение

Все современные SOTA языковые модели в процедуре обучения так или иначе содержат RL в том или ином виде. Несмотря на то, что RL этап требует обычно меньше вычислений (есть работы, которые предлагают сразу с RL-я стартовать) по сравнению с претрейном, он все равно может быть достаточно дорогим, чтобы был соблазн на нем сэкономить.

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

Hierarchical Reasoning Model
Guan Wang, Jin Li, Yuhao Sun, Xing Chen, Changling Liu, Yue Wu, Meng Lu, Sen Song, Yasin Abbasi Yadkori
Статья: https://arxiv.org/abs/2506.21734
Код: https://github.com/sapientinc/HRM

Иерархического лонгрида вам на выходные!

Не сделал в своё время ручной разбор этой работы про HRM от сингапурцев из Sapient Intelligence (сделал правда автоматический), но она важная, стоит разобрать. Тем более, что свежая TRM (https://arxiv.org/abs/2510.04871) ей вдохновляется.

Эта интересная летняя работа предложила вдохновлённую мозгом иерархическую модель с быстрой и медленной сетями. Модель была довольно скромного размера (27M) и обучалась всего на 1000 примерах. При этом она получила очень высокие скоры на нескольких сложных задачах. В частности, она также сумела обойти o3-mini-high (а также гигантскую DeepSeek-R1 и Claude 3.7) на ARC-AGI-1 и 2, что весьма круто. Что стоит за этой моделью и как она работает? Разберём.

Современные трансформеры добились значительных результатов в разных задачах, но сама их архитектура в целом довольно неглубокая с фиксированной глубиной (но есть исключения с рекурсией или динамической глубиной). Из-за этого они ограничены низкими классами вычислительной сложности (такими как AC⁰ или TC⁰, https://arxiv.org/abs/2308.03212, схемы фиксированной глубины) и с трудом справляются с проблемами, требующими глубокого, итеративного и алгоритмического мышления. Напомню, что RNN сидят в более высоком классе и вообще вроде как Тьюринг полны. Подробнее про классы тут (https://en.wikipedia.org/wiki/TC_(complexity)).

Вдохновляясь иерархической обработкой на разных временных масштабах, присущей человеческому мозгу, авторы представляют Hierarchical Reasoning Model (HRM) — новую рекуррентную архитектуру.

🏗 Структура HRM

В основе HRM лежат три принципа, наблюдаемые в нейронных вычислениях: иерархическая обработка, разделение во времени и рекуррентные связи. Архитектура включает два взаимозависимых рекуррентных модуля, работающих на разных временных масштабах:

1. Высокоуровневый (H) модуль для медленного, абстрактного и обдуманного планирования.
2. Низкоуровневый (L) модуль для быстрых, детальных и подчинённых вычислений.

Динамика модели разворачивается в течение N высокоуровневых циклов, каждый из которых состоит из T низкоуровневых временных шагов. L-модуль обновляется на каждом шаге, и его состояние зависит от H-модуля, который остаётся неизменным на протяжении всего цикла. H-модуль обновляется только один раз за цикл, используя конечное состояние L-модуля.

- Иерархическая сходимость

Cтандартные RNN имеют тенденцию сходиться преждевременно. Когда скрытое состояние установилось около фиксированной точки, магнитуды обновлений уменьшаются, по факту замораживая последующие вычисления и ограничивая эффективную глубину сети. Хочется, чтобы сходимость была постепенной, но синженерить этот подход трудно. HRM борется с преждевременной сходимостью с помощью процесса, который авторы называют иерархической сходимостью (Hierarchical convergence). В каждом цикле L-модуль сходится к локальному равновесию, но оно зависит от высокоуровневого состояния модуля H, которое тот выдал для данного цикла. После T шагов, H-модуль инкорпорирует в себя полученный результат и обновляет своё состояние, тем самым задавая новый контекст для следующего цикла L-модуля, который теперь сойдётся к другому локальному равновесию.

Это похоже на менеджера проекта (H-модуль), который ставит конкретную подзадачу (например, «решить этот угол в судоку»). L-модуль выступает в роли исполнителя, который быстро итерируется для решения этой конкретной подзадачи. Как только исполнитель заканчивает, он отчитывается, и менеджер использует этот результат для постановки следующей подзадачи. Это не даёт модели застрять и позволяет ей выполнять структурированные, многошаговые вычисления, поддерживая высокую активность на протяжении многих шагов и достигая эффективной глубины NT.

Вчера мы затронули Tiny Recursion Model, и на gonzo-обзоры ML статей сегодня вышел подробный и содержательный лонгрид про Hierarchical Reasoning Model.

Рекомендую к прочтению)

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

TRM валидируют на Sudoku-Extreme, Maze-Hard и ARC-AGI 1 / 2. TRM, оказывается стабильно лучше HRM. На ARC-AGI метрики оказываются на уровне ведущих reasoning моделей (несколько уступая Grok 4).

Для обучения TRM используется train set, к которому применяются всевозможные аугментации, определяемые симметриями задач. TRM-MLP-Mixer хорош на Sudoku, но уступает TRM-Attn на остальных задачах.

💡 Выводы

Выходит, что в определенных нишах небольшие специализированные модельки все еще способны конкурировать с массивными general-purpose. С практической точки зрения интересно, возможно ли отмасштабировать такую или подобную архитектуру на real-world задачи. Концепция итеративного обновления решения близка к диффузионным моделям, можно ли это рассматривать как некоторое обобщение?

🔬 Метод

Эффективной стратегией при решении сложных задач является итеративное улучшение решения. Авторегрессионные языковые модели добиваются этого с помощью длинных цепочек рассуждений и для того, чтобы такой механизм эффективно работал, требуется дообучение на специальных данных или некая вариация RLя.

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

HRM

В HRM 4 обучаемые компоненты:
📌 Входной эмбеддинг f_I(x)
📌 Низкоуровневая сеть f_L(x + z_L + z_H), обновляющая состояние z_L
📌 Высокоуровневая сеть f_H(x + z_L + z_H), обновляющая состояние z_H
📌Выходной эмбеддинг f_O(z_H)

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

Чтобы такую конструкцию можно было обучать эффективно по памяти, авторы делают предположение, что на последней итерации уравнение обновления скрытых состояний сошлось к фиксированной точке и можно делать приближение 1-го порядка, из которого следует, что достаточно считать градиенты только на последней итерации, а прошлые гонять с no_grad менеджером контекста. Тем самым не нужно хранить объемный граф вычислений.

В HRM максимально число итераций выставляется в 16, но бывает так, что можно сойтись гораздо раньше. И для этого обучают специальную голову поверх z_H, которая говорит, пора ли останавливаться.

За счет нескольких прогонов имеем эффективно большую глубину. Данный подход напоминает AlBERT, и Adaptive Computation Time из бородатых 🧔‍♂️ времен.

👶 TRM

В TRM предлагают переосмыслить архитектуру и процедуру обучения TRM. Вместо низкоуровневого и высокоуровневого состояния есть только одно скрытое состояние z и ответ y. Фактически z_L выполняет роль y, а z_H - z.

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

Далее авторы замечают, что не имеет смысла держать две модели (low-level и high-level) и одна модель работает не хуже.

Использование одного скрытого состояния z и выходного признака оптимально по качеству. Добавление большего числа скрытых состояний только ухудшает качество, якобы потому что это неестественно 🤷‍♂️ (более строго аргумента не приводится), а одно состояние на ответ тоже сильно хуже - мол, пытаемся в один вектор впихнуть и решение и скрытый признак. Логика такая, что модели нужно держать последнее актуальное решение и то, как она к нему пришла.

Хаки для улучшения качества

Делать модель больше не имеет смысла в виду ограниченности обучающей выборки. 2-слойная модель работает лучше всего, 4-слойная уже переобучается (регуляризации, правда, не особо шатали, по всей видимости).

Для малой длины контекста (рассматриваемые задачи имеют фиксированный размер входов) вместо Attention лучше себя показывает MLP-Mixer . На задачах побольше MLP-Mixer более склонен к переобучению, и потому берется стандартный трансформер.

Кроме того, для стабилизации обучения и борьбы с переобучением используют экспоненциальное скользящее среднее (EMA).

Количество рекурсий и отношение частоты обновление y и z настраивается для выжимания максимального качества.

Less is More: Recursive Reasoning with Tiny Networks
[Статья][Код]

Введение

Большие языковые модели прокачались за последнее время настолько, что уже могут решать (если надлежащим образом завести) сложнейшие олимпиадные задачи и контексты по программированию. Однако, некоторые классы задач (вероятно, из-за формата не очень привычного и удобного для них) до сих пор даются им со скрипом - ARC-AGI 1 / 2 имени Франсуа Шолле, судоку и разные паззлы.

Специализированные небольшие модели, с нужными inductive bias-ами вполне способны с ними конкурировать.

Некоторое время назад вышла Hierarchical Reasoning Model (HRM) , которая при скромных размерах (27M параметров) выбила хорошие метрики на вышеупомянутых головоломках.

В разбираемой сегодня работе было предложено некоторое развитие идеи HRM под названием Tiny Recursion Model (TRM), которое оказалось эффективнее и по размеру (7M параметров) и лучше по метрикам.

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

Метод прогнали на семействах моделей Llama-3 и Qwen-3. Качество замеряли на 4 задачах из OpenLLM Leaderboard V1 (GSM8K, MMLU-CoT, HellaSwag, Winogrande). И отдельно для Llama-3.1-8B-Instruct Platinum бенч (сборная солянка из задач, откуда почистили примеры с забагованными условиями или ответами).

Основные наблюдения следующие:
📌 INT4 (group_size=32, без квантизации скейлов) ~= NVFP4
📌 MXFP4 заметно хуже NVFP4 по качеству
📌 Вращения заметно улучшают MXFP, но не особо полезны для NVFP. Разрыв между двумя MXFP и NVFP все равно существенный.
📌 QAT тоже дает более заметный прирост метрик для MXFP, для NVFP побить GPTQ оказывается непросто.
📌 Для малюток размером 1B параметров просадки большие - до 20% от исходного качества, для моделей побольше - Qwen3-32B / Llama-3.3-70B-Instruct в пределах 1-2%.

Использование QuTLASS кернелов для матричных умножений позволяет достичь ускорения, близкого к максимально возможному (без учёта операций с поворотами и скейлами). MXFP демонстрирует немного более высокую скорость по сравнению с NVFP. Матричные операции ускоряются в 4 раза на B200 и в 6 раз на RTX5090 (против half precision). Общее ускорение (end-to-end) составляет до 2 раз на B200 и до 6 раз на RTX5090.

💡 Выводы

FP4 в режиме post-training weight+activation квантизации дает довольно хорошее ускорение, но некоторую просадку в качестве. Отказ от FP в пользу INT не столько уж очевидно правильный шаг. На рассмотренных задачах большие модели почти lossless, но не факт, что так будет на бенчах посложнее - требующих сложных цепочек рассуждений или агентских. Будем посмотреть.