Machine Learning für die Generierung von Krypto-Signalen

Machine Learning hat den Kryptowährungshandel grundlegend verändert. Was früher rein auf technischer Analyse und manueller Interpretation basierte, profitiert heute von neuronalen Netzen, die Muster aus Millionen von Preis-Ticks, Orderbuch-Snapshots und On-Chain-Ereignissen extrahieren können. Dieser Leitfaden untersucht, wie man ML-gesteuerte Bestätigungssysteme für Krypto-Signale aufbaut — die gleichen Techniken, die wir bei Smart Money API für unsere Confidence Scores verwenden.

Wesentliche Erkenntnis: ML-Signale funktionieren am besten in Kombination mit traditionellen Metriken. Ein neuronales Netz, das die Preisrichtung mit 52% Genauigkeit vorhersagt, ist wertlos. Aber eines, das den Momentum bestätigt, wenn die Funding Rates positiv sind und der Wal-Konsens bullish ist? Das ist ein System mit einer Gewinnrate von über 60%.

Mathematische Grundlagen

Bevor Sie mit dem Code beginnen, verstehen Sie die Mathematik. Jedes neuronale Netz ist im Wesentlichen ein Funktionsapproximator. Bei gegebenen Eingabemerkmalen (Preis, Volumen, Funding Rate, Wal-Konsens) lernt es Gewichte, die den Vorhersagefehler über historische Daten minimieren.

Das überwachte Lernframework

Beginnen Sie mit gelabelten Daten: historische Preis/Signal-Paare.

Python — Datenvorbereitung
# Überwachte Daten vorbereiten
import numpy as np
import pandas as pd
# OHLCV-Daten für BTC laden
df = pd.read_csv('btc_5m.csv')
# Merkmale: [open, high, low, close, volume, funding_rate, whale_long_pct]
features = df[['open', 'high', 'low', 'close', 'volume', 'fr', 'whale_long']].values
# Ziel: Preis bewegte sich in den nächsten 5 Kerzen nach oben (1) oder unten (0)
targets = (df['close'].shift(-5) > df['close']).astype(int).values
# Merkmale auf [0,1] normalisieren
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X = scaler.fit_transform(features)

Feature-Engineering für Krypto

Roh-OLHCV-Daten reichen nicht aus. Sie benötigen:

Der Schlüssel liegt darin, die Informationsasymmetrie — Signale, die die Mehrheit der Händler nicht sieht. Unsere Smart Money API kombiniert alle drei Ebenen (Derivate, On-Chain, Wale) zu einem zusammengesetzten Feature, das jede einzelne Metrik übertrifft.

Neuronale Netzwerkarchitektur

Multilayer Perceptron (MLP) für Klassifikation

Ein einfaches Feedforward-Netzwerk funktioniert überraschend gut für binäre Klassifikation (Kaufen/Verkaufen):

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

Diese Architektur hat 7 Eingabemerkmale, die durch progressiv schmaler werdende Schichten fließen (128 → 64 → 32 → 1), mit ReLU-Aktivierungen und Dropout zur Regularisierung. Die Sigmoid-Ausgabe komprimiert die letzte Schicht auf [0,1], was die Kaufwahrscheinlichkeit darstellt.

LSTM für Sequenzvorhersage

Warum rekurrente Netze?

Preisbewegungen sind nicht unabhängig – sie haben ein Gedächtnis. Ein LSTM-Netzwerk (Long Short-Term Memory) kann zeitliche Abhängigkeiten lernen: "Wenn der Momentum steigt und der Funding Rate nach 3 Stunden Negativität gerade positiv wurde, ist die nächste 5-Minuten-Kerze mit 58% Wahrscheinlichkeit bullisch."

Python – LSTM für Krypto
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

Dieses LSTM nimmt Sequenzen von 60 Zeitschritten (5 Stunden mit 5-Minuten-Kerzen) und sagt die nächste Richtung voraus. Der Zellzustand lernt, welche Merkmale zu verschiedenen Zeitpunkten der Sequenz am wichtigsten sind.

Sequenzvorbereitung

Transformieren Sie Ihre flachen Daten in gleitende Fenster:

Python – LSTM-Sequenzen erstellen
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)

Training und Auswertung

Train-Test-Split-Strategie

