AIKraft Agents
Главная/Блог/Гайд/Ускорение Mamba-2 с NVIDIA CUDA Tile:…
Гайд12 мин чтения · 19 октября 2026 г.

Ускорение Mamba-2 с NVIDIA CUDA Tile: Глубокое погружение

Разбираем, как инженеры Jane Street и NVIDIA оптимизировали модель Mamba-2 с помощью Python DSL cuTile, создав три высокопроизводительных ядра для прямого прохода.

Ускорение Mamba-2 с NVIDIA CUDA Tile: Глубокое погружение

В мире искусственного интеллекта гонка за эффективностью не знает границ. Архитектуры последовательного моделирования, такие как трансформеры с механизмом внимания, долгое время доминировали благодаря своей способности обрабатывать данные параллельно. Однако их вычислительная сложность растет квадратично с увеличением длины последовательности, что создает серьезные узкие места при работе с длинными контекстами. На смену им приходят модели пространства состояний (State-Space Models, SSM), такие как Mamba, которые обещают линейную сложность и постоянный объем памяти. Но как сделать их обучение и инференс по-настоящему быстрыми на современных GPU NVIDIA? Ответ кроется в низкоуровневой оптимизации, и именно об этом рассказывает новая статья от NVIDIA, подготовленная совместно с инженерами Jane Street.

В этой статье мы подробно разберем, как используется NVIDIA CUDA Tile (cuTile) — новый Python DSL и модель параллельного программирования, которая абстрагирует сложность планирования на уровне потоков и варпов, позволяя разработчикам писать высокопроизводительные ядра (kernels) на Python. Мы рассмотрим три ключевых ядра, созданных для прямого прохода (forward pass) модели Mamba-2: chunk_cumsum, fwd_pass_state и compute_out. Это не просто теория: это практическое руководство от ведущих экспертов индустрии, показывающее, как достичь пиковой производительности Tensor Cores.

01Что такое NVIDIA CUDA Tile (cuTile)?

До появления cuTile написание высокооптимизированных GPU-ядер требовало глубоких знаний C++/CUDA, ручного управления памятью и сложного планирования_warps_. CuTile меняет эту парадигму. Это язык спецификаций (DSL) на базе Python, который позволяет описывать операции на уровне «плиток» (tiles). Компилятор cuTile автоматически преобразует эти высокоуровневые описания в эффективный код, который целенаправленно использует передовые функции аппаратного обеспечения GPU, такие как Tensor Cores, TMA (Tensor Memory Accelerator) и другие оптимизации.

Для инженеров по машинному обучению это означает возможность писать код на знакомом Python, сохраняя при этом производительность, сравнимую с ручным CUDA C++. CuTile берет на себя рутину распределения задач между потоками, что позволяет сосредоточиться на математической сути алгоритма. В данном случае, инженеры Jane Street, известной своей глубокой технической экспертизой в количественных исследованиях, выбрали cuTile для реализации Mamba-2, чтобы достичь максимальной эффективности.

💡
Важно знать. Для работы с cuTile требуется специфическая среда. Убедитесь, что ваш окружение соответствует требованиям, описанным в руководстве cuTile Python Quickstart. Импортируйте пакет как cuda.tile и используйте псевдоним ct во всех реализациях ядер, как показано в примерах ниже.

02Вычислительный компромисс в последовательном моделировании

Чтобы понять ценность оптимизаций Mamba-2, нужно рассмотреть фундаментальный компромисс в архитектуре моделей. Традиционные архитектуры на основе механизма внимания (softmax attention) обучаются быстро благодаря матричным умножениям, которые идеально ускоряются Tensor Cores. Однако во время инференса (генерации) вычислительные требования и объем требуемой памяти растут линейно (или даже квадратично, в зависимости от реализации кэша ключей и значений) с увеличением длины последовательности.

С другой стороны, рекуррентные нейронные сети (RNN) требуют постоянного объема памяти и вычислительных ресурсов, независимо от длины последовательности, так как они обрабатывают данные шаг за шагом. Но их обучение часто медленное и не может быть эффективно распараллелено. Mamba-2 (и его предшественник Mamba-1) стремится объединить лучшее из обоих миров: фиксированный размер скрытого состояния, как у RNN, и возможность эффективного параллельного вычисления с использованием Tensor Cores, как у трансформеров.

03Архитектура Mamba-2: Математика и интуиция

Ядро рекуррентного обновления в Mamba-2 описывается следующим уравнением:

terminalpython
h_t = exp(A * dt_t) * h_{t-1} + dt_t * B_t * x_t
y_t = c_t^T * h_t + D * x_t

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

  • x_t, dt_t, B_t и c_t — входные данные для слоя Mamba-2 на токене t. Они получаются путем проецирования входных данных, аналогично тому, как в механизме внимания вычисляются Query, Key и Value.
  • y_t — выход на токене t.
  • h_t — скрытое состояние фиксированного размера, передаваемое от токена к токену. Важно отметить, что h_t — это не вектор, как в классических RNN, а матрица размером S x H, что дает большую репрезентативную мощность.
  • A и D — обучаемые параметры модели.

