LoopLMs: за и против

23 февраля 2026 г.

Мне внезапно прислали свежую статью (Константин, привет!), которая объединяет два совсем разных направления, о которых я недавно писал в блоге и рассказывал в докладах:

с позитивной стороны, здесь развивается идея representation recycling, о которой я вам рассказывал в контексте thinking tokens;
с негативной, это почти буквально The Most Forbidden Technique; точнее, всё это направление просто-напросто отменяет идею легко интерпретируемых рассуждений в виде chain-of-thought (о которых я рассказывал здесь);
кроме того, это те самые process reward models, которые по идее не работают в рассуждающих моделях, но с неожиданной стороны.

Давайте разбираться!

Введение

Вся эта история начинается с естественной, но всё равно ещё не вполне исследованной идеи в контексте рассуждающих моделей — латентных рассуждений: а что если модель будет думать не словами, записывая свои промежуточные мысли в блокнотик, а молча, итеративно уточняя свои внутренние представления?

Так называемые Looped Language Models (LoopLMs) реализуют эту идею, рекурсивно прогоняя входы через один и тот же блок трансформера несколько раз перед тем, как породить очередной токен. Вот иллюстрация из работы Zhu et al. (Nov 2025), к которой мы ещё вернёмся:

Но попытки улучшить такие модели с помощью обучения с подкреплением до сих пор проваливались. И вот новая статья Williams & Tureci (2026) объясняет, почему проваливались, и предлагает красивое решение: RLTT (Reward Latent Thought Trajectories), метод, который награждает не только финальный результат размышлений, но и всю траекторию латентных мыслей модели.

Сегодня мы разберёмся, как устроены петлевые модели и почему стандартный RL для них не работает, как RLTT решает проблему credit assignment в латентном пространстве, обсудим связь с моим предыдущим постом о thinking tokens и в частности representation recycling из той работы. А потом поговорим о неприятной стороне всего этого, ведь латентные рассуждения лишают нас одного из немногих реально работающих инструментов AI safety: мониторинга chain of thought.

Что такое петлевые модели?

В посте о Hierarchical Reasoning Model (которая в итоге, видимо, не взлетела) я уже писал о том, что стандартные трансформеры — это по сути схемы фиксированной глубины. Каким бы широким ни был трансформер, сколько бы миллиардов параметров в нём ни было, число последовательных шагов обработки у него ограничено числом слоёв. А это накладывает фундаментальные ограничения на класс задач, которые модель может решать.

Рассуждающие модели обходят это ограничение, порождая длинные цепочки рассуждений (chain-of-thought) — но это в каком-то смысле костыль. Модель эмулирует итеративные вычисления через текст, тратя кучу токенов и вычислительных ресурсов на порождение промежуточного текста, который, строго говоря, для самих рассуждений не нужен.

Петлевые языковые модели (looped language models, LoopLMs) предлагают принципиально другой подход. Идея простая: давайте вместо одного прохода через десятки уникальных блоков трансформера, давайте прогоним вход через один и тот же блок несколько раз. Каждый проход уточняет внутреннее представление, но ни один промежуточный результат не декодируется в текст. Модель думает молча, в латентном пространстве, и порождает токен только после завершения всех итераций.

Это прямой аналог итеративного уточнения в численных методах: модель как бы “сходится” к правильному ответу, каждую итерацию уточняя своё внутреннее представление о задаче. Кстати, теоретическая база для этого тоже есть: Saunshi et al. (2025) показали, что петлевые трансформеры строго мощнее обычных с точки зрения вычислительной выразительности.

На практике эту идею реализует Ouro — на данный момент, насколько я знаю, единственная открытая петлевая языковая модель, которая реально достигает хороших результатов (Zhu et al., Nov 2025):

Ouro рекурсивно применяет блоки трансформера с общими весами перед порождением каждого токена и показывает качество рассуждений, сравнимое с chain-of-thought подходами, но без промежуточных токенов и всего за 2.6B параметров.