Für Zeitreihendaten, niemals shuffeln. Zukünftige Datenlecks würden die Genauigkeit überbewerten.

Python – Korrekter Zeitreihen-Split
# 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:]

Trainingsschleife

Verwenden Sie den binären Kreuzentropieverlust und den Adam-Optimierer:

Python – Training
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}")

Integration mit Smart Money API

Unsere ML-Modelle ersetzen keine traditionellen Metriken – sie verstärken sie. So kombiniert Smart Money API sie:

Python – Ensemble-Bewertung
def compute_confirmation_score(symbol, direction):
# 1. Get derivatives score (funding rate, LSR)
deriv_score = get_derivatives_score(symbol, direction)
# 2. Get on-chain score (MVRV, SOPR, exchange flow)
onchain_score = get_onchain_score(symbol)
# 3. Get whale score (consensus direction, pnl)
whale_score = get_whale_score(symbol, direction)
# 4. Run ML model on features
features = [deriv_score, onchain_score, whale_score, volatility, volume_trend]
ml_signal = lstm_model.predict(features)
# 5. Weighted 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 mlml_signal
}

Best Practices

1. Vermeiden Sie Overfitting

2. Umgang mit Klassenungleichgewicht

Wenn Sie mehr „Aufwärts“- als „Abwärts“-Tage haben, wird das Modell häufiger Aufwärts vorhersagen. Verwenden Sie gewichteten Verlust:

Python – Gewichtete BCE
# Wenn 60% der Fälle Aufwärts sind, sollten Abwärts-Fälle stärker gewichtet werden
pos_weight = (len(y_train) - y_train.sum()) / y_train.sum()
loss_fn = nn.BCEWithLogitsLoss(pos_weight=torch.tensor(pos_weight))

3. Feature-Normalisierung

Neuronale Netze sind empfindlich gegenüber der Skalierung der Features. Normalisieren Sie die Eingabefeatures immer auf [0,1] oder [-1,1]. Passen Sie den Skalierer nur an die Trainingsdaten an und wenden Sie ihn dann auf die Validierungs-/Testdaten an.

4. Walk-Forward-Validierung

Verwenden Sie anstelle eines einzelnen Testsets gleitende Fenster: Trainieren Sie mit 1-Jahres-Daten, testen Sie im nächsten Monat, trainieren Sie dann mit 13 Monaten und testen Sie im 14. Monat usw. Dies simuliert Live-Handelsbedingungen.

5. Überwachen Sie die Leistung in der realen Welt

Die Backtest-Genauigkeit entspricht nie der Live-Genauigkeit. Stellen Sie Ihr Modell bereit, verfolgen Sie die tatsächlichen Handelsergebnisse und trainieren Sie monatlich mit neuen Daten neu. Verwenden Sie Sharpe-Ratio und Gewinnrate als Ihre realen Metriken, nicht den F1-Score.

Fortgeschrittene Techniken

Aufmerksamkeitsmechanismen

Transformer-basierte Modelle (wie Attention Is All You Need) lassen Ihr Netzwerk auf die wichtigsten Zeitpunkte in einer Sequenz „fokussieren“. Für Krypto hilft dies, aktuelle Volatilitätsspitzen höher zu gewichten als ältere Daten.

Ensemble-Methoden

Trainieren Sie mehrere Architekturen (MLP, LSTM, XGBoost) und mitteln Sie die Vorhersagen. Ensemble-Modelle übertreffen Einzelmodelle typischerweise um 2-5% Genauigkeit.

Bestärkendes Lernen

Anstatt die Preisrichtung vorherzusagen, trainieren Sie einen Agenten, um den kumulativen PnL zu maximieren. Der Agent lernt, Positionen basierend auf Vertrauen und Marktbedingungen zu skalieren. Dies ist die Grenze der Krypto-Handels-KI.

Setzen Sie ML mit der Smart Money API ein

Unser zusammengesetztes Bewertungssystem kombiniert Derivate-Intelligenz, On-Chain-Analyse und Walverfolgung – alles bereit zur Integration in Ihre ML-Modelle als zusätzliche Features. Fügen Sie sie Ihren LSTM-Eingabefeatures hinzu und beobachten Sie, wie die Genauigkeit um 3-5% steigt.

Holen Sie sich den kostenlosen API-Schlüssel →