Интуитивно:

  • dt_t (скаляр на голову) определяет, насколько сильно должно обновляться состояние. Все значения dt отрицательны. Поскольку предыдущее состояние умножается на exp(A * dt_t), состояние остается неизменным, если dt_t = 0.
  • x_t (вектор размера H) играет роль, аналогичную Values в attention.
  • B_t (вектор размера S) аналогичен Keys.
  • c_t (вектор размера S) определяет, как состояние смешивается для получения выходов, аналогично Queries.

Для упрощения записи введем a_t = A * dt_t и b_t = dt_t * B_t. Тогда уравнение принимает вид:

terminalpython
h_t = exp(a_t) * h_{t-1} + b_t * x_t^T
y_t = c_t^T * h_t + D * x_t

Эта рекуррентная формулировка идеальна для последовательного инференса. Однако для обучения и этапа префилла (prefill) нужен более быстрый способ, чем простой цикл for. Прямой параллельный сканирующий алгоритм (parallel scan) требует материализации огромного тензора скрытых состояний, что делает процесс ограниченным пропускной способностью памяти (memory-bound) и не позволяет эффективно использовать Tensor Cores.

Обновление состояния после обработки чанка событий
Обновление состояния после обработки чанка событий

04Формула прыжка (Jump Formula) и использование Tensor Cores

Альтернативный подход, используемый в Mamba-2, позволяет вычислять любое будущее скрытое состояние напрямую через матричное умножение, игнорируя член exp(a_t) для упрощения на первом этапе. Переход от h_t к h_{t+T} выглядит так:

terminalpython
h_{t+T} = h_t + b_{t+1}x_{t+1}^T + b_{t+2}x_{t+2}^T + ... + b_{t+T}x_{t+T}^T

Если собрать все b_{t+i} в матрицу B размера (T, S) и все x_{t+i} в матрицу X размера (T, H), то это выражение становится простым матричным умножением:

terminalpython
h_{t+T} = h_t + B * X^T

Эта «формула прыжка» позволяет эффективно вычислять скрытое состояние в контрольных точках (chunk checkpoints) последовательности. Следующий шаг — вычислить выходы y_1, y_2, y_3, y_4, имея только начальное состояние h_0. Если бы мы вычисляли h_1, h_2, ... последовательно, это было бы просто, но это противоречит цели использования формулы прыжка для ускорения.

Исключая пока член затухания exp(a_t), цель состоит в вычислении:

terminalpython
y_{t+i} = c_{t+i}^T * h_{t+i} + D * x_{t+i}

Подставляя разложение скрытого состояния, мы видим, что член связи по умолчанию (skip connection) D * x_{t+i} прост. Остальная часть выражения может быть переписана с использованием матричных произведений, дружественных к Tensor Cores. Здесь возникает важная деталь: при вычислении выхода y_{t+i} у нас есть произведение c_{t+i} на все b_j для j ≤ t + i. При вычислении полного матричного произведения необходимо обнулить значения, находящиеся в будущем (выше диагонали). В математике это делается с помощью причинной маски (causal mask).

05Учет экспоненциального затухания

Когда мы возвращаем член затухания exp(a_t), математика становится немного сложнее. Развертывание рекурсии выглядит так:

terminalpython
h_{t+T} = exp(a_{t+1} + ... + a_{t+T}) * h_t + 
         exp(a_{t+2} + ... + a_{t+T}) * b_{t+1} * x_{t+1} + 
         ... + b_{t+T} * x_{t+T}

Переход в логарифмическое пространство позволяет заменить последовательные умножения на кумулятивные суммы. Это остается матричным умножением, если строки матрицы B (или X) предварительно умножены на экспоненты. Отслеживая кумулятивную сумму a_t в тензоре G, мы получаем новое уравнение:

terminalpython
h_{t+T} = exp(G_last) * h_t + (exp(G_last - G) * B) * X^T

Подстановка нового прыжка скрытого состояния в вычисление выхода дает:

terminalpython
Y = exp(G) * C * h_{kT} + (exp(G - G^T) * (C * B^T) * M) * X + D * X

где M — традиционная причинная маска. Матрица exp(G - G^T) содержит в позиции (i, j) член exp(g_i - g_j). Поскольку все значения a_t отрицательны, g_i - g_j также отрицательно для i > j. Это гарантирует численную стабильность, так как экспоненты положительных чисел никогда не сохраняются.

Вычисление чанка в Mamba-2
Вычисление чанка в Mamba-2

06Три ключевых ядра (Kernels)

