Диффузионные языковые модели: как NVIDIA пробует научить LLM писать текст не слева направо

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

Так работают GPT-подобные модели, Llama, Qwen и большинство чат-ботов. Модель смотрит на уже написанный контекст и предсказывает следующий токен. Потом ещё один. Потом ещё один.

Примерно так:

Языковая → модель → генерирует → текст → последовательно

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

NVIDIA в Nemotron-Labs Diffusion пробует другой путь: языковая модель не просто «дописывает следующее слово», а постепенно проявляет текст, как диффузионные модели проявляют изображение из шума.

Звучит непривычно, но идея интересная.

В чём проблема авторегрессии

Авторегрессионные модели стали стандартом не случайно. Их удобно обучать: даём текст и просим модель предсказать следующий токен. На больших данных это работает отлично.

Но у такого подхода есть два ограничения.

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

Второе: генерация плохо параллелится. Чтобы получить 4096 токенов, модели нужно сделать длинную цепочку последовательных шагов. GPU может быть очень мощным, но логика вывода всё равно остаётся «один токен за другим».

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

Что значит «диффузия» для текста

В изображениях диффузия работает интуитивно: берём шум и постепенно убираем его, пока не появится картинка.

С текстом сложнее. Токены — не пиксели, к ним нельзя просто добавить гауссов шум. Поэтому в языковых диффузионных моделях используется другая идея: masking.

Упрощённо процесс выглядит так:

Исходный текст:
Диффузионная модель генерирует текст иначе

Зашумлённая версия:
Диффузионная [MASK] генерирует [MASK] иначе

Задача модели:
восстановить скрытые токены

Во время обучения модель видит текст, где часть токенов заменена на [MASK], и учится восстанавливать пропуски. Причём уровень маскирования может быть разным: иногда скрыто немного, иногда почти всё.

На этапе генерации можно начать почти с пустого шаблона:

[MASK] [MASK] [MASK] [MASK] [MASK]

Модель делает предположения, какие токены должны быть на этих местах. Самые уверенные предсказания фиксируются, остальные остаются замаскированными. Потом процесс повторяется.

Итоговая последовательность постепенно «кристаллизуется»:

[MASK] [MASK] [MASK] [MASK]
Диффузионная [MASK] [MASK] текст
Диффузионная модель генерирует текст

Это не точная внутренняя схема NVIDIA, а простая интуиция. Главное отличие от обычной LLM: модель может работать сразу с блоком позиций и уточнять результат, а не идти строго слева направо.

Что представила NVIDIA

В серии Nemotron-Labs Diffusion NVIDIA предлагает не просто одну DLM-модель, а более гибридный подход. В материалах компании фигурирует семейство моделей на 3B, 8B и 14B параметров, включая instruction-tuned варианты и отдельную vision-language model.

Самая интересная часть — не размер, а архитектура.

NVIDIA называет подход tri-mode language model. Одна модель может работать в трёх режимах:

1. Autoregressive mode — обычная генерация слева направо.
   

2. Diffusion mode — генерация и уточнение блоков токенов.
   

3. Self-speculation mode — быстрый черновой прогноз с последующей проверкой.
   

И это важный момент. NVIDIA не говорит: «Авторегрессия умерла, теперь всё будет диффузией». Скорее наоборот: старый и новый подходи пытаются совместить в одном чекпоинте.

Режим 1: обычная генерация

Autoregressive mode нужен для совместимости с привычным миром LLM.

Prompt: NVIDIA introduced a new model
Output: that combines autoregressive and diffusion generation...

Этот режим понятен, стабилен и хорошо подходит для обычных сценариев: чат, completion, tool calling, API-интеграции.

Если у вас уже есть пайплайн под обычную LLM, такой режим позволяет использовать модель без полной перестройки логики.

Режим 2: diffusion generation

Diffusion mode интересен тем, что модель может работать не только с концом текста, но и с пропусками, фрагментами, блоками.

Например:

Input:
NVIDIA представила [MASK] модель, которая [MASK] текст не по одному токену.

Output:
NVIDIA представила диффузионную модель, которая генерирует текст не по одному токену.

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

Для кода это ещё важнее.

def process_items(items):
    # нужно вставить реализацию здесь
    return result

Такой формат — fill-in-the-middle — для авторегрессионных моделей всегда был немного не родным. Они могут это делать, но архитектурно всё равно заточены под продолжение текста. Диффузионный подход лучше совпадает с задачей: есть левый контекст, правый контекст и место, которое нужно восстановить.

Режим 3: self-speculation

Self-speculation — это уже история про скорость.

В классическом speculative decoding обычно есть две модели:

• маленькая draft-модель быстро предлагает несколько токенов;

• большая модель проверяет, какие из них можно принять.

NVIDIA пытается сделать похожее внутри одной модели. Diffusion-часть быстро набрасывает несколько токенов, а autoregressive-часть проверяет и принимает подходящие.

Очень грубо:

Draft:  модель быстро предлагает 8 токенов
Check:  основная часть принимает 5, отклоняет 3

Зачем это нужно? Чтобы ускорить инференс без отдельной draft-модели и лишней инфраструктуры.

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

Почему это может быть быстрее

Авторегрессионная генерация делает много последовательных шагов. Diffusion-подход может работать с несколькими позициями сразу.

Это не значит, что он всегда быстрее. Один diffusion-шаг может быть тяжелее, а количество шагов уточнения тоже имеет значение. Для короткого ответа обычная autoregressive-модель может оказаться практичнее.

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

