Machine Learning pro generování krypto signálů

Machine learning zásadně změnil obchodování s kryptoměnami. Co bylo dříve závislé pouze na technické analýze a manuální interpretaci, nyní těží z neuronových sítí, které dokážou extrahovat vzory z milionů cenových tiků, snímků order booku a on-chain událostí. Tato příručka vysvětluje, jak vytvořit ML-driven potvrzovací systémy pro krypto signály — stejné techniky, které používáme v Smart Money API pro naše confidence skóre.

Klíčový poznatek: ML signály fungují nejlépe v kombinaci s tradičními metrikami. Neuronová síť předpovídající směr ceny s 52% přesností je k ničemu. Ale ta, která potvrzuje momentum, když jsou funding rates pozitivní a whale consensus býčí? To je systém s úspěšností přes 60%.

Matematické základy

Než se pustíte do kódu, pochopte matematiku. Každá neuronová síť je v podstatě aproximátor funkcí. Na základě vstupních parametrů (cena, objem, funding rate, whale consensus) se učí váhy, které minimalizují chybu predikce napříč historickými daty.

Framework Supervised Learning

Začněte s označenými daty: historické páry cena/signál.

Python — Příprava dat
# Příprava supervised dat
import numpy as np
import pandas as pd
# Načtení OHLCV dat pro BTC
df = pd.read_csv('btc_5m.csv')
# Features: [open, high, low, close, volume, funding_rate, whale_long_pct]
features = df[['open', 'high', 'low', 'close', 'volume', 'fr', 'whale_long']].values
# Target: cena se zvýšila (1) nebo snížila (0) v následujících 5 svících
targets = (df['close'].shift(-5) > df['close']).astype(int).values
# Normalizace features na [0,1]
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X = scaler.fit_transform(features)

Feature Engineering pro krypto

Pouhá OHLCV data nestačí. Potřebujete:

Klíčem je zachycení informační asymetrie — signály, které většina obchodníků nevidí. Naše Smart Money API kombinuje všechny tři vrstvy (deriváty, on-chain, velryby) do jedné složené funkce, která překonává jakýkoli jednotlivý metrik sám o sobě.

Architektura neuronové sítě

Vícevrstvý perceptron (MLP) pro klasifikaci

Jednoduchá dopředná síť překvapivě dobře funguje pro binární klasifikaci (nákup/prodej):

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

Tato architektura má 7 vstupních prvků, které procházejí postupně se zužujícími vrstvami (128 → 64 → 32 → 1), s ReLU aktivacemi a dropoutem pro regularizaci. Sigmoidový výstup stlačuje finální vrstvu do rozsahu [0,1], reprezentující pravděpodobnost nákupu.

LSTM pro predikci sekvencí

Proč rekurentní sítě?

Cenové pohyby nejsou nezávislé – mají paměť. LSTM (Long Short-Term Memory) síť dokáže naučit časové závislosti: „Pokud roste momentum a funding rate se právě změnil na pozitivní po 3 hodinách negativních hodnot, je další 5minutová svíčka s 58% pravděpodobností býčí.“

Python – LSTM pro kryptoměny
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

Tato LSTM přijímá sekvence 60 časových kroků (5 hodin 5minutových svíček) a předpovídá další směr. Stav buňky se učí, které vlastnosti jsou v různých bodech sekvence nejdůležitější.

Příprava sekvencí

Transformujte plochá data do posuvných oken:

Python – Vytvoření LSTM sekvencí
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)

Trénování a evaluace

Strategie rozdělení na trénovací a testovací data

Pro časové řady, nikdy nemíchejte. Únik budoucích dat by nadhodnotil přesnost.

Python – Správné rozdělení časové řady
# 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:]

Trénovací smyčka

Použijte binární cross-entropy loss a Adam optimizer:

Python – Trénování
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}")

Integrace se Smart Money API

Naše ML modely nenahrazují tradiční metriky – zesilují je. Zde je návod, jak je Smart Money API kombinuje:

Python – Skóre ensemble
def compute_confirmation_score(symbol, direction):
# 1. Získat skóre derivátů (funding rate, LSR)
deriv_score = get_derivatives_score(symbol, direction)
# 2. Získat on-chain skóre (MVRV, SOPR, exchange flow)
onchain_score = get_onchain_score(symbol)
# 3. Získat skóre velryb (konsenzuální směr, pnl)
whale_score = get_whale_score(symbol, direction)
# 4. Spustit ML model na vlastnostech
features = [deriv_score, onchain_score, whale_score, volatility, volume_trend]
ml_signal = lstm_model.predict(features)
# 5. Vážený ensemble
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}
}

Osvědčené postupy

1. Vyhněte se přetrénování

2. Řešení nerovnováhy tříd

Pokud máte více "up" dní než "down" dní, model bude častěji předpovídat růst. Použijte váženou ztrátu:

Python — Vážená BCE
# Pokud 60 % případů jsou "up", "down" případy by měly mít vyšší váhu
pos_weight = (len(y_train) - y_train.sum()) / y_train.sum()
loss_fn = nn.BCEWithLogitsLoss(pos_weight=torch.tensor(pos_weight))

3. Normalizace příznaků

Neuronové sítě jsou citlivé na škálu příznaků. Vždy normalizujte vstupní příznaky na rozsah [0,1] nebo [-1,1]. Normalizaci přizpůsobte pouze na trénovacích datech a poté aplikujte na validační/testovací data.

4. Validace postupným posouváním

Namísto jedné testovací sady použijte posuvná okna: trénujte na datech za 1 rok, testujte na následujícím měsíci, poté znovu trénujte na 13 měsících a testujte na 14. měsíci atd. Tím simulujete podmínky reálného obchodování.

5. Sledování výkonu v reálném světě

Přesnost na historických datech nikdy není stejná jako v reálném obchodování. Nasazujte svůj model, sledujte skutečné výsledky obchodů a měsíčně přetrénovávejte s novými daty. Používejte Sharpeho poměr a úspěšnost obchodů jako reálné metriky, nikoli F1 skóre.

Pokročilé techniky

Mechanismy pozornosti

Modely založené na transformérech (jako Attention Is All You Need) umožňují vaší síti "zaměřit se" na nejdůležitější časové body v sekvenci. U kryptoměn to pomáhá dát větší váhu nedávným výkyvům volatility než starším datům.

Ensemble metody

Trénujte více architektur (MLP, LSTM, XGBoost) a průměrujte jejich předpovědi. Ensemble modely obvykle překonají jednotlivé modely o 2-5 % v přesnosti.

Učení posilováním

Namísto předpovídání směru ceny trénujte agenta, aby maximalizoval kumulativní PnL. Agent se naučí velikost pozic na základě důvěry a tržních podmínek. Toto je špička v oblasti AI pro obchodování s kryptoměnami.

Využijte ML s Smart Money API

Náš kompozitní systém skóre kombinuje inteligenci derivátů, on-chain analýzu a sledování velryb — vše připravené k integraci do vašich ML modelů jako další příznaky. Přidejte je ke vstupním příznakům vašeho LSTM a sledujte, jak přesnost vzroste o 3-5 %.

Získejte bezplatný API klíč →