Разработка Multi-Agent RL системы для торговли

Разработка Multi-Agent RL системы для торговли

Multi-Agent Reinforcement Learning (MARL) в трейдинге: несколько независимых агентов работают параллельно — каждый специализируется на своей нише. Агент трендовой торговли, агент mean-reversion, агент управления риском — их совокупное поведение формирует более устойчивую систему, чем один универсальный агент.

Зачем MARL в трейдинге

Один универсальный агент страдает от concept drift: рыночные режимы меняются. Bull market → одна стратегия, sideways → другая, high-volatility → третья. MARL решает через специализацию и ансамблирование:

Декомпозиция задачи:

• Agent₁: Momentum/Trend following (RSI, MACD, Moving Averages)
• Agent₂: Mean Reversion (Bollinger Bands, Z-score)
• Agent₃: Volatility/Options-like hedging
• Meta-agent (coordinator): взвешивает рекомендации агентов

Разделение по активам:

• Agent per asset: каждый агент специализируется на одном инструменте
• Hierarchical: master agent управляет капиталом, sub-agents торгуют секторами

MARL архитектуры

Independent Learners (IL): Каждый агент обучается независимо, другие агенты — часть среды. Простейший подход. Проблема: нестационарность (действия других агентов меняют среду).

Centralized Training, Decentralized Execution (CTDE): При обучении: каждый агент видит глобальное состояние. При исполнении: только локальное наблюдение.

class CTDECritic(nn.Module):
    """Centralized critic видит все наблюдения и действия"""
    def __init__(self, n_agents, obs_dim, action_dim):
        super().__init__()
        # concat всех obs + actions
        input_dim = n_agents * (obs_dim + action_dim)
        self.net = nn.Sequential(
            nn.Linear(input_dim, 256), nn.ReLU(),
            nn.Linear(256, 256), nn.ReLU(),
            nn.Linear(256, 1)
        )

    def forward(self, all_obs, all_actions):
        x = torch.cat([all_obs.flatten(1), all_actions.flatten(1)], dim=1)
        return self.net(x)

MADDPG (Multi-Agent DDPG): CTDE для continuous actions. Каждый агент имеет свою policy π_i и Q-функцию Q_i. Q_i обучается с global state/actions.

Hierarchical MARL система

Level 0 (Portfolio Manager):
    Input: market regime + agent signals
    Output: capital allocation weights

Level 1 (Strategy Agents):
    Agent Trend: signal ∈ {buy, hold, sell} + confidence
    Agent MeanRev: signal ∈ {buy, hold, sell} + confidence
    Agent Momentum: signal ∈ {buy, hold, sell} + confidence

Level 2 (Risk Manager):
    Input: proposed positions + portfolio state
    Output: position limits + stop-loss levels

Portfolio Manager как meta-learner:

class PortfolioManager(nn.Module):
    def __init__(self, n_agents, n_assets):
        super().__init__()
        # входы: сигналы агентов + рыночный режим
        self.regime_detector = RegimeDetector()
        self.allocation_net = nn.Sequential(
            nn.Linear(n_agents * 3 + regime_dim, 128), nn.ReLU(),
            nn.Linear(128, n_assets), nn.Softmax(dim=-1)
        )

    def forward(self, agent_signals, market_features):
        regime = self.regime_detector(market_features)
        x = torch.cat([agent_signals.flatten(1), regime], dim=1)
        return self.allocation_net(x)

Reward шаринг

Как делить reward между агентами — ключевой вопрос MARL.

Individual rewards: Каждый агент оптимизирует свой PnL. Проблема: может приводить к конфликтам (агенты торгуют против друг друга).

Shared team reward: Все агенты получают одинаковый reward (общий PnL портфеля). Решает конфликты, но затрудняет атрибуцию.

COMA (Counterfactual Multi-Agent): Reward агента i = общий reward - counterfactual (что было бы без агента i). Справедливая атрибуция вклада.

def counterfactual_reward(global_reward, baseline_rewards, agent_idx):
    """global_reward - E[reward | other agents' actions, marginalizing over agent_i]"""
    return global_reward - baseline_rewards[agent_idx]

Market Regime Detection для routing

Meta-agent нужно знать рыночный режим для правильного взвешивания стратегий:

from hmmlearn import hmm

# Hidden Markov Model для определения режима
model = hmm.GaussianHMM(n_components=3, covariance_type="full")
# state 0: bull (высокий доход, низкая vol)
# state 1: bear (отрицательный доход, высокая vol)
# state 2: sideways (низкий доход, средняя vol)
model.fit(returns_features)
regime = model.predict(current_features)

Альтернатива: LSTM classifier обученный на размеченных периодах.

PettingZoo / RLlib для MARL

from ray.rllib.algorithms.maddpg import MADDPGConfig

config = (MADDPGConfig()
    .environment(env="MultiAgentTradingEnv")
    .multi_agent(
        policies={
            "trend_agent": (None, obs_space, act_space, {"gamma": 0.99}),
            "meanrev_agent": (None, obs_space, act_space, {"gamma": 0.95}),
        },
        policy_mapping_fn=lambda agent_id, **kw: agent_id,
    )
    .training(n_step=1, tau=0.01)
)
trainer = config.build()
for i in range(1000):
    result = trainer.train()

Практические соображения

Coordination overhead: MARL система сложнее в отладке. Нужны инструменты для мониторинга каждого агента отдельно + их взаимодействия.

Overfitting к ансамблю: если агенты слишком похожи (correlation > 0.8 их сигналов) — ансамбль не даёт диверсификации.

Вычислительная стоимость: MARL в 3–5× дороже single-agent по GPU часам.

Сроки: 14–24 недели

Базовая иерархия с 2–3 агентами — 8 недель. Полноценная MARL система с CTDE, counterfactual rewards, regime detection — 20–24 недели.