RLTT: какую проблему и как он решает

Как устроена архитектура LoopLM

Давайте чуть формализуем. Пусть $x$ — промпт, $y = [y_1, \ldots, y_L]$ — порождённая моделью последовательность из $L$ токенов. Для каждого токена $y_j$ LoopLM делает $T_{\max}$ итераций “внутреннего размышления”: на каждой итерации $t$ скрытое состояние $h_j^{(t)}$ уточняется, а через языковую голову $g$ можно получить “промежуточное” распределение на следующий токен:

$P_\theta^{(t)}(y_j \mid x, y_{<j}) = \text{Softmax}(g(h_j^{(t)})).$

Но для реального порождения используется только финальное распределение $P_\theta^{(T_{\max})}$ — все промежуточные распределения $P_\theta^{(1)}, \ldots, P_\theta^{(T_{\max}-1)}$ остаются “ненаблюдаемыми вычислениями”, латентными мыслями модели.

Обратите внимание на важный момент: промежуточные распределения — это не просто технический артефакт, а полноценные “черновики” предсказания следующего токена. На ранних итерациях они шумные и неуверенные, но с каждым проходом через блок трансформера становятся всё точнее. Это как бы “поток мысли” модели, который постепенно кристаллизуется в конкретное предсказание.

Почему стандартный RL не работает для LoopLMs

А теперь — ключевой вопрос, который ставит эта работа: почему стандартные методы обучения с подкреплением, вроде GRPO, не помогают петлевым моделям? Ведь для обычных рассуждающих моделей (DeepSeek R1 и подобных) GRPO и его аналоги работают прекрасно!

Проблема фундаментальная, и, честно говоря, довольно очевидная задним числом: стандартный GRPO видит только финальное латентное состояние. В стандартном REINFORCE-стиле градиент по параметрам выглядит так:

$\nabla_\theta J_{\text{standard}}(\theta) \propto \sum_{i=1}^{g} \sum_{j=1}^{|y_i|} \nabla_\theta \log P_\theta^{(T_{\max})}(y_{i,j} \mid x, y_{i,<j}) \cdot \hat{A}_i,$

где $\hat{A}_i$ — нормализованное преимущество (advantage) для $i$ -го роллаута. Обратите внимание: в этой формуле фигурирует только финальное распределение $P\theta^{(T_{\max})}$ . Все промежуточные итерации “размышления” получают градиентный сигнал только через обратное распространение от финального состояния.

Это создаёт классическую проблему распределения вознаграждения (credit assignment): вознаграждение должно как-то “пробраться” обратно через все $T_{\max}$ итераций латентного рассуждения. С точки зрения RL, каждый токен порождается как будто за один шаг, хотя на самом деле за ним стоит длинная цепочка внутренних уточнений.

В целом это в точности соответствует тому, как, например, AlphaZero или MuZero обучаются игре в шахматы; там тоже никакие промежуточные шаги не вознаграждаются, а с MuZero есть и ещё одна аналогия, потому что там тоже многошаговые размышления происходят в латентном пространстве. Но здесь “игра” куда более сложная, и на таком масштабе чистый RL уже не работает.

Авторы Ouro прямо указывали в своей работе, что RL не привёл к значимым улучшениям. И единственная существовавшая до RLTT попытка решить проблему — LSRL для модели Huginn (Ren, 2025) — требовала декодирования промежуточных латентных состояний в текст и оценки этого текста внешним верификатором (другой LLM). Это, мягко говоря, не очень элегантно и создаёт значительные накладные расходы.

RLTT: награждаем всю траекторию мысли

Решение, которое предлагают авторы, концептуально очень простое. Вместо того чтобы формировать градиент только через финальное распределение, RLTT распределяет вознаграждение по всей траектории латентного рассуждения:

