Латентное мышление в LLM: рассуждать, не проговаривая
Chain-of-thought сделал модели умнее: модель пишет промежуточные шаги словами и сама их перечитывает. Работает, но дорого — каждый шаг рассуждения превращается в токены, которые нужно сгенерировать и удержать в KV-кэше. Я задался вопросом: что если держать промежуточные мысли как непрерывные скрытые состояния и вообще их не декодировать?
Чтобы разобраться предметно, а не по диагонали, я собрал latentGPT — крошечный трансформер латентных рассуждений на ~0,5–1M параметров, который тренируется за минуты на ноутбуке. Масштаб тут не цель, цель — воспроизвести центральное утверждение литературы: точность растёт, если тратить больше вычислений на инференсе, итерируя рекуррентный блок в латентном пространстве. И сделать это с той строгостью, которую литература 2026 года уже требует.
#Две идеи в основе
Модель объединяет два подхода. Из COCONUT — идею непрерывной мысли: последнее скрытое состояние подаётся обратно как следующий входной эмбеддинг и никогда не становится словом. Из Recurrent-Depth / Huginn — факторизацию prelude → рекуррентное ядро → coda, где ядро зацикливается произвольное число раз на инференсе, а обучается со случайным числом итераций и усечённым BPTT, чтобы обобщаться за пределы обучающей глубины.
Prelude извлекает контекст, одно рекуррентное ядро итеративно уточняет латентное состояние s (на каждом шаге контекст впрыскивается через адаптер), coda декодирует ответ. На инференсе я кручу ядро от 1 до 16 раз — это единственный рычаг «думать дольше».
#Почему наивная версия ломается
Простой зацикленный reasoner выходит на пик и коллапсирует: добавляешь шаги — точность сперва растёт, потом падает. Виноват якобиан рекуррентного оператора: он разносит состояние. Фикс — STARS, штраф на его спектральный радиус, который удерживает ядро сжимающим (ρ(J) < 1). Технически это двойной backward через attention (оценка верхнего сингулярного числа через power iteration + JVP/VJP), а значит — только math-ядро SDPA, flash и efficient double-grad не поддерживают. Обучение дорожает на 1–2%, зато глубина масштабируется предсказуемо, а не как повезёт.
Ещё два решения держат обучение вместе: случайная глубина (1–8 шагов на батч), чтобы модель училась уточнять постепенно, и усечённый BPTT, чтобы память не зависела от числа шагов на инференсе.
#Как я всё это проверяю
Кривым «вверх» на глаз я не доверяю. Бенчмарк мультизадачный, с ручкой глубины: pointer-chasing (следуй за перестановкой k раз), арифметические цепочки, ListOps (вложенные MAX/MIN), parity. На каждую пару задача×глубина — exact-match с 95% доверительным интервалом Уилсона. Сравнение идёт сразу по двум осям: против Qwen3.5-0.8B (~800× больше) по вычислениям на инференсе — латентные шаги против токенов CoT при сопоставимом бюджете; и против параметро-эквивалентного бейзлайна без рекуррентности, чтобы выигрыш нельзя было списать на число параметров.
Плюс диагностика: спектральный радиус (должен держаться < 1), затухание нормы шага, косинус между соседними шагами (~0,5–0,65 — модель движется по спирали, а не мгновенно коллапсирует в неподвижную точку), logit-lens как проба на верность рассуждения.
#Результат и его границы
При стабильном ядре точность действительно растёт с числом латентных шагов, особенно на более глубоких задачах, а латентная модель обходит параметро-эквивалентный бейзлайн — выигрыш от рекуррентности, а не от параметров.
Ограничения записаны прямо в репозитории, не спрятаны в примечаниях. Есть trade-off между поиском и точным исполнением: латентное рассуждение сильно на задачах-поиске (pointer-chasing, ListOps), но проигрывает токенам CoT в арифметике. Масштабирование надёжное, но не монотонное — переусиленное STARS-ом ядро сходится слишком рано. И латентные «мысли» не гарантированно верны: их легко принять за рассуждение там, где модель на самом деле срезает угол.
В этом и притягательность темы: латентное рассуждение — не универсальная победа, а конкретный компромисс, особенно интересный под жёстким бюджетом и на маленьких моделях, где узкое место память, а не FLOPs. Это то, что я хочу исследовать строго.