Machine Learning per la Generazione di Segnali Crypto

Il machine learning ha rivoluzionato il trading di criptovalute. Ciò che una volta si basava esclusivamente sull'analisi tecnica e sull'interpretazione manuale ora beneficia di reti neurali in grado di estrarre modelli da milioni di tick di prezzo, snapshot dell'order book e eventi on-chain. Questa guida esplora come costruire sistemi di conferma basati su ML per i segnali crittografici — le stesse tecniche che utilizziamo in Smart Money API per alimentare i nostri punteggi di confidenza.

Approfondimento chiave: I segnali ML funzionano meglio se combinati con metriche tradizionali. Una rete neurale che prevede la direzione del prezzo con una precisione del 52% è inutile. Ma una che conferma il momentum quando i tassi di funding sono positivi e il consenso delle balene è rialzista? Quello è un sistema con un tasso di successo superiore al 60%.

Fondamenti Matematici

Prima di immergersi nel codice, è essenziale comprendere la matematica. Ogni rete neurale è essenzialmente un approssimatore di funzioni. Dati i feature di input (prezzo, volume, tasso di funding, consenso delle balene), apprende pesi che minimizzano l'errore di previsione sui dati storici.

Il Framework di Apprendimento Supervisionato

Inizia con dati etichettati: coppie storiche prezzo/segnale.

Python — Preparazione dei Dati
# Prepara i dati supervisionati
import numpy as np
import pandas as pd
# Carica i dati OHLCV per BTC
df = pd.read_csv('btc_5m.csv')
# Feature: [open, high, low, close, volume, funding_rate, whale_long_pct]
features = df[['open', 'high', 'low', 'close', 'volume', 'fr', 'whale_long']].values
# Target: prezzo salito (1) o sceso (0) nelle prossime 5 candele
targets = (df['close'].shift(-5) > df['close']).astype(int).values
# Normalizza le feature in [0,1]
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X = scaler.fit_transform(features)

Feature Engineering per Crypto

I dati OHLCV grezzi non sono sufficienti. Servono:

La chiave è catturare l'asimmetria informativa — segnali che la maggior parte dei trader non vede. La nostra Smart Money API combina tutti e tre i livelli (derivati, on-chain, balene) in una funzionalità composita che supera qualsiasi singola metrica da sola.

Architettura della rete neurale

Perceptron Multistrato (MLP) per la classificazione

Una semplice rete feedforward funziona sorprendentemente bene per la classificazione binaria (acquisto/vendita):

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

Questa architettura ha 7 caratteristiche di input che fluiscono attraverso strati progressivamente più stretti (128 → 64 → 32 → 1), con attivazioni ReLU e dropout per la regolarizzazione. L'output sigmoide comprime lo strato finale a [0,1], rappresentando la probabilità di acquisto.

LSTM per la previsione di sequenze

Perché reti ricorrenti?

I movimenti dei prezzi non sono indipendenti — hanno memoria. Una rete LSTM (Long Short-Term Memory) può apprendere dipendenze temporali: "Se il momentum è in aumento e il funding rate è appena diventato positivo dopo 3 ore di negativi, la prossima candela di 5 minuti ha il 58% di probabilità di essere rialzista."

Python — LSTM per 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)
# Prendi l'ultimo timestep
last_hidden = lstm_out[:, -1, :]
x = torch.relu(self.fc1(last_hidden))
x = torch.sigmoid(self.fc2(x))
return x

Questo LSTM prende sequenze di 60 timestep (5 ore di candele di 5 minuti) e prevede la direzione successiva. Lo stato della cella apprende quali caratteristiche sono più importanti in diversi punti della sequenza.

Preparazione delle sequenze

Trasforma i tuoi dati piatti in finestre scorrevoli:

Python — Crea sequenze 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]) # prossimo target
return np.array(X), np.array(y)
X, y = create_sequences(X)
# X.shape: (n_samples, 60, 7)