$\nabla_\theta J_{\text{RLTT}}(\theta) \propto \sum_{i=1}^{g} \sum_{j=1}^{|y_i|} \sum_{t=1}^{T_{\max}} \omega_t \nabla_\theta \log P_\theta^{(t)}(y_{i,j} \mid x, y_{i,<j}) \cdot \hat{A}_i,$

где $\omega_t \geq 0$ — веса для каждой итерации, $\sum_t \omega_t = 1$ . Вот и вся идея: мы просто добавляем взвешенную сумму по петлям в градиент. Это гарантирует, что каждое промежуточное “латентное рассуждение” напрямую связано с вознаграждением.

К этому добавляется стандартная KL-регуляризация относительно замороженной копии модели (reference policy), чтобы модель не забыла свои общие языковые способности:

$J_{\text{RLTT}}(\theta) = J_{\text{RLTT\_PG}}(\theta) + \beta D_{\text{KL}}(\pi_\theta | \pi_{\text{ref}}).$

Важно, что KL-дивергенция считается только по финальному распределению $P_\theta^{(T_{\max})}$ , а не по промежуточным; это логично, ведь именно финальное распределение определяет реальное поведение модели.

Стратегии взвешивания петель

Остаётся выбрать веса $\omega_t$ . Авторы предлагают три варианта:

Exit-probability. Ouro, помимо прочего, обучает специальную “голову выхода”, которая определяет, когда пора прекратить итерации. Вес каждой итерации пропорционален вероятности того, что модель остановилась бы именно на ней. Это самый “информированный” вариант: если модель уверена, что ранние итерации ещё не сошлись, она даёт им меньший вес.

Progressive. Позднейшие итерации получают больший вес: $\omega_t \propto t^\alpha$ . Логика простая — чем позже, тем ближе к “правильному” распределению.

Uniform. Все итерации весят одинаково: $\omega_t = 1/T_{\max}$ . Это поощряет модель формировать правильное распределение как можно раньше.

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

Практические детали: что стоит RLTT?

С вычислительной точки зрения RLTT почти бесплатен: промежуточные логиты уже вычисляются при прямом проходе через LoopLM, а взвешенная сумма по петлям — линейная операция. Однако есть нюанс: RLTT требует хранить логарифмы вероятностей для каждой итерации каждого токена, что линейно увеличивает потребление памяти в $T_{\max}$ раз. На практике авторам пришлось вдвое уменьшить максимальное количество токенов на GPU (с 16384 до 8192) и компенсировать это дополнительными мини-шагами. Но если на память не смотреть, то в целом RLTT даже быстрее GRPO.

Результаты

Динамика обучения

Начнём с того, что происходит во время обучения.

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

Во-вторых, и это очень интересное наблюдение, длина ответов начинает падать: RLTT-обученная модель порождает значительно более короткие ответы, чем GRPO. При этом в функции вознаграждения нет никакого штрафа за длину — reward чисто бинарный, 0/1 за правильность ответа.

Сокращение длины — это эмерджентный эффект, и очень любопытный. Получается, что модель учится сходиться к правильному ответу быстрее во внутреннем латентном пространстве, чем при использовании “внешних” токенов.

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

В-третьих, энтропия токенов падает у RLTT заметно быстрее, чем у GRPO. Закономерный вопрос: не значит ли это, что энтропия просто коллапсирует, и модель теряет разнообразие? Авторы отвечают на него анализом Pass@k (об этом ниже) и показывают, что нет — модель становится более уверенной, а не более однообразной.

Бенчмарки

Я обычно не люблю циферки анализировать, но тут для полноты картины покажу таблицу, она довольно впечатляющая:

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

Самыми интересными, на мой взгляд, здесь являются результаты на AIME24 и BeyondAIME. Это относительно сложные олимпиадные задачи, где GRPO-модель регулярно не успевает дойти до ответа, исчерпав бюджет токенов. RLTT решает ту же задачу короче и, как следствие, чаще укладывается в лимит. Тут мы наглядно видим, как улучшение внутреннего рассуждения транслируется в практический результат.