NVIDIA утверждает, что Nemotron-Labs-Diffusion-8B показывает заметный прирост throughput в отдельных бенчмарках, особенно при работе через SGLang на современном GPU-железе. Смысл здесь не в красивой цифре самой по себе, а в направлении: модель пытаются ускорить не только серверными трюками, но и самой архитектурой генерации.

Что DLM умеет лучше обычной LLM

Самое очевидное — инфиллинг.

Допустим, у вас есть два фрагмента текста, а середину нужно заполнить:

В начале статьи мы объяснили проблему.

[MASK MASK MASK]

В финале мы показали, почему новый подход может быть полезен.

Диффузионная модель естественно подходит для такой задачи: она видит оба края и восстанавливает середину.

Вторая сильная зона — редактирование. Не «допиши дальше», а «переделай вот этот кусок, не трогая остальное».

Для документов, кода, технических статей, IDE-ассистентов и редакторов это важнее, чем кажется. Большая часть реальной работы с текстом — это не написание с нуля, а правка существующего материала.

Третья зона — агентные сценарии. Агент не всегда пишет длинную простыню. Он постоянно делает маленькие шаги:

спланировал → вызвал инструмент → получил результат → исправил код → запустил тест → продолжил

Если модель быстрее генерирует короткие блоки и дешевле обслуживается, это прямо влияет на стоимость таких workflows.

Что внутри модели

Если совсем коротко, внутри остаётся знакомый трансформерный мир. NVIDIA не выбрасывает Transformer и не строит всё с нуля.

Важные элементы:

• decoder-only transformer;

• RoPE для позиционного кодирования;

• обучение на разных уровнях маскирования;

• loss считается по замаскированным позициям;

• diffusion-декодирование уточняет токены итерациями;

• autoregressive и diffusion-режимы обучаются совместно.
  

То есть это не «магия вместо LLM». Это скорее попытка заставить знакомую архитектуру работать в более гибком режиме.

Ограничения и вопросы

Здесь важно не перегнуть.

Диффузионные языковые модели пока не выглядят как гарантированная замена GPT-подобным системам. У подхода есть вопросы.

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

Во-вторых, сложность настройки. У обычной LLM есть привычные параметры вроде temperature и top_p. В diffusion-подходе появляются свои ручки: количество шагов, расписание маскирования, стратегия выбора уверенных токенов. Это менее привычно для разработчиков.

В-третьих, инфраструктура. Большая часть inference-стека уже заточена под autoregressive decoding. Чтобы DLM раскрылись, нужны оптимизации в серверах, библиотеках и runtime.

И наконец, бенчмарки не всегда отражают жизнь. Throughput в тесте — это одно. Поведение модели в IDE, продакшен-агенте или документном редакторе — другое.

Почему это всё равно важно

У LLM долго было несколько понятных направлений роста:

больше параметров
больше данных
длиннее контекст
лучше RLHF / instruction tuning
быстрее инференс

Nemotron-Labs Diffusion добавляет ещё одно направление: другой способ генерации.

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

Если diffusion language models смогут дать ускорение и более естественную работу с фрагментами текста, они могут занять свою нишу рядом с классическими LLM.

Не вместо них. Рядом.

Где это может пригодиться первым

Самые очевидные сценарии:

• IDE-ассистенты и автодополнение кода;

• fill-in-the-middle для функций, классов, тестов;

• редактирование больших документов;

• переписывание фрагментов без разрушения всего текста;

• AI-агенты с большим числом коротких генераций;

• high-throughput inference, где важна стоимость токена;

• инструменты для структурированного редактирования.
  

Для обычного чат-бота разница может быть не такой заметной. А вот для среды разработки или редактора документов — вполне.

Итог

Nemotron-Labs Diffusion интересна не тем, что «диффузия пришла в текст». Такие идеи обсуждали и раньше. Интересно другое: NVIDIA пытается превратить это в практичную архитектуру, где одна модель умеет работать сразу в трёх режимах:

autoregressive + diffusion + self-speculation

Это не похоже на смерть обычных LLM. Скорее это попытка выбраться из ограничения «только следующий токен» и дать модели больше способов создавать текст.

Авторегрессия остаётся сильной базой. Diffusion добавляет возможность итеративного уточнения и более естественной работы с пропусками. Self-speculation пытается ускорить вывод без отдельной draft-модели.

Если подход хорошо покажет себя в реальных задачах — кодинге, редактировании, агентных workflows и массовом инференсе — diffusion language models могут стать не экзотикой, а нормальным инструментом в LLM-инфраструктуре.

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

Почему я в восторге от этого направления

Я не первый год работаю с авторегрессионными моделями, и они уже начинают казаться локальным оптимумом. Диффузия предлагает выход из парадигмы «предскажи следующее», не выбрасывая при этом сам трансформер, который мы все знаем и любим.

Если NVIDIA (или кто-то ещё) масштабирует этот подход до 70B или 405B параметров с теми же трюками, которые сделали Llama 3.1 такой мощной (качественные данные, длинный контекст), мы можем получить модель, которая не просто сравняется с GPT-4, но и будет делать то, что сегодня попросту невозможно — например, редактировать 10-тысячесловный документ на месте или нелинейно генерировать связную историю.

Я слежу за репозиторием Nemotron-Labs и их будущими публикациями. Если появятся более крупные модели, обязательно сделаю новые разборы.

А вы что думаете? Попробовали бы диффузию для генерации текста или пока остаётесь с проверенными авторегрессионными моделями? Делитесь мыслями в комментариях!

Источник: dev.to (monuminu)