Глава 137: Gated State Space Models (Gated SSM)

Обзор

Gated State Space Models (Gated SSM) — это усовершенствование классических моделей пространства состояний (SSM) с помощью механизмов гейтинга, вдохновлённых рекуррентными нейронными сетями (LSTM, GRU). Добавление обучаемых гейтов, которые избирательно управляют потоком информации через динамику состояний, позволяет Gated SSM преодолеть два ключевых ограничения базовых SSM: неспособность избирательно запоминать или забывать информацию и фиксированную линейную динамику. Основополагающая работа Mehta et al. (2022) представила архитектуру GSS (Gated State Spaces), которая объединяет блок гейтированной активации со слоем пространства состояний, демонстрируя конкурентную или превосходящую производительность по сравнению с Transformer-ами на задачах моделирования последовательностей с дальними зависимостями.

В алгоритмической торговле Gated SSM предлагают мощный индуктивный уклон: они эффективно моделируют дальние зависимости в ценовых рядах (через SSM-основу), при этом избирательно реагируя на смену рыночных режимов, всплески волатильности и сигналы возврата к среднему (через гейтинг). В этой главе рассматриваются теория, реализации на Python и Rust, а также практические торговые стратегии с использованием Gated SSM на данных фондового и криптовалютного рынков.

Содержание

Введение в модели пространства состояний
Механизмы гейтинга в SSM
Математические основы
Архитектуры Gated SSM
Применение в трейдинге
Реализация на Python
Реализация на Rust
Практические примеры с данными акций и криптовалют
Фреймворк бэктестинга
Оценка производительности
Дальнейшие направления
Литература

Введение в модели пространства состояний

Непрерывная SSM

Модель пространства состояний определяет линейную динамическую систему, отображающую входной сигнал u(t) в выходной y(t) через скрытое состояние x(t):

x'(t) = A x(t) + B u(t)
y(t)  = C x(t) + D u(t)

Где:

x(t) ∈ ℝ^N — скрытое состояние
A ∈ ℝ^(N×N) — матрица перехода состояний
B ∈ ℝ^(N×1) — проекция входа
C ∈ ℝ^(1×N) — проекция выхода
D ∈ ℝ — сквозное соединение (skip connection)

Дискретизация

Для дискретных последовательностей (например, дневных цен) непрерывная система дискретизируется с шагом Δ. Дискретизация методом удержания нулевого порядка (ZOH) даёт:

Ā = exp(ΔA)
B̄ = (ΔA)^{-1} (exp(ΔA) - I) · ΔB

Дискретная рекуррентность:

x_k = Ā x_{k-1} + B̄ u_k
y_k = C x_k + D u_k

Эффективное вычисление через свёртку

Ключевое наблюдение: дискретная SSM может быть вычислена как глобальная свёртка:

K = (CB̄, CĀB̄, CĀ²B̄, ..., CĀ^{L-1}B̄)
y = K * u

Это позволяет вычислять за O(L log L) с помощью FFT, что делает SSM высокоэффективными для длинных последовательностей.

Ограничения базовых SSM

Несмотря на эффективность, базовые SSM имеют фиксированную, не зависящую от входа динамику:

Матрицы A, B, C не изменяются в зависимости от содержания входа
Модель не может избирательно обращать внимание на определённые входы или игнорировать их
Поток информации через состояние одинаков независимо от значимости входа

Именно здесь механизмы гейтинга становятся необходимыми.

Механизмы гейтинга в SSM

Мотивация из RNN

LSTM и GRU решают проблему избирательной памяти с помощью гейтов — значений с сигмоидальной активацией, которые модулируют поток информации. Ячейка LSTM использует:

Гейт забывания: f_t = σ(W_f · [h_{t-1}, x_t] + b_f) — что забыть
Входной гейт: i_t = σ(W_i · [h_{t-1}, x_t] + b_i) — какую новую информацию сохранить
Выходной гейт: o_t = σ(W_o · [h_{t-1}, x_t] + b_o) — что выводить

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

Типы гейтинга в SSM

1. Гейтинг выхода (GSS / Mehta et al., 2022)

Простейший подход — гейтирование выхода SSM:

z = SSM(u)           # Стандартный проход SSM
g = σ(Linear(u))     # Сигнал гейтинга из входа
y = z ⊙ g            # Поэлементное гейтирование

2. Гейтинг состояния

Гейты, применяемые непосредственно к обновлению состояния:

x_k = g_f ⊙ (Ā x_{k-1}) + g_i ⊙ (B̄ u_k)

Где g_f (гейт забывания) и g_i (входной гейт) зависят от входа.

3. Входо-зависимая дискретизация (стиль Mamba)

Шаг дискретизации Δ делается зависимым от входа:

Δ_k = softplus(Linear(u_k))
Ā_k = exp(Δ_k · A)
B̄_k = Δ_k · B

Это делает динамику состояния контенто-зависимой: большой Δ → больше внимания на новый вход, маленький Δ → больше внимания на память состояния.

Математические основы

Блок GSS (Gated State Spaces)

Архитектура GSS из Mehta et al. (2022) состоит из:

Вход u ∈ ℝ^{L×d}

Ветвь 1 (путь SSM):
  v = Linear_V(u)           ∈ ℝ^{L×d_ssm}
  z = SSM(v)                ∈ ℝ^{L×d_ssm}
  z = LayerNorm(z)

Ветвь 2 (путь гейта):
  g = Linear_G(u)           ∈ ℝ^{L×d_ssm}
  g = GELU(g)

Объединение:
  y = z ⊙ g                 ∈ ℝ^{L×d_ssm}
  y = Linear_O(y)           ∈ ℝ^{L×d}

Инициализация HiPPO

Матрица состояний A инициализируется с помощью фреймворка HiPPO (High-Order Polynomial Projection Operator):

A_{nk} = -{ (2n+1)^{1/2} (2k+1)^{1/2}   если n > k
          { n+1                             если n = k
          { 0                               если n < k

Эта инициализация позволяет SSM оптимально аппроксимировать историю входов с помощью полиномов Лежандра, что критически важно для захвата дальних зависимостей в финансовых временных рядах.

Диагональные пространства состояний (S4D)

Для вычислительной эффективности матрица состояний A часто ограничивается диагональной:

A = diag(a_1, a_2, ..., a_N)

С диагональной A каждое измерение состояния эволюционирует независимо:

x_k^{(n)} = ā_n · x_{k-1}^{(n)} + b̄_n · u_k

Это упрощает вычисления с O(N²) до O(N) на шаг.

Формула гейтированной рекуррентности

Полная рекуррентность Gated SSM для одного слоя:

# Входные проекции
v_k = W_v · u_k + b_v                    (проекция значения)
g_k = σ(W_g · u_k + b_g)                 (гейт, сигмоидальная активация)

# Обновление состояния (с диагональной A)
x_k = diag(ā) · x_{k-1} + diag(b̄) · v_k

# Выход
z_k = C · x_k
y_k = z_k ⊙ g_k                          (гейтированный выход)

Стабильность обучения

Gated SSM используют несколько техник для стабильного обучения:

Параметризация A: A параметризуется в логарифмическом пространстве: A = -exp(log_A), обеспечивая отрицательные действительные части (стабильная динамика)
Обрезка градиентов: Применяется для предотвращения взрывающихся градиентов при обучении на длинных последовательностях
Расписание скорости обучения: Параметры SSM (A, B, C) часто используют меньшую скорость обучения, чем параметры гейтинга

Архитектуры Gated SSM

GSS (Gated State Spaces) — Mehta et al., 2022

Оригинальная архитектура складывает блоки GSS с остаточными связями:

for each layer:
    residual = u
    u = LayerNorm(u)
    u = GSSBlock(u)
    u = Dropout(u)
    u = u + residual

Ключевые решения дизайна:

Активация GELU для гейта (не сигмоида), обеспечивающая более гладкие градиенты
Нормализация слоя после SSM, перед гейтингом
Фактор расширения: внутренняя размерность d_ssm = α · d (обычно α = 2)

S4 с гейтингом

Добавление гейтинга к архитектуре S4:

u → S4_Layer → LayerNorm → ⊙ ← σ(Linear(u))

Mamba (Selective State Spaces)

Mamba (Gu & Dao, 2023) делает все параметры SSM входо-зависимыми:

x_k = Ā(u_k) · x_{k-1} + B̄(u_k) · u_k
y_k = C(u_k) · x_k

Это наиболее выразительная форма гейтинга, где вся динамика состояний зависит от содержания.

Применение в трейдинге

Почему Gated SSM для финансовых рынков?

Режимо-зависимая обработка: Гейты учатся переключать поведение между бычьим/медвежьим/боковым рынками
Дальние зависимости: SSM-основа эффективно захватывает сезонные паттерны и долгосрочные тренды
Избирательное внимание: Гейты фильтруют шум (случайные дневные колебания), пропуская значимые сигналы (изменения тренда, прорывы волатильности)
Эффективный инференс: O(1) на шаг рекуррентности для торговли в реальном времени, в отличие от O(L) для Transformer-ов

Торговые задачи

Предсказание доходности: Прогнозирование доходности следующего периода с использованием Gated SSM для захвата как краткосрочного импульса, так и долгосрочного возврата к среднему.

Прогнозирование волатильности: Механизм гейтинга учится подчёркивать кластеризацию волатильности (ARCH-эффекты), сохраняя при этом долгую память о режимах волатильности.

Классификация тренда: Классификация рынка на трендовый и возвратный режимы. Гейты естественным образом сегментируют входную последовательность для режимо-специфической обработки.

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

Реализация на Python

Модель GatedSSM

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np

class DiagonalSSMLayer(nn.Module):
    """Слой диагональной модели пространства состояний."""

    def __init__(self, d_model: int, d_state: int = 64, dt_min: float = 0.001, dt_max: float = 0.1):
        super().__init__()
        self.d_model = d_model
        self.d_state = d_state

        # Матрица состояний A (параметризация в логарифмическом пространстве)
        log_A_real = torch.log(0.5 * torch.ones(d_model, d_state))
        self.log_A_real = nn.Parameter(log_A_real)

        # Входная матрица B
        self.B = nn.Parameter(torch.randn(d_model, d_state) * 0.02)

        # Выходная матрица C
        self.C = nn.Parameter(torch.randn(d_model, d_state) * 0.02)

        # Шаг дискретизации
        log_dt = torch.rand(d_model) * (np.log(dt_max) - np.log(dt_min)) + np.log(dt_min)
        self.log_dt = nn.Parameter(log_dt)

        # Сквозное соединение
        self.D = nn.Parameter(torch.ones(d_model))

    def forward(self, u: torch.Tensor) -> torch.Tensor:
        batch, seq_len, d_model = u.shape

        dt = torch.exp(self.log_dt)
        A = -torch.exp(self.log_A_real)
        dtA = dt.unsqueeze(-1) * A
        A_bar = torch.exp(dtA)
        B_bar = self.B * dt.unsqueeze(-1)

        x = torch.zeros(batch, d_model, self.d_state, device=u.device)
        outputs = []

        for t in range(seq_len):
            x = A_bar * x + B_bar * u[:, t, :].unsqueeze(-1)
            y_t = (self.C * x).sum(dim=-1)
            outputs.append(y_t)

        y = torch.stack(outputs, dim=1)
        y = y + u * self.D
        return y


class GatedSSMBlock(nn.Module):
    """Гейтированный блок SSM (стиль GSS)."""

    def __init__(self, d_model: int, d_state: int = 64, expand: int = 2, dropout: float = 0.1):
        super().__init__()
        d_inner = d_model * expand
        self.linear_v = nn.Linear(d_model, d_inner)
        self.linear_g = nn.Linear(d_model, d_inner)
        self.ssm = DiagonalSSMLayer(d_inner, d_state)
        self.norm = nn.LayerNorm(d_inner)
        self.linear_o = nn.Linear(d_inner, d_model)
        self.dropout = nn.Dropout(dropout)

    def forward(self, u: torch.Tensor) -> torch.Tensor:
        v = self.linear_v(u)
        z = self.ssm(v)
        z = self.norm(z)
        g = F.gelu(self.linear_g(u))
        y = z * g
        y = self.dropout(y)
        y = self.linear_o(y)
        return y


class GatedSSMModel(nn.Module):
    """Полная модель Gated SSM для предсказания последовательностей."""

    def __init__(self, input_size, d_model=128, d_state=64, n_layers=4, expand=2, dropout=0.1, num_classes=None):
        super().__init__()
        self.input_proj = nn.Linear(input_size, d_model)
        self.layers = nn.ModuleList()
        self.norms = nn.ModuleList()
        for _ in range(n_layers):
            self.layers.append(GatedSSMBlock(d_model, d_state, expand, dropout))
            self.norms.append(nn.LayerNorm(d_model))
        self.final_norm = nn.LayerNorm(d_model)
        self.head = nn.Linear(d_model, num_classes if num_classes else 1)
        self.num_classes = num_classes

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        h = self.input_proj(x)
        for layer, norm in zip(self.layers, self.norms):
            residual = h
            h = norm(h)
            h = layer(h)
            h = h + residual
        h = self.final_norm(h)
        h = h[:, -1, :]
        return self.head(h)

Подробные примеры кода для загрузки данных, бэктестинга и торговли на Bybit доступны в английской версии README.md.

Реализация на Rust

Структура проекта

137_gated_ssm/
├── Cargo.toml
├── src/
│   ├── lib.rs
│   ├── model/
│   │   ├── mod.rs
│   │   ├── ssm.rs
│   │   └── gated_ssm.rs
│   ├── data/
│   │   ├── mod.rs
│   │   ├── features.rs
│   │   └── bybit.rs
│   ├── backtest/
│   │   ├── mod.rs
│   │   └── engine.rs
│   └── trading/
│       ├── mod.rs
│       ├── signals.rs
│       └── strategy.rs
└── examples/
    ├── basic_gated_ssm.rs
    ├── crypto_trading.rs
    └── backtest_strategy.rs

Полный код реализации на Rust доступен в директории src/ и описан в английской версии README.md.

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

Метрика	Описание	Цель
Sharpe Ratio	Доходность с поправкой на риск (годовая)	> 1.0
Sortino Ratio	Доходность с поправкой на нижний риск	> 1.5
Max Drawdown	Максимальная просадка	> -20%
Win Rate	Доля прибыльных сделок	> 52%
Annual Return	Сложная годовая доходность	> 10%

Ожидаемые преимущества Gated SSM

Над базовыми SSM: Избирательная обработка улучшает соотношение сигнал/шум
Над LSTM: Более эффективное моделирование дальних зависимостей с обучением O(L log L)
Над Transformer-ами: O(1) инференс на шаг для торговли в реальном времени
Над GRU: Параметризация пространства состояний даёт лучшие теоретические гарантии долгосрочной памяти

Дальнейшие направления

Selective State Spaces (Mamba): Все параметры SSM зависят от входа для максимальной выразительности
Многомасштабные Gated SSM: Разные слои SSM работают на разных временных масштабах (тик, минута, день)
Кросс-активный гейтинг: Гейты, обусловленные рыночными сигналами (VIX, секторные индексы)
Гибридные архитектуры: Комбинирование Gated SSM со слоями внимания
Аппаратно-оптимизированные ядра: Пользовательские CUDA-ядра для эффективного параллельного сканирования
Непрерывное обучение: Онлайн-адаптация параметров гейтинга при смене рыночных режимов

Литература

Mehta, H., Gupta, A., Cutkosky, A., & Neyshabur, B. (2022). Long Range Language Modeling via Gated State Spaces. arXiv:2206.13947.
Gu, A., Goel, K., & Ré, C. (2021). Efficiently Modeling Long Sequences with Structured State Spaces. ICLR 2022.
Gu, A., & Dao, T. (2023). Mamba: Linear-Time Sequence Modeling with Selective State Spaces. arXiv:2312.00752.
Gu, A., Johnson, I., Goel, K., Saab, K., Dao, T., Rudra, A., & Ré, C. (2021). Combining Recurrent, Convolutional, and Continuous-time Models with Linear State Space Layers. NeurIPS 2021.
Smith, J.T.H., Warrington, A., & Linderman, S. (2022). Simplified State Space Layers for Sequence Modeling. ICLR 2023.
Gu, A., Dao, T., Ermon, S., Rudra, A., & Ré, C. (2020). HiPPO: Recurrent Memory with Optimal Polynomial Projections. NeurIPS 2020.

Запуск примеров

Python

cd 137_gated_ssm/python
pip install -r requirements.txt
python model.py
python backtest.py

Rust

cd 137_gated_ssm
cargo build
cargo run --example basic_gated_ssm
cargo run --example crypto_trading
cargo run --example backtest_strategy