Machine Learning pentru Generarea de Semnale Crypto

Machine learning a transformat fundamental tranzacționarea de criptomonede. Ceea ce se baza odată doar pe analiza tehnică și interpretarea manuală beneficiază acum de rețele neuronale care pot extrage modele din milioane de tick-uri de preț, instantanee ale cărții de comenzi și evenimente on-chain. Acest ghid explorează cum să construiești sisteme de confirmare bazate pe ML pentru semnalele cripto — aceleași tehnici pe care le folosim la Smart Money API pentru a alimenta scorurile noastre de încredere.

Idee cheie: Semnalele ML funcționează cel mai bine atunci când sunt combinate cu metrici tradiționale. O rețea neuronală care prezice direcția prețului cu o acuratețe de 52% este inutilă. Dar una care confirmă impulsul când ratele de finanțare sunt pozitive și consensul balenelor este optimist? Acesta este un sistem cu o rată de câștig de peste 60%.

Fundamente Matematice

Înainte de a te arunca în cod, înțelege matematica. Fiecare rețea neuronală este în esență un aproximator de funcții. Având în vedere caracteristicile de intrare (preț, volum, rata de finanțare, consensul balenelor), învață ponderi care minimizează eroarea de predicție pe datele istorice.

Cadrul de Învățare Supravegheată

Începe cu date etichetate: perechi istorice preț/semnal.

Python — Pregătirea Datelor
# Pregătește date supravegheate
import numpy as np
import pandas as pd
# Încarcă date OHLCV pentru BTC
df = pd.read_csv('btc_5m.csv')
# Caracteristici: [open, high, low, close, volume, funding_rate, whale_long_pct]
features = df[['open', 'high', 'low', 'close', 'volume', 'fr', 'whale_long']].values
# Țintă: prețul a crescut (1) sau a scăzut (0) în următoarele 5 lumânări
targets = (df['close'].shift(-5) > df['close']).astype(int).values
# Normalizează caracteristicile la [0,1]
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X = scaler.fit_transform(features)

Inginerie de Caracteristici pentru Crypto

Datele OHLCV brute nu sunt suficiente. Ai nevoie de:

Cheia este captarea asimetriei informaționale — semnale pe care majoritatea comercianților nu le văd. Smart Money API combină toate cele trei straturi (derivate, on-chain, balene) într-o caracteristică compusă care depășește orice metrică individuală.

Arhitectura Rețelei Neuronale

Perceptron Multistrat (MLP) pentru Clasificare

O rețea feedforward simplă funcționează surprinzător de bine pentru clasificarea binară (cumpărare/vânzare):

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

Această arhitectură are 7 caracteristici de intrare care curg prin straturi progresiv înguste (128 → 64 → 32 → 1), cu activări ReLU și dropout pentru regularizare. Ieșirea sigmoidă comprimă stratul final la [0,1], reprezentând probabilitatea de cumpărare.

LSTM pentru Predicția Secvențelor

De ce Rețele Recurrente?

Mișcările prețurilor nu sunt independente — ele au memorie. O rețea LSTM (Long Short-Term Memory) poate învăța dependențe temporale: „Dacă impulsul crește și rata de finanțare tocmai s-a întors pozitivă după 3 ore de valori negative, următoarea lumânare de 5 minute are 58% șanse să fie bullish.”

Python — LSTM pentru Crypto
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

Acest LSTM preia secvențe de 60 de intervale de timp (5 ore de lumânări de 5 minute) și prezice următoarea direcție. Starea celulei învață care caracteristici contează cel mai mult în diferite puncte ale secvenței.

Pregătirea Secvențelor

Transformă datele tale plate în ferestre glisante:

Python — Crează secvențe 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)

Antrenare și Evaluare

Strategie de Împărțire Train-Test

Pentru date de serie temporală, nu amesteca. Scurgerea de date viitoare va supraestima acuratețea.

Python — Împărțire corectă a seriei temporale
# 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:]

Bucla de Antrenare

Folosește pierdere de entropie binară și optimizator Adam:

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

Integrare cu Smart Money API

Modelele noastre ML nu înlocuiesc metricile tradiționale — le amplifică. Iată cum le combină Smart Money API:

Python — Scor de ansamblu
def compute_confirmation_score(symbol, direction):
# 1. Obține scorul derivatelor (rata de finanțare, LSR)
deriv_score = get_derivatives_score(symbol, direction)
# 2. Obține scorul on-chain (MVRV, SOPR, fluxul de exchange)
onchain_score = get_onchain_score(symbol)
# 3. Obține scorul balenelor (direcția de consens, pnl)
whale_score = get_whale_score(symbol, direction)
# 4. Rulează modelul ML pe caracteristici
features = [deriv_score, onchain_score, whale_score, volatility, volume_trend]
ml_signal = lstm_model.predict(features)
# 5. Ansamblu ponderat
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}
}

Cele mai bune practici

1. Evitați supraadaptarea

2. Gestionați dezechilibrul claselor

Dacă aveți mai multe zile "în creștere" decât "în scădere", modelul va prezice mai des creșteri. Utilizați pierdere ponderată:

Python — BCE ponderat
# Dacă 60% din cazuri sunt în creștere, cazurile în scădere ar trebui să aibă o pondere mai mare
pos_weight = (len(y_train) - y_train.sum()) / y_train.sum()
loss_fn = nn.BCEWithLogitsLoss(pos_weight=torch.tensor(pos_weight))

3. Normalizarea caracteristicilor

Rețelele neuronale sunt sensibile la scara caracteristicilor. Normalizați întotdeauna caracteristicile de intrare la [0,1] sau [-1,1]. Reajustați scalarea doar pe datele de antrenament, apoi aplicați la validare/test.

4. Validare Walk-Forward

În loc de un singur set de test, utilizați ferestre glisante: antrenați pe date de 1 an, testați pe luna următoare, apoi reantrenați pe 13 luni și testați pe luna 14, etc. Acest lucru simulează condițiile de tranzacționare live.

5. Monitorizați performanța în lumea reală

Acuratețea backtestată nu este niciodată acuratețea live. Implementați modelul, urmăriți rezultatele reale ale tranzacțiilor și reantrenați lunar cu date noi. Utilizați raportul Sharpe și rata de câștig ca metrici reale, nu scorul F1.

Tehnici avansate

Mecanisme de atenție

Modelele bazate pe Transformers (cum ar fi "Attention Is All You Need") permit rețelei voastre să se "concentreze" pe cele mai importante puncte de timp dintr-o secvență. Pentru crypto, acest lucru ajută la ponderarea mai mare a spike-urilor recente de volatilitate decât a datelor mai vechi.

Metode de ansamblu

Antrenați mai multe arhitecturi (MLP, LSTM, XGBoost) și mediați predicțiile. Modelele de ansamblu depășesc de obicei modelele individuale cu 2-5% în acuratețe.

Învățare prin întărire

În loc să prezică direcția prețului, antrenați un agent să maximizeze PnL cumulativ. Agentul învață să dimensioneze pozițiile în funcție de încredere și condiții de piață. Aceasta este frontiera AI-ului în tranzacționarea crypto.

Puneți ML la lucru cu Smart Money API

Sistemul nostru compozit de scor combină informații din derivate, analiză on-chain și urmărire a balenelor — toate gata de integrat în modelele voastre ML ca caracteristici suplimentare. Adăugați-le la caracteristicile de intrare LSTM și urmăriți cum acuratețea crește cu 3-5%.

Obțineți cheie API gratuită →