Малые модели думают? Шутка. А Recursive Mamba пытается их научить

В марте 2026 года reasoning для 7B-13B моделей — это как заставить хомяка решать интегралы. Все крутятся вокруг хитростей с данными и архитектурными ухищрениями. Recursive Mamba — очередной эксперимент, который не обещает революции, но показывает, куда можно тыкать палкой.

Это не production-ready решение. Код сырой, статьи на ArXiv нет, авторы выложили репу на GitHub с пометкой "research preview". Но идея забавная.

Суть: рекурсивный тупик или прорыв?

Обычная Mamba (SSM) обрабатывает последовательность один раз, генерируя скрытое состояние для каждого токена. Recursive Mamba добавляет цикл: скрытое состояние последнего токена N-го слоя подаётся обратно на вход того же слоя. Получается микро-итерация внутри одного слоя.

Звучит безумно. Зачем? Авторы утверждают, что это имитирует "внутренний монолог" модели. Вместо одного прохода — несколько "обдумываний" каждого фрагмента контекста. Особенно для сложных логических цепочек.

💡

Динамическое масштабирование глубины — ключевая фишка. Модель сама решает, сколько рекурсивных итераций нужно для каждого блока. Сложный фрагмент текста? 3-4 цикла. Простой? 1-2. Экономит вычисления.

1 Как это выглядит в коде (PyTorch, март 2026)

Имплементация использует последнюю версию Mamba2 (State-Space Model v2), которая стабилизировала training на длинных контекстах. Рекурсивный блок — это обёртка вокруг стандартного SSM слоя.

import torch
import torch.nn as nn
from mamba_ssm import Mamba2Block  # Используем актуальную на 2026 год версию

class RecursiveMambaBlock(nn.Module):
    def __init__(self, d_model, n_recursions=3, dynamic_scaling=True):
        super().__init__()
        self.ssm = Mamba2Block(d_model)  # Базовый блок Mamba2
        self.n_recursions = n_recursions
        self.dynamic_scaling = dynamic_scaling
        # Гейт для динамического решения о продолжении рекурсии
        self.halt_gate = nn.Linear(d_model, 1) if dynamic_scaling else None
    
    def forward(self, x, cache=None):
        hidden_state = None
        for i in range(self.n_recursions):
            # Подаём hidden_state предыдущей итерации как дополнительный контекст
            x, hidden_state = self.ssm(x, hidden_state=hidden_state, cache=cache)
            
            if self.dynamic_scaling and self.training:
                halt_score = torch.sigmoid(self.halt_gate(x.mean(dim=1)))
                if halt_score > 0.7:  # Порог выхода из рекурсии
                    break
        return x

В теории это работает. На практике нужно аккуратно инициализировать веса, иначе модель зацикливается на первом же токене (проверено, бесит).

Сравнение: против кого воюет Recursive Mamba?

В 2026 году для reasoning в малых моделях есть несколько трендов:

Подход	Плюсы	Минусы	Где смотреть
Recursive Mamba	Динамическая глубина, экономия VRAM, линейная сложность от контекста	Сложная стабилизация, риск overthinking, сырая имплементация	Экспериментальные репы на GitHub
MoE + SSM гибриды	Высокий quality, хорошая масштабируемость	Пожирает память, сложный routing	Genesis-152M-Instruct
GRPO + длинный контекст	Стабильное обучение, SOTA на бенчмарках	Требует тонны данных, долгий tuning	ICLR 2026 про GRPO
Внешний reasoning budget	Контроль над вычислениями, предсказуемость	Жёсткие ограничения, падение качества на сложных задачах	Llama.cpp reasoning budget

Recursive Mamba не пытается быть универсальным решением. Это скорее попытка решить проблему "thinking depth" без увеличения параметров. Qwen2.5 7B использует хитрые prompting strategies, а Recursive Mamba хочет встроить reasoning в архитектуру.

Эффективность VRAM: главный козырь или иллюзия?

Здесь цифры. На конфигурации 7B параметров, контекст 8K:

Обычная Mamba2: ~14GB VRAM при inference с полным контекстом
Recursive Mamba (3 итерации, динамическое scaling): ~11GB VRAM
Трансформер с attention (аналогичный размер): ~18GB VRAM

Экономия в 3GB — не фантастика, но для RTX 4090/5090 (если верить утечкам на 2026) это разница между запуском и out-of-memory. Особенно если вы экспериментируете на старом железе.

Динамическое масштабирование — вот что реально экономит память. Модель не тупо выполняет 5 итераций для каждого блока, а останавливается, когда "поняла" фрагмент. В бенчмарках ARC-AGI это даёт прирост 15-20% по accuracy при том же потреблении VRAM.

Кому это вообще нужно?

Исследователи, которые устали от transformers. Если вы верите, что SSM — будущее, Recursive Mamba даёт новый вектор для экспериментов.
Инженеры с ограниченным GPU. Когда нужно выжать максимум из одной карты, а бесплатный Colab задыхается на 7B моделях.
Те, кто играет с локальными reasoning-моделями. Если вы тестировали MiniMax M2.5 и хотите что-то подобное, но с открытым кодом.

Не берите Recursive Mamba, если:

Вам нужна стабильная production-модель. Здесь ещё год багфиксов.
Вы не готовы копаться в исходниках PyTorch. Документация — это три комментария в коде.
Вы ждёте мгновенного SOTA. Это исследовательский прототип, а не готовая библиотека.

Что дальше? Прогноз на 2026-2027

Recursive Mamba умрёт. Или трансформируется. Скорее всего, её идеи вольются в гибридные архитектуры типа "SSM + внешняя memory". Динамическое масштабирование глубины — это круто, но нужно учить модель принимать решение о halt более интеллектуально.

Уже сейчас есть намёки, что Step-3.5-Flash-Int4 использует похожие техники для контроля reasoning steps. Будущее — за адаптивными моделями, которые тратят compute только на сложные части задачи.

Совет: если хотите поиграть с Recursive Mamba, форкните репу сейчас. Через полгода автор забросит проект, и найти рабочую версию будет невозможно. И да, делайте бэкапы весов. Рекурсивное обучение иногда приводит к катастрофическому забыванию — модель внезапно забывает английский и начинает выдавать рандомные unicode символы. Проверено.

Подписаться на канал

Recursive Mamba: когда одной итерации мало — как рекурсивные SSM ломают reasoning в малых моделях