Вся эта математика трансформируется в три специализированных ядра cuTile:

  1. chunk_cumsum: Вычисляет кумулятивные суммы a_t внутри каждого чанка.
  2. fwd_pass_state: Вычисляет скрытое состояние в начале каждого чанка, используя формулу прыжка.
  3. compute_out: Вычисляет выходы для каждого чанка, используя начальное скрытое состояние, вычисленное на предыдущем шаге.

Ядро 1: chunk_cumsum

Кумулятивные суммы a_t (обозначенные как G) необходимы как для шага 2, так и для шага 3. Чтобы избежать повторных вычислений, это первое ядро вычисляет a_t один раз и сохраняет результат. Важно отметить, что это не глобальная кумулятивная сумма, а только внутри каждого чанка.

Входными данными являются скаляр затухания на голову a и временной шаг на токен dt. Эффективное затухание для токена t и головы h равно a[h] * dt[t, h]. Ядро аккумулирует это произведение вдоль размерности чанка. Все кумулятивные суммы находятся в логарифмическом пространстве, и от них всегда берется экспонента (или их линейная комбинация). Поскольку вычисление exp2 дешевле, чем exp, результат масштабируется на log2(e).

Это ядро вводит основные примитивы cuTile, используемые во всех трех ядрах: ct.bid, ct.load, ct.store и ct.cumsum.

terminalpython
@ct.kernel
def chunk_cumsum_kernel(
    a: torch.Tensor,        # [num_heads]
    dt: torch.Tensor,       # [batch_size, num_tokens, num_heads]
    output: torch.Tensor,   # [batch_size, num_tokens, num_heads]
    chunk_size: ct.Constant[int],
    BLOCK_H: ct.Constant[int],
) -> None:
    chunk_idx, head_tile_idx, batch = ct.bid(0), ct.bid(1), ct.bid(2)
    dt_tile = ct.load(dt, index=(batch, chunk_idx, head_tile_idx),
                          shape=(1, chunk_size, BLOCK_H),
                          padding_mode=ct.PaddingMode.ZERO).astype(ct.float32)
    a_tile = ct.load(a, index=(head_tile_idx,),
                        shape=(BLOCK_H,),
                        padding_mode=ct.PaddingMode.ZERO).astype(ct.float32)
    d_tile = ct.cumsum(a_tile * dt_tile, axis=1) * LOG2E
    ct.store(output, index=(batch, chunk_idx, head_tile_idx), tile=d_tile.astype(output.dtype))

Ядро запускается с сеткой (num_chunks, num_head_tiles, batch_size). Первая строка определяет позицию в сетке с помощью ct.bid. Произведение a_tile (размер [BLOCK_H]) и dt_tile (размер [1, chunk_size, BLOCK_H]) дает эффективное затухание для каждого токена и головы. ct.cumsum(..., axis=1) сканирует вдоль размерности токенов внутри чанка, и результат сохраняется в формате, ожидаемом последующими ядрами.

Причинная маска для безопасного экспоненциального затухания
Причинная маска для безопасного экспоненциального затухания

Ядро 2: fwd_pass_state

Ядро fwd_pass_state вычисляет начальное скрытое состояние каждого чанка и конечное скрытое состояние после последнего чанка. Оно не вычисляет выход напрямую, а подготавливает переносимое состояние, которое compute_out позже проецирует в выходы. В основе ядра лежит последовательный цикл по чанкам.

Каждый запуск ядра загружает один срез скрытого состояния (batch, head, head_tile, state_tile). Внутри этого среза hid_tile имеет размер [BLOCK_HEAD, BLOCK_STATE] и содержит плитку начального скрытого состояния для каждого чанка.

terminalpython
head_tile_idx, state_tile_idx, batch_head = ct.bid(0), ct.bid(1), ct.bid(2)
batch = batch_head // x.shape[2]
head = batch_head % x.shape[2]
group = head // num_heads_per_group
hid_tile = ct.load(
    init_state,
    index=(batch, head, head_tile_idx, state_tile_idx),
    shape=(1, 1, BLOCK_HEAD, BLOCK_STATE),
).reshape((BLOCK_HEAD, BLOCK_STATE))

В каждой итерации цикла сначала сохраняется скрытое состояние:

terminalpython
num_chunks = ct.cdiv(b.shape[1], chunk_size)
for chunk_idx in range(num_chunks):
    ct.store(
        hiddens,
        index=(batch, head, chunk_idx, head_tile_idx, state_tile_idx),
        tile=hid_tile.reshape((1, 1, 1, BLOCK_HEAD, BLOCK_STATE)).astype(hiddens.dtype),
    )

Остальная часть цикла загружает один чанк dt и decay_cumsum для вычисления начального скрытого состояния следующего чанка. Математика:

terminalpython
h_{t+T} = exp(G_last) * h_t + (exp(G_last - G) * B) * X^T