Addestramento e valutazione

Strategia di suddivisione Train-Test

Per i dati di serie temporali, non mescolare mai. La fuga di dati futuri sovrastimerà l'accuratezza.

Python — Suddivisione corretta delle serie temporali
# 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:]

Ciclo di addestramento

Usa la perdita di entropia incrociata binaria e l'ottimizzatore Adam:

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

Integrazione con Smart Money API

I nostri modelli ML non sostituiscono le metriche tradizionali — le amplificano. Ecco come Smart Money API le combina:

Python — Punteggio ensemble
def compute_confirmation_score(symbol, direction):
# 1. Ottieni il punteggio derivati (funding rate, LSR)
deriv_score = get_derivatives_score(symbol, direction)
# 2. Ottieni il punteggio on-chain (MVRV, SOPR, exchange flow)
onchain_score = get_onchain_score(symbol)
# 3. Ottieni il punteggio whale (direzione di consenso, pnl)
whale_score = get_whale_score(symbol, direction)
# 4. Esegui il modello ML sulle caratteristiche
features = [deriv_score, onchain_score, whale_score, volatility, volume_trend]
ml_signal = lstm_model.predict(features)
# 5. Ensemble ponderato
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
}

Migliori Pratiche

1. Evita l'Overfitting

2. Gestisci lo Squilibrio delle Classi

Se hai più giorni "up" che "down", il modello predirà più spesso "up". Usa una perdita ponderata:

Python — BCE Ponderata
# Se il 60% dei casi è "up", i casi "down" dovrebbero essere ponderati maggiormente
pos_weight = (len(y_train) - y_train.sum()) / y_train.sum()
loss_fn = nn.BCEWithLogitsLoss(pos_weight=torch.tensor(pos_weight))

3. Normalizzazione delle Caratteristiche

Le reti neurali sono sensibili alla scala delle caratteristiche. Normalizza sempre le caratteristiche di input in [0,1] o [-1,1]. Ricalibra lo scaler solo sui dati di addestramento, poi applica a validazione/test.

4. Validazione Walk-Forward

Invece di un singolo set di test, usa finestre scorrevoli: addestra su 1 anno di dati, testa sul mese successivo, poi riaddestra su 13 mesi e testa sul mese 14, ecc. Questo simula le condizioni di trading live.

5. Monitora le Prestazioni nel Mondo Reale

L'accuratezza backtestata non è mai l'accuratezza live. Distribuisci il tuo modello, traccia i risultati effettivi delle operazioni e riaddestra mensilmente con nuovi dati. Usa Sharpe ratio e win rate come metriche reali, non l'F1 score.

Tecniche Avanzate

Meccanismi di Attenzione

Modelli basati su Transformer (come Attention Is All You Need) permettono alla tua rete di "concentrarsi" sui momenti più importanti in una sequenza. Per le cripto, questo aiuta a dare più peso ai picchi di volatilità recenti rispetto ai dati più vecchi.

Metodi di Ensemble

Addestra più architetture (MLP, LSTM, XGBoost) e fai la media delle previsioni. I modelli ensemble generalmente superano i modelli singoli del 2-5% in accuratezza.

Apprendimento per Rinforzo

Invece di prevedere la direzione del prezzo, addestra un agente per massimizzare il PnL cumulativo. L'agente impara a dimensionare le posizioni in base alla fiducia e alle condizioni di mercato. Questa è la frontiera dell'AI per il trading di cripto.

Metti in funzione il ML con Smart Money API

Il nostro sistema di punteggio composito combina intelligence sui derivati, analisi on-chain e tracciamento delle whale — tutto pronto per essere integrato nei tuoi modelli ML come caratteristiche aggiuntive. Aggiungili alle caratteristiche di input del tuo LSTM e osserva l'accuratezza aumentare del 3-5%.

Ottieni la Chiave API Gratuita →