Машинное обучение для генерации криптосигналов

Машинное обучение кардинально изменило торговлю криптовалютами. То, что раньше зависело исключительно от технического анализа и ручной интерпретации, теперь использует нейронные сети, способные выявлять закономерности среди миллионов ценовых тиков, снимков стакана заявок и событий в блокчейне. Это руководство рассказывает, как создавать ML-системы подтверждения криптовалютных сигналов — те же методы, которые мы используем в Smart Money API для расчета наших оценок уверенности.

Ключевая идея: ML-сигналы работают лучше всего в сочетании с традиционными метриками. Нейронная сеть, предсказывающая направление цены с точностью 52%, бесполезна. Но та, которая подтверждает импульс при положительных ставках финансирования и бычьем консенсусе китов? Это система с процентом успеха 60%+.

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

Прежде чем погружаться в код, разберитесь с математикой. Каждая нейронная сеть — это, по сути, аппроксиматор функций. Получая входные данные (цена, объем, ставка финансирования, консенсус китов), она обучается весам, минимизирующим ошибку прогнозирования на исторических данных.

Фреймворк обучения с учителем

Начните с размеченных данных: исторических пар цена/сигнал.

Python — Подготовка данных
# Подготовка размеченных данных
import numpy as np
import pandas as pd
# Загрузка OHLCV-данных для BTC
df = pd.read_csv('btc_5m.csv')
# Признаки: [open, high, low, close, volume, funding_rate, whale_long_pct]
features = df[['open', 'high', 'low', 'close', 'volume', 'fr', 'whale_long']].values
# Цель: цена выросла (1) или упала (0) в следующие 5 свечей
targets = (df['close'].shift(-5) > df['close']).astype(int).values
# Нормализация признаков к [0,1]
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X = scaler.fit_transform(features)

Создание признаков для криптовалют

Сырых OHLCV-данных недостаточно. Вам нужны:

Ключевой момент — выявление асимметрии информации — сигналов, которые не видит большинство трейдеров. Наш Smart Money API объединяет все три уровня (деривативы, ончейн-данные, киты) в единый функционал, превосходящий любую отдельную метрику.

Архитектура нейронной сети

Многослойный перцептрон (MLP) для классификации

Простая feedforward-сеть показывает удивительно хорошие результаты для бинарной классификации (покупка/продажа):

Python — PyTorch MLP
import torch
import torch.nn as nn
class CryptoMLP(nn.Module):
def __init__(self, input_size=7):
super().__init__()
self.fc1 = nn.Linear(input_size, 128)
self.fc2 = nn.Linear(128, 64)
self.fc3 = nn.Linear(64, 32)
self.fc4 = nn.Linear(32, 1)
self.dropout = nn.Dropout(0.3)
def forward(self, x):
x = torch.relu(self.fc1(x))
x = self.dropout(x)
x = torch.relu(self.fc2(x))
x = self.dropout(x)
x = torch.relu(self.fc3(x))
x = torch.sigmoid(self.fc4(x))
return x

Эта архитектура имеет 7 входных признаков, проходящих через последовательно сужающиеся слои (128 → 64 → 32 → 1), с активациями ReLU и dropout для регуляризации. Сигмоидный выход сжимает финальный слой до [0,1], представляя вероятность покупки.

LSTM для прогнозирования последовательностей

Почему рекуррентные сети?

Движение цен не является независимым — оно обладает памятью. Сеть LSTM (Long Short-Term Memory) может изучать временные зависимости: «Если импульс растет, а ставка финансирования только что стала положительной после 3 часов отрицательных значений, следующая 5-минутная свеча с вероятностью 58% будет бычьей».

Python — LSTM для криптовалют
class CryptoLSTM(nn.Module):
def __init__(self, input_size=7, hidden_size=64, num_layers=2):
super().__init__()
self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True, dropout=0.3)
self.fc1 = nn.Linear(hidden_size, 32)
self.fc2 = nn.Linear(32, 1)
def forward(self, x):
# x shape: (batch, seq_len, features)
lstm_out, _ = self.lstm(x)
# Take last timestep
last_hidden = lstm_out[:, -1, :]
x = torch.relu(self.fc1(last_hidden))
x = torch.sigmoid(self.fc2(x))
return x

Эта LSTM принимает последовательности из 60 временных шагов (5 часов 5-минутных свечей) и предсказывает следующее направление. Состояние ячейки определяет, какие признаки наиболее важны в разных точках последовательности.

Подготовка последовательностей

Преобразуйте ваши данные в скользящие окна:

Python — Создание последовательностей для LSTM
def create_sequences(data, seq_len=60):
X, y = [], []
for i in range(len(data) - seq_len):
X.append(data[i:i+seq_len])
y.append(data[i+seq_len, -1]) # next target
return np.array(X), np.array(y)
X, y = create_sequences(X)
# X.shape: (n_samples, 60, 7)

Обучение и оценка

Стратегия разделения на обучающую и тестовую выборки

Для временных рядов никогда не перемешивайте. Утечка данных из будущего завысит точность.

Python — Правильное разделение временного ряда
# Split: 70% train, 20% val, 10% test
n = len(X)
train_idx = int(n * 0.7)
val_idx = int(n * 0.9)
X_train, y_train = X[:train_idx], y[:train_idx]
X_val, y_val = X[train_idx:val_idx], y[train_idx:val_idx]
X_test, y_test = X[val_idx:], y[val_idx:]

Цикл обучения

Используйте бинарную кросс-энтропию и оптимизатор Adam:

Python — Обучение
model = CryptoLSTM()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
loss_fn = nn.BCELoss()
for epoch in range(100):
model.train()
optimizer.zero_grad()
preds = model(X_train_tensor)
loss = loss_fn(preds, y_train_tensor)
loss.backward()
optimizer.step()
model.eval()
with torch.no_grad():
val_preds = model(X_val_tensor)
val_loss = loss_fn(val_preds, y_val_tensor)
print(f"Epoch {epoch}: train={loss:.4f}, val={val_loss:.4f}")

Интеграция с Smart Money API

Наши ML-модели не заменяют традиционные метрики — они усиливают их. Вот как Smart Money API их объединяет:

Python — Ансамблевая оценка
def compute_confirmation_score(symbol, direction):
# 1. Получить оценку деривативов (ставка финансирования, LSR)
deriv_score = get_derivatives_score(symbol, direction)
# 2. Получить оценку ончейн-данных (MVRV, SOPR, поток на биржах)
onchain_score = get_onchain_score(symbol)
# 3. Получить оценку китов (консенсус направления, pnl)
whale_score = get_whale_score(symbol, direction)
# 4. Запустить ML-модель на признаках
features = [deriv_score, onchain_score, whale_score, volatility, volume_trend]
ml_signal = lstm_model.predict(features)
# 5. Взвешенный ансамбль
composite = (deriv_score * 0.35 + onchain_score * 0.25 + whale_score * 0.25 + ml_signal * 0.15)
return {
"composite": composite,
"confidence": classify_confidence(composite),
"components": {"deriv": deriv_score, "onchain": onchain_score, "whale"whale_score mlml_signal
}

Лучшие практики

1. Избегайте переобучения

2. Работа с дисбалансом классов

Если у вас больше дней с ростом, чем с падением, модель будет чаще предсказывать рост. Используйте взвешенную потерю:

Python — Взвешенная BCE
# Если 60% случаев — рост, случаи падения должны быть взвешены сильнее
pos_weight = (len(y_train) - y_train.sum()) / y_train.sum()
loss_fn = nn.BCEWithLogitsLoss(pos_weight=torch.tensor(pos_weight))

3. Нормализация признаков

Нейронные сети чувствительны к масштабу признаков. Всегда нормализуйте входные признаки до [0,1] или [-1,1]. Переобучите скалер только на тренировочных данных, затем примените к валидационным/тестовым.

4. Валидация с движущимся окном

Вместо одного тестового набора используйте скользящие окна: обучайтесь на данных за 1 год, тестируйте на следующий месяц, затем переобучитесь на 13 месяцев и протестируйте на 14-й месяц и т.д. Это имитирует условия реальной торговли.

5. Мониторинг реальной производительности

Точность на бэктесте никогда не равна точности в реальной торговле. Разверните свою модель, отслеживайте реальные результаты сделок и переобучайтесь ежемесячно с новыми данными. Используйте коэффициент Шарпа и процент выигрышей как реальные метрики, а не F1-оценку.

Продвинутые техники

Механизмы внимания

Трансформерные модели (например, Attention Is All You Need) позволяют вашей сети "фокусироваться" на самых важных временных точках в последовательности. Для криптовалют это помогает уделять больше внимания недавним всплескам волатильности, чем более старым данным.

Ансамблевые методы

Обучите несколько архитектур (MLP, LSTM, XGBoost) и усредните предсказания. Ансамблевые модели обычно превосходят одиночные модели на 2-5% по точности.

Обучение с подкреплением

Вместо предсказания направления цены обучите агента максимизировать совокупный PnL. Агент учится определять размер позиций на основе уверенности и рыночных условий. Это передний край ИИ в криптотрейдинге.

Примените ML с Smart Money API

Наша система составных оценок объединяет аналитику деривативов, анализ блокчейна и отслеживание китов — все готово для интеграции в ваши ML-модели в качестве дополнительных признаков. Добавьте их к входным признакам вашего LSTM и наблюдайте, как точность увеличивается на 3-5%.

Получите бесплатный API-ключ →