ct.extract позволяет взять последний токен из тайла затухания (для вычисления G_last). Используется exp2 вместо exp для повышения производительности. ct.mma — это API, который выполняет умножение матриц с добавлением, используя Tensor Cores.

terminalpython
x_tile = ct.load(
        x, index=(batch, chunk_idx, head, head_tile_idx),
        shape=(1, chunk_size, 1, BLOCK_HEAD),
        padding_mode=ct.PaddingMode.ZERO,
    ).reshape((chunk_size, BLOCK_HEAD))
    b_tile = ct.load(
        b, index=(batch, chunk_idx, group, state_tile_idx),
        shape=(1, chunk_size, 1, BLOCK_STATE),
        padding_mode=ct.PaddingMode.ZERO,
    ).reshape((chunk_size, BLOCK_STATE))
    dt_tile = ct.load(
        dt, index=(batch, chunk_idx, head),
        shape=(1, chunk_size, 1),
        padding_mode=ct.PaddingMode.ZERO,
    ).reshape((chunk_size,))
    d_tile = ct.load(
        decay_cumsum, index=(batch, chunk_idx, head),
        shape=(1, chunk_size, 1),
        padding_mode=ct.PaddingMode.ZERO,
    ).reshape((chunk_size,))
    d_last = ct.extract(d_tile, index=(chunk_size - 1,), shape=(1,))
    b_dt_d = b_tile * (dt_tile * ct.exp2(d_last - d_tile))[:, None]
    hid_tile = ct.exp2(d_last) * hid_tile
    hid_tile = ct.mma(x_tile.transpose(), b_dt_d.astype(b.dtype), hid_tile)

После последнего чанка hid_tile содержит конечное скрытое состояние, которое сохраняется. Во время инференса это значение может быть подано обратно как init_state для следующего вызова; во время обучения оно обычно отбрасывается.

Производительность прямого прохода Mamba-2 с использованием cuTile
Производительность прямого прохода Mamba-2 с использованием cuTile

Ядро 3: compute_out

Хотя в исходном тексте детализация третьего ядра compute_out обрывается, логика его работы следует из предыдущих разделов. Это ядро объединяет перенесенное состояние, затухающую и причинно замаскированную матрицу взаимодействия, а также связь по умолчанию (skip connection) в единое tiled-ядро. Оно хранит промежуточные матрицы в регистрах и приводит их к TF32 для выполнения на Tensor Cores. Ключевые оптимизации здесь включают подсказки задержки для моделирования трафика DRAM, обмен операндами для маршрутизации объединенных операндов в память Tensor Cores, транспонированные макеты памяти для доступа, дружественного к TMA, и автонастройщик, который ищет параметры размера блока и занятости для каждой формы входа.

07Оптимизации производительности

Помимо самой математики, инженеры применили ряд низкоуровневых оптимизаций:

  • Подсказки задержки (Latency hints): Помогают моделировать трафик DRAM и планировать доступ к памяти более эффективно.
  • Обмен операндами (Operand swapping): Позволяет маршрутизировать объединенные операнды непосредственно в память Tensor Cores, уменьшая задержки.
  • Транспонированные макеты памяти: Обеспечивают доступ, дружественный к TMA (Tensor Memory Accelerator), что критически важно для высокой пропускной способности памяти.
  • Автонастройщик (Autotuner): Автоматически ищет оптимальные параметры размера блока и занятости (occupancy) для каждой формы входа, обеспечивая максимальную утилизацию GPU.

08Что это значит на практике

Для разработчиков AI, работающих с моделями пространства состояний, эта статья демонстрирует, что путь к высокой производительности лежит не только через выбор архитектуры, но и через глубокую оптимизацию реализации. Использование Python DSL, такого как cuTile, снижает порог входа для написания высокопроизводительного кода, не жертвуя скоростью. Для российских разработчиков, которые часто сталкиваются с ограничениями доступа к облачным ресурсам или необходимостью локального запуска тяжелых моделей, понимание таких низкоуровневых оптимизаций становится критически важным. Оно позволяет извлекать максимум из имеющегося «железа», будь то NVIDIA A100, H100 или более старые поколения GPU.

Эксперименты Jane Street показывают, что Mamba-2, оптимизированный с помощью cuTile, способен конкурировать с трансформерами по скорости инференса, сохраняя при этом преимущества линейной сложности. Это открывает новые возможности для работы с очень длинными контекстами в финансовых моделях, анализе текста и других областях, где длина последовательности играет ключевую роль.

Если вы хотите начать использовать cuTile, ознакомьтесь с документацией Python, репозиториями GitHub и примерами кода, предоставленными NVIDIA. Это мощный инструмент, который может значительно ускорить ваши проекты в области глубокого обучения.

Источник: NVIDIA Developer ↗