Ещё один важный результат: RLTT переносится на не-математические задачи, хотя обучалась модель исключительно на математике. Например, на GPQA улучшение почти двукратное (с 19.7% до 38.4%), а GPQA требует многошаговых рассуждений; опять получается, что латентное рассуждение становится более эффективным.

Робастность

Авторы проводят обширный анализ робастности и устойчивости.

Бюджет декодирования. RLTT стабильно лучше GRPO при любом бюджете, от 1024 до 4096 токенов (что вдвое больше тренировочного бюджета). И опять чем меньше токенов, тем больше разница: при 1024 токенах RLTT даёт 78.4% на MATH-500, а GRPO — только 42.4%.

Число итераций (loops). При оценке с разным числом итераций (от 1 до 4) RLTT выигрывает при каждом варианте. На GSM8K даже с одной итерацией RLTT обгоняет GRPO на 26.2 процентных пунктов. Это означает, что RLTT улучшает каждую итерацию, а не только последнюю.

Стратегии выбора весов. Как я уже упоминал, разница между uniform, progressive и exit-probability весами невелика. Все три варианта дают примерно одинаковые результаты на большинстве бенчмарков. Это тоже приятная мелочь

Энтропия: контролируемая уверенность или коллапс?

Энтропия у RLTT падает быстрее, чем у GRPO — не схлопывается ли модель в вырожденное состояние? Авторы проверяют это через анализ Pass@k: порождают $k$ ответов с температурой $T=0.6$ и смотрят, удаётся ли хотя бы одному из них решить задачу.

RLTT демонстрирует более крутой рост Pass@k с увеличением $k$ . Это значит, что у RLTT-модели больше разнообразных правильных путей решения, а не один доминирующий. Особенно показательно это на AIME24 и BeyondAIME, где GRPO практически не улучшается с ростом $k$ , а RLTT продолжает набирать очки. Так что низкая энтропия здесь — это именно контролируемая уверенность, а не коллапс.

Почему это работает: теоретическое обоснование

Авторы дают и теоретическое объяснение, почему RLTT должен приводить к более коротким ответам. Идея следующая: RLTT увеличивает “стоимость неуверенности” на каждом токене. В GRPO неуверенность считается только по финальному распределению, а в RLTT — усредняется по всем итерациям (включая ранние, более шумные). Поскольку ранние итерации менее уверены, чем финальная, средняя неуверенность по траектории всегда не меньше финальной.

Авторы формализуют это в теореме: при условии убывающей предельной полезности дополнительных токенов (что вполне естественно: каждый следующий токен даёт всё меньше нового), более высокая “стоимость неуверенности” приводит к меньшей оптимальной длине декодирования. Грубо говоря, при RLTT для модели “дороже” быть неуверенной на каждом токене, и поэтому она учится решать задачи быстрее.

Это, конечно, упрощённая модель, но она хорошо согласуется с эмпирическими наблюдениями и даёт подходящую интуицию.

Помимо этого, авторы измерили Gradient Signal-to-Noise Ratio (GSNR) — отношение сигнала к шуму в градиентах. На самых сложных бенчмарках (AIME24, BeyondAIME), где вознаграждение особенно разрежено, RLTT показывает статистически значимо более высокий GSNR. То есть градиенты при RLTT содержат больше полезной информации на каждом шаге обучения.

Примеры

Авторы приводят несколько примеров, которые наглядно иллюстрируют разницу между RLTT и GRPO. Типичная картина выглядит так: RLTT-модель быстро формулирует правильный подход, аккуратно его реализует и останавливается. GRPO-модель приходит к тому же подходу, но потом начинает перепроверять формулу несколькими разными способами, проверять частные случаи, сомневаться в себе, заново выводить то же самое — и в итоге тратит в два-три раза больше токенов.

Вот пример рассуждения RLTT:

А вот GPRO на той же задаче; в одну картинку это уже никак не влезает:

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

Связь с thinking tokens и representation recycling

Внимательный читатель моего блога мог заметить, что петлевые модели подозрительно напоминают один из механизмов, который я обсуждал в посте о thinking tokens. В работе Qian et al. (2025) был предложен Representation Recycling (RR): берём внутреннее представление на каком-то слое трансформера и прогоняем его через тот же блок ещё раз. Результат второго прохода отличается от первого, потому что self-attention видит другой контекст — уже “обработанные” представления вместо сырых.

Но это по сути ведь и есть та самая петля! Representation recycling — это LoopLM с $T_{\max} = 2$ , применённая к одному конкретному блоку трансформера. Механизм тот же самый: те же веса, тот же вход (с поправкой на обновлённый контекст self-attention), итеративное уточнение представления. Просто в LoopLM это архитектурное решение, заложенное в модель с самого начала, а в RR это post-hoc трюк, применяемый к стандартному трансформеру.

Различия тоже очевидны: в LoopLM каждый токен проходит через все $T_{\max}$ итераций, это часть архитектуры, а RR запускается избирательно, только в моменты информационных пиков — тех самых thinking tokens (“Hmm”, “Wait”, “Therefore”). В каком-то смысле RR реализует идею адаптивной глубины вычислений: простые токены обрабатываются стандартно, а на “сложных” — модель думает дольше.

Во-вторых, обучение идёт по-разному. LoopLM обучается с учётом того, что будет зацикливание: общие веса блоков, механизм ранней остановки, вся архитектура заточена под итеративное уточнение. А RR работает без специального дообучения — берётся стандартная рассуждающая модель и к ней применяется дополнительный проход. Это и плюс (не нужно специально дообучать), и минус (модель не оптимизирована для повторной обработки, и третий-четвёртый проходы уже не помогают, а скорее вредят).

Я подозреваю, что логичный следующий шаг — это что-то вроде адаптивного RLTT, где число итераций варьируется от токена к токену в зависимости от сложности, совмещая избирательность RR с мощью RLTT. Собственно, авторы RLTT указывают на это как на главное направление будущей работы; сюда же относится и интеграция механизмов адаптивной остановки (adaptive halting), как уже сделано в Ouro.

Слон в комнате: латентные рассуждения и AI safety

До сих пор мы обсуждали RLTT как чисто техническое достижение. Но у всей парадигмы латентных рассуждений и LoopLMs есть серьёзная импликация для AI safety, о которой стоит поговорить отдельно.

The Most Forbidden Technique и мониторинг chain of thought

Одна из немногих действительно работающих техник AI safety на сегодняшний день — это мониторинг chain of thought. Рассуждающие модели “думают вслух”, записывая свои рассуждения текстом, и этот текст можно читать. OpenAI в Baker et al. (2025) показали, что модели, занимающиеся reward hacking (подделывающие тесты вместо решения задач), буквально пишут в своих рассуждениях что-то вроде “Let’s hack” — и простой агент-монитор на основе GPT-4o ловит это с высокой точностью. CoT-мониторинг оказался значительно эффективнее мониторинга только действий модели.

Zvi Mowshowitz сформулировал The Most Forbidden Technique: если у вас есть инструмент для наблюдения за “мышлением” модели, никогда не используйте его как сигнал обучения. Потому что если вы начнёте наказывать модель за “плохие мысли” в chain of thought, она быстро научится скрывать свои намерения, продолжая при этом вести себя нехорошо. OpenAI подтвердили это экспериментально: при добавлении CoT-монитора в функцию вознаграждения модель сначала стала вести себя лучше, но затем перешла к obfuscated reward hacking — reward hacking с невинно выглядящими рассуждениями. Монитор переставал что-либо замечать, а модель продолжала жульничать.

Отсюда рекомендация, с которой согласны буквально все ведущие специалисты по AI safety: не применяйте сильное оптимизационное давление к chain of thought, оставьте его свободным для мониторинга! Посмотрите, сколько авторов у статьи с этим призывом, а главное, что это за авторы:

Я об этом всём недавно и рассказывал в докладах (на семинаре лаборатории Маркова и на OpenTalks.AI), и писал в своём обзоре AI Safety в 2025 году (первая часть, вторая часть).

LoopLMs: мышление без слов

А теперь посмотрите на LoopLMs. Что делает Ouro? Она думает молча, без промежуточных токенов. Нет никакого “Let me think about this” или “Wait, let me reconsider”. Вся цепочка рассуждений — это последовательность скрытых состояний $h_j^{(1)} \to h_j^{(2)} \to \ldots \to h_j^{(T_{\max})}$ , которые существуют только в виде векторов в латентном пространстве.

С точки зрения AI safety это, прямо скажем, тревожно. CoT-мониторинг полностью теряет смысл, если рассуждения модели не выражены текстом. Нельзя попросить GPT-4o прочитать вектор из 2048 чисел с плавающей запятой и определить, “думает” ли модель о чём-то нехорошем.

Более того, RLTT усугубляет эту проблему. Весь смысл метода в том, чтобы RL-сигнал проникал в промежуточные латентные состояния — то есть мы специально оптимизируем именно то внутреннее “мышление”, которое в случае обычных рассуждающих моделей лучше не трогать. Мы строим модели, которые рассуждают всё лучше и при этом, скорее всего, всё более непрозрачно.

Tradeoff между эффективностью и прозрачностью

Здесь возникает фундаментальная дилемма. Латентное рассуждение эффективнее текстового: оно не тратит токены на промежуточный текст, не страдает от ограничений естественного языка, работает в пространстве более высокой размерности. Результаты Ouro и RLTT это наглядно подтверждают. А RLTT ещё и показывает, что эти внутренние рассуждения можно эффективно улучшать с помощью RL — чего не удавалось сделать ранее.

Но текстовое рассуждение прозрачнее. Пусть chain of thought не всегда в точности отражает внутренние процессы модели; собственно, работа о thinking tokens, которую я обсуждал ранее, хорошо показывает, что реальная “работа” происходит в представлениях, а не в токенах. Но это хотя бы что-то, что можно читать, анализировать, мониторить. С латентным рассуждением у нас нет даже этого.

LSRL — альтернативный RLTT подход — пытался решить проблему в лоб: он декодирует промежуточные латентные состояния в текст и оценивает их внешним верификатором. Это, в принципе, возвращает нам хотя бы какую-то прозрачность. Но авторы RLTT справедливо замечают, что декодирование промежуточных состояний в текст — это дорого и не факт, что информативно, ведь промежуточные состояния LoopLM не обучались быть интерпретируемыми после декодирования (в отличие от обычных рассуждений, которые модель на следующей итерации читает именно в виде обычного текста).

Возможно, правильный путь — в развитии механистической интерпретируемости, которая работает непосредственно с латентными представлениями: probing, sparse autoencoders и подобные методы. Но пока эти инструменты далеки от уровня, при котором можно было бы мониторить “латентные мысли” модели с той же надёжностью, с какой GPT-4o читает chain of thought.

В конечном счёте, развитие латентного рассуждения — это ещё один пример того, как capability research и safety research движутся в противоположных направлениях. Модели становятся умнее, эффективнее, компактнее — и при этом одновременно менее прозрачными. RLTT — элегантная и красивая работа, которая решает реальную техническую проблему. Но чем лучше мы научимся обучать модели, которые думают молча, тем острее станет вопрос: а как нам за ними следить?

А вы за LoopLMs или против? 🙂

Сергей Николенко

P.S. Прокомментировать и обсудить пост можно в канале «Sineкура»: присоединяйтесь!