Machine Learning dla generowania sygnałów kryptowalutowych

Uczenie maszynowe zrewolucjonizowało handel kryptowalutami. To, co kiedyś opierało się wyłącznie na analizie technicznej i manualnej interpretacji, teraz korzysta z sieci neuronowych, które potrafią wyodrębnić wzorce z milionów ticków cenowych, migawek order book i zdarzeń on-chain. Ten przewodnik pokazuje, jak budować systemy potwierdzenia oparte na ML dla sygnałów kryptowalutowych — te same techniki, których używamy w Smart Money API do generowania naszych wskaźników pewności.

Kluczowa wskazówka: Sygnały ML działają najlepiej w połączeniu z tradycyjnymi metrykami. Sieć neuronowa przewidująca kierunek ceny z dokładnością 52% jest bezużyteczna. Ale taka, która potwierdza momentum, gdy stawki fundingowe są dodatnie, a konsensus wielorybów jest byczy? To system z wskaźnikiem wygranych powyżej 60%.

Podstawy matematyczne

Zanim przejdziesz do kodu, zrozum matematykę. Każda sieć neuronowa to w zasadzie aproksymator funkcji. Dla danych wejściowych (cena, wolumen, stopa fundingowa, konsensus wielorybów) uczy się wag, które minimalizują błąd predykcji na danych historycznych.

Framework uczenia nadzorowanego

Zacznij od oznaczonych danych: historycznych par cena/sygnał.

Python — Przygotowanie danych
# Przygotuj dane nadzorowane
import numpy as np
import pandas as pd
# Załaduj dane OHLCV dla BTC
df = pd.read_csv('btc_5m.csv')
# Cechy: [open, high, low, close, volume, funding_rate, whale_long_pct]
features = df[['open', 'high', 'low', 'close', 'volume', 'fr', 'whale_long']].values
# Cel: cena poszła w górę (1) lub w dół (0) w ciągu następnych 5 świec
targets = (df['close'].shift(-5) > df['close']).astype(int).values
# Normalizuj cechy do [0,1]
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X = scaler.fit_transform(features)

Inżynieria cech dla kryptowalut

Surowe dane OHLCV nie wystarczą. Potrzebujesz:

Kluczowe jest uchwycenie asymetrii informacji — sygnałów, których większość traderów nie widzi. Nasz Smart Money API łączy wszystkie trzy warstwy (instrumenty pochodne, on-chain, wieloryby) w jedną cechę złożoną, która przewyższa każdą pojedynczą metrykę.

Architektura sieci neuronowej

Wielowarstwowy perceptron (MLP) do klasyfikacji

Prosta sieć feedforward działa zaskakująco dobrze dla klasyfikacji binarnej (kup/sprzedaj):

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

Ta architektura ma 7 cech wejściowych przepływających przez kolejno zawężające się warstwy (128 → 64 → 32 → 1), z aktywacjami ReLU i dropoutem dla regularyzacji. Wyjście sigmoidalne sprowadza ostatnią warstwę do zakresu [0,1], reprezentując prawdopodobieństwo kupna.

LSTM do przewidywania sekwencji

Dlaczego sieci rekurencyjne?

Ruchy cen nie są niezależne — mają pamięć. Sieć LSTM (Long Short-Term Memory) może uczyć się zależności czasowych: "Jeśli momentum rośnie, a stopa finansowania właśnie zmieniła się na dodatnią po 3 godzinach ujemnych, następna 5-minutowa świeca ma 58% szans na bycie byczą."

Python — LSTM dla kryptowalut
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

Ten LSTM przyjmuje sekwencje 60 kroków czasowych (5 godzin 5-minutowych świec) i przewiduje następny kierunek. Stan komórki uczy się, które cechy są najważniejsze w różnych punktach sekwencji.

Przygotowanie sekwencji

Przekształć swoje płaskie dane w przesuwające się okna:

Python — Tworzenie sekwencji 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)

Trening i ewaluacja

Strategia podziału na zbiór treningowy i testowy

Dla danych szeregów czasowych, nigdy nie mieszaj. Wyciek danych z przyszłości zawyży dokładność.

Python — Właściwy podział szeregów czasowych
# 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:]

Pętla treningowa

Użyj straty binary cross-entropy i optymalizatora Adam:

Python — Trening
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}")

Integracja z Smart Money API

Nasze modele ML nie zastępują tradycyjnych metryk — wzmacniają je. Oto jak Smart Money API je łączy:

Python — Ocena zespołowa
def compute_confirmation_score(symbol, direction):
# 1. Pobierz wynik instrumentów pochodnych (stopa finansowania, LSR)
deriv_score = get_derivatives_score(symbol, direction)
# 2. Pobierz wynik on-chain (MVRV, SOPR, przepływ wymiany)
onchain_score = get_onchain_score(symbol)
# 3. Pobierz wynik wielorybów (konsensus kierunku, pnl)
whale_score = get_whale_score(symbol, direction)
# 4. Uruchom model ML na cechach
features = [deriv_score, onchain_score, whale_score, volatility, volume_trend]
ml_signal = lstm_model.predict(features)
# 5. Zespół ważony
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, "ml": ml_signal}
}

Najlepsze praktyki

1. Unikaj przeuczenia

2. Radzenie sobie z nierównowagą klas

Jeśli masz więcej dni "w górę" niż "w dół", model będzie częściej przewidywał wzrost. Użyj ważonej straty:

Python — Wważona BCE
# Jeśli 60% przypadków to wzrost, przypadki spadku powinny być bardziej obciążone
pos_weight = (len(y_train) - y_train.sum()) / y_train.sum()
loss_fn = nn.BCEWithLogitsLoss(pos_weight=torch.tensor(pos_weight))

3. Normalizacja cech

Sieci neuronowe są wrażliwe na skalę cech. Zawsze normalizuj cechy wejściowe do zakresu [0,1] lub [-1,1]. Dopasuj skalę tylko na danych treningowych, a następnie zastosuj do walidacji/testu.

4. Walidacja krocząca

Zamiast pojedynczego zestawu testowego użyj przesuwających się okien: trenuj na danych z 1 roku, testuj na kolejnym miesiącu, następnie przetrenuj na 13 miesiącach i testuj na 14 miesiącu, itd. Symuluje to warunki rzeczywistego handlu.

5. Monitoruj wydajność w rzeczywistych warunkach

Dokładność backtestu nigdy nie jest dokładnością na żywo. Wdróż swój model, śledź rzeczywiste wyniki transakcji i przetrenuj co miesiąc z nowymi danymi. Użyj współczynnika Sharpe'a i wskaźnika wygranych jako rzeczywistych metryk, a nie F1.

Zaawansowane techniki

Mechanizmy uwagi

Modele oparte na transformatorach (jak Attention Is All You Need) pozwalają sieci "skupić" na najważniejszych punktach czasowych w sekwencji. W przypadku kryptowalut pomaga to nadać większą wagę niedawnym skokom zmienności niż starszym danym.

Metody zespołowe

Trenuj wiele architektur (MLP, LSTM, XGBoost) i uśredniaj przewidywania. Modele zespołowe zazwyczaj przewyższają pojedyncze modele o 2-5% dokładności.

Uczenie przez wzmacnianie

Zamiast przewidywać kierunek ceny, wytrenuj agenta, aby maksymalizował skumulowany PnL. Agent uczy się dobierać wielkość pozycji na podstawie pewności siebie i warunków rynkowych. To jest przyszłość AI w handlu kryptowalutami.

Wykorzystaj ML z Smart Money API

Nasz złożony system oceny łączy inteligencję instrumentów pochodnych, analizę on-chain i śledzenie wielorybów — wszystko gotowe do integracji z Twoimi modelami ML jako dodatkowe cechy. Dodaj je do cech wejściowych LSTM i obserwuj wzrost dokładności o 3-5%.

Zdobyć darmowy klucz API →