Разработка RL-агента для криптотрейдинга: PPO, SAC, DQN

Обучение RL-агента (PPO/SAC/DQN) для торговой стратегии

Представьте: вы потратили месяцы на обучение DQN-агента на исторических данных, а на реальном рынке он теряет капитал из-за неучтённого проскальзывания. В одном из наших проектов клиент пришёл с такой проблемой: обучали PPO на минутных свечах, его Sharpe ratio на тесте был 1.8, но в live просадка достигла 40%. Клиент терял около $15,000 ежемесячно из-за этих недочётов. Мы выяснили, что среда не учитывала комиссии и ликвидность. После калибровки reward и добавления walk-forward validation Sharpe снова вырос до 1.5, а просадка сократилась до 12%. Экономия составила $4,000 в месяц.

Проектирование RL-агента для криптотрейдинга — это не просто выбор алгоритма. Вы сталкиваетесь с нестационарностью рынка, скрытыми комиссиями, проскальзыванием и риском переобучения. Мы берём на себя полный цикл — от формирования data pipeline до live trading. Используем проверенные алгоритмы PPO, SAC и DQN, адаптируя их под вашу стратегию. Наш опыт — более пяти лет в блокчейн-разработке, 15+ проектов для DeFi и CEX, включая интеграцию с Binance API. Свяжитесь с нами для детального анализа вашей стратегии.

Три рабочих алгоритма: DQN, PPO, SAC

Каждый алгоритм имеет свою нишу. Рассмотрим их сильные стороны и типичные сценарии применения.

DQN (Deep Q-Network)

Подходит для дискретных действий (buy/hold/sell) и простых стратегий. DQN аппроксимирует Q-функцию: Q(state, action) — ожидаемая дисконтированная награда при выборе действия action в состоянии state.

import torch
import torch.nn as nn
from collections import deque
import random

class DQNNetwork(nn.Module):
    def __init__(self, state_dim, n_actions, hidden_dim=256):
        super().__init__()
        # Dueling architecture: отдельные Value и Advantage потоки
        self.shared = nn.Sequential(
            nn.Linear(state_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU()
        )
        self.value_stream = nn.Linear(hidden_dim, 1)
        self.advantage_stream = nn.Linear(hidden_dim, n_actions)

    def forward(self, x):
        shared = self.shared(x)
        value = self.value_stream(shared)
        advantage = self.advantage_stream(shared)
        # Dueling: Q = V + (A - mean(A))
        q_values = value + (advantage - advantage.mean(dim=1, keepdim=True))
        return q_values

class PrioritizedReplayBuffer:
    """Prioritized Experience Replay — чаще семплируем важные transitions"""
    def __init__(self, capacity=50000, alpha=0.6):
        self.buffer = deque(maxlen=capacity)
        self.priorities = deque(maxlen=capacity)
        self.alpha = alpha

    def push(self, state, action, reward, next_state, done, td_error=1.0):
        priority = (abs(td_error) + 1e-5) ** self.alpha
        self.buffer.append((state, action, reward, next_state, done))
        self.priorities.append(priority)

    def sample(self, batch_size, beta=0.4):
        probs = np.array(self.priorities) / sum(self.priorities)
        indices = np.random.choice(len(self.buffer), batch_size, p=probs)
        # Importance sampling weights
        weights = (len(self.buffer) * probs[indices]) ** (-beta)
        weights /= weights.max()
        batch = [self.buffer[i] for i in indices]
        return batch, indices, weights

Double DQN устраняет overestimation Q-значений: online сеть выбирает действие, target сеть оценивает.

# Double DQN target calculation with torch.no_grad():
    next_actions = online_net(next_states).argmax(dim=1)  # online net выбирает
    next_q = target_net(next_states).gather(1, next_actions.unsqueeze(1))  # target оценивает
    targets = rewards + gamma * next_q * (1 - dones)

PPO (Proximal Policy Optimization)

Подходит для дискретных и непрерывных действий, on-policy, стабильное обучение. PPO ограничивает размер обновления политики через clipping.

class PPOActor(nn.Module):
    def __init__(self, state_dim, action_dim, hidden_dim=256):
        super().__init__()
        self.network = nn.Sequential(
            nn.Linear(state_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.Tanh()
        )
        self.policy_head = nn.Linear(hidden_dim, action_dim)
        self.value_head = nn.Linear(hidden_dim, 1)

    def forward(self, x):
        features = self.network(x)
        logits = self.policy_head(features)
        value = self.value_head(features)
        return logits, value

def ppo_update(model, optimizer, states, actions, old_log_probs, advantages, returns, clip_eps=0.2, n_epochs=4):
    for _ in range(n_epochs):
        logits, values = model(states)
        dist = torch.distributions.Categorical(logits=logits)
        new_log_probs = dist.log_prob(actions)
        entropy = dist.entropy()

        # PPO clipped objective
        ratio = (new_log_probs - old_log_probs).exp()
        surr1 = ratio * advantages
        surr2 = torch.clamp(ratio, 1 - clip_eps, 1 + clip_eps) * advantages
        actor_loss = -torch.min(surr1, surr2).mean()
        critic_loss = (returns - values.squeeze()).pow(2).mean()
        entropy_loss = -entropy.mean()

        total_loss = actor_loss + 0.5 * critic_loss + 0.01 * entropy_loss

        optimizer.zero_grad()
        total_loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
        optimizer.step()

SAC (Soft Actor-Critic)

Подходит для непрерывного action space (позиционирование 0%–100% капитала), off-policy, максимальная sample efficiency. SAC максимизирует: J(π) = E[Σ γ^t (r_t + α H(π(·|s_t)))]. Энтропийный член H поощряет exploration.

class SACActorContinuous(nn.Module):
    def __init__(self, state_dim, action_dim, hidden_dim=256):
        super().__init__()
        self.network = nn.Sequential(
            nn.Linear(state_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU()
        )
        self.mean_head = nn.Linear(hidden_dim, action_dim)
        self.log_std_head = nn.Linear(hidden_dim, action_dim)

    def forward(self, x):
        features = self.network(x)
        mean = self.mean_head(features)
        log_std = self.log_std_head(features).clamp(-20, 2)
        std = log_std.exp()
        dist = torch.distributions.Normal(mean, std)
        action = dist.rsample()  # reparameterization trick
        # Squash to [-1, 1]
        action_tanh = torch.tanh(action)
        log_prob = dist.log_prob(action) - torch.log(1 - action_tanh.pow(2) + 1e-6)
        return action_tanh, log_prob.sum(-1, keepdim=True)

Какой алгоритм выбрать для вашей стратегии?

Выбор зависит от action space и требований к sample efficiency. Если стратегия оперирует только дискретными сигналами (покупка/продажа/удержание) — DQN с dueling и PER даст стабильный результат. Для непрерывного управления капиталом (например, процент от портфеля) SAC вне конкуренции: он в 2–3 раза эффективнее PPO по использованию данных. PPO — универсальный выбор, когда нужна надёжность и простота настройки.

Мы часто комбинируем алгоритмы в multi-agent архитектуре: macro-агент на DQN определяет общее направление, micro-агент на SAC исполняет сделки. Это снижает variance и улучшает Sharpe ratio на 15–30%.

Почему важна корректная функция награды?

Reward shaping — ключевой этап, от которого зависит адекватность поведения агента. Типичные ошибки: агент учится накапливать нереализованную прибыль (без учёта проскальзывания) или начинает торговать очень редко, чтобы избежать комиссий. Мы используем многокомпонентную награду: PnL, штраф за просадку, комиссии и спред. Например, reward = ΔP&L - λ1 * fee - λ2 * max_drawdown. Коэффициенты λ подбираются так, чтобы симулировать реалистичные условия.

В одном из проектов для DeFi-протокола неправильный reward привёл к тому, что агент открывал сотни микро-сделок, генерируя убыток от комиссий. После редизайна награды (штраф за количество сделок) агент стал работать в плюс.

Сравнение алгоритмов для крипто-торговли

Как настроить обучение RL-агента: пошаговый план

1. Определите action space и state space. Для дискретных действий (buy/sell/hold) подходит DQN, для непрерывного позиционирования — SAC. Состояние включает цены, объёмы, индикаторы.
2. Спроектируйте функцию награды. Учитывайте PnL, комиссии, проскальзывание, штраф за просадку.
3. Выберите алгоритм и архитектуру нейросети. Используем dueling DQN, PPO с clipping, SAC с автоматической регулировкой энтропии.
4. Обучите с валидацией. Применяем walk-forward validation с 36 rolling windows и early stopping.
5. Протестируйте на out-of-sample данных. Оцениваем Sharpe ratio, max drawdown, stability reward.

Типичные сложности и как мы их решаем

Нестационарность рынка — агент, обученный на спокойном рынке, может провалиться при высокой волатильности. Как отмечается в спецификации reinforcement learning, смена распределения данных — серьёзный вызов. Мы применяем curriculum learning: поэтапно увеличиваем волатильность среды, а в продакшене — continuous fine-tuning с детектором дрифта.

Reward hacking — искусственно завышенные награды. Защита через reward clipping и использование реалистичного симулятора с рыночными данными (Level 2, исторические свечи).

Overfitting — agent memorization. Используем walk-forward validation с 36 rolling windows и тестирование на полностью исключённых периодах (out-of-sample).

Что входит в работу

• Анализ стратегии и подготовка data pipeline.
• Проектирование кастомной среды (gymnasium) с учётом комиссий, проскальзывания и просадок.
• Выбор алгоритма и архитектуры нейросети.
• Обучение с подбором гиперпараметров (grid/random search, Bayesian optimization).
• Walk-forward validation и робастность к смене режимов рынка.
• Интеграция с брокерским API (Binance, Bybit, KuCoin).
• Документирование, обучение вашей команды, сопровождение 3 месяца.

Свяжитесь с нами, чтобы мы могли проанализировать вашу стратегию. Мы гарантируем качество результата и сопровождение на всех этапах.

Ориентировочные сроки и этапы

Закажите консультацию — мы подберём алгоритм и архитектуру под вашу задачу. Оценим проект в течение 2 рабочих дней.