Machine Learning a kripto jelgeneráláshoz

A gépi tanulás alapvetően átalakította a kriptovaluta kereskedést. Ami korábban kizárólag technikai elemzésre és kézi értelmezésre támaszkodott, ma már profitál a neurális hálózatoktól, amelyek képesek mintázatokat kinyerni milliónyi ártick-ből, rendelési könyv pillanatképekből és on-chain eseményekből. Ez a útmutató bemutatja, hogyan építhető ML-alapú megerősítő rendszer kriptovaluta jelekhez — ugyanazokat a technikákat alkalmazva, mint amit a Smart Money API használ a bizalmi pontszámaink meghatározásához.

Kulcsfontosságú betekintés: Az ML jelek a legjobban akkor működnek, ha hagyományos metrikákkal kombinálják őket. Egy neurális hálózat, amely 52%-os pontossággal jósolja meg az ár irányát, értéktelen. De amely megerősíti a lendületet, amikor a finanszírozási ráta pozitív és a bálnák konszenzusa emelkedő? Ez egy 60%+-os nyerési arányú rendszer.

Matematikai alapok

Mielőtt belemerülnénk a kódba, értsük meg a matematikát. Minden neurális hálózat lényegében egy függvényközelítő. Adott bemeneti jellemzők (ár, volumen, finanszírozási ráta, bálnák konszenzusa) esetén olyan súlyokat tanul meg, amelyek minimalizálják a predikciós hibát a történelmi adatokon.

A felügyelt tanulás keretrendszere

Kezdj a címkézett adatokkal: történelmi ár/jel párokkal.

Python — Adatelőkészítés
# Felügyelt adatok előkészítése
import numpy as np
import pandas as pd
# BTC OHLCV adatok betöltése
df = pd.read_csv('btc_5m.csv')
# Jellemzők: [nyitó, magas, alacsony, záró, volumen, finanszírozási_ráta, bálnák_hosszú_százalék]
features = df[['open', 'high', 'low', 'close', 'volume', 'fr', 'whale_long']].values
# Cél: az ár emelkedett (1) vagy csökkent (0) a következő 5 gyertyán
targets = (df['close'].shift(-5) > df['close']).astype(int).values
# Jellemzők normalizálása [0,1] tartományba
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X = scaler.fit_transform(features)

Jellemzőtervezés kriptóhoz

A nyers OHLCV adatok nem elegendőek. Szükséges:

A kulcs az információs aszimmetria megragadása — jelek, amelyeket a kereskedők többsége nem lát. Smart Money API-nk mindhárom réteget (derivatívák, on-chain, bálnák) egyetlen összetett jellé kombinálja, amely jobb teljesítményt nyújt, mint bármely egyetlen metrika önmagában.

Neurális háló architektúra

Többrétegű perceptron (MLP) osztályozáshoz

Egy egyszerű előrejelző hálózat meglepően jól működik bináris osztályozáshoz (vétel/eladás):

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

Ez az architektúra 7 bemeneti jellemzőt használ, amelyek fokozatosan szűkülő rétegeken (128 → 64 → 32 → 1) haladnak át, ReLU aktivációs függvénnyel és dropout regularizációval. A szigmoid kimenet a végső réteget [0,1] intervallumba préseli, ami a vételi valószínűséget reprezentálja.

LSTM szekvencia-előrejelzéshez

Miért rekurrens hálózatok?

Az ármozgások nem függetlenek – memóriával rendelkeznek. Egy LSTM (Long Short-Term Memory) hálózat megtanulhatja az időbeli összefüggéseket: „Ha a lendület növekszik és a finanszírozási ráta épp pozitívra vált 3 óra negatív után, akkor 58% esély van arra, hogy a következő 5 perces gyorska emelkedő lesz.”

Python – LSTM kriptovalutákhoz
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 alak: (batch, seq_len, features)
lstm_out, _ = self.lstm(x)
# Utolsó időlépés kiválasztása
last_hidden = lstm_out[:, -1, :]
x = torch.relu(self.fc1(last_hidden))
x = torch.sigmoid(self.fc2(x))
return x

Ez az LSTM 60 időlépésből álló szekvenciákat vesz fel (5 óra 5 perces gyorskákat), és megjósolja a következő irányt. A cellaállapot megtanulja, hogy mely jellemzők a legfontosabbak a szekvencia különböző pontjain.

Szekvencia előkészítése

Alakítsd át a lapos adataid csúszó ablakokká:

Python – LSTM szekvenciák létrehozása
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]) # következő célérték
return np.array(X), np.array(y)
X, y = create_sequences(X)
# X.shape: (n_samples, 60, 7)

Tanítás és értékelés

Tanító-teszt felosztási stratégia

Idősor adatok esetén soha ne keverjük össze. A jövőbeli adatszivárgás túlbecsülné a pontosságot.

Python – Helyes idősor felosztás
# Felosztás: 70% tanító, 20% validációs, 10% teszt
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:]

Tanítási ciklus

Használj bináris kereszt-entrópia veszteséget és Adam optimalizálót:

Python – Tanítás
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}")

Integráció a Smart Money API-val

A gépi tanulási modelljeink nem helyettesítik a hagyományos metrikákat – hanem felerősítik őket. Így kombinálja őket a Smart Money API:

Python – Együttes pontozás
def compute_confirmation_score(symbol, direction):
# 1. Derivált pontszám lekérése (finanszírozási ráta, LSR)
deriv_score = get_derivatives_score(symbol, direction)
# 2. On-chain pontszám lekérése (MVRV, SOPR, tőzsdei áramlás)
onchain_score = get_onchain_score(symbol)
# 3. Bálna pontszám lekérése (konszenzus irány, pnl)
whale_score = get_whale_score(symbol, direction)
# 4. ML modell futtatása a jellemzőkön
features = [deriv_score, onchain_score, whale_score, volatility, volume_trend]
ml_signal = lstm_model.predict(features)
# 5. Súlyozott együttes
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
}

Legjobb gyakorlatok

1. Kerüld a túlilleszkedést

2. Kezeld az osztályegyensúlyt

Ha több "fel" napod van, mint "le" napod, a modell gyakrabban fog fel irányt jelezni. Használj súlyozott veszteséget:

Python — Súlyozott BCE
# Ha az esetek 60%-a fel irányú, a le eseteket nehezebben kell súlyozni
pos_weight = (len(y_train) - y_train.sum()) / y_train.sum()
loss_fn = nn.BCEWithLogitsLoss(pos_weight=torch.tensor(pos_weight))

3. Jellemző normalizálás

A neurális hálózatok érzékenyek a jellemzők skálájára. Mindig normalizáld a bemeneti jellemzőket [0,1] vagy [-1,1] tartományba. Csak a tanítási adatokon újraillesztett skálát alkalmazd a validációs/tesz adatokra.

4. Haladó validáció

Egyetlen tesztkészlet helyett használj csúszó ablakokat: taníts 1 év adatain, tesztelj a következő hónapon, majd újra taníts 13 hónapon és tesztelj a 14. hónapon, stb. Ez szimulálja az élő kereskedési feltételeket.

5. Figyeld a valós teljesítményt

A visszatesztelt pontosság sosem egyezik meg az élő pontossággal. Telepítsd a modelledet, kövesd a tényleges kereskedési eredményeket, és havonta újra tanítsd új adatokkal. Használd Sharpe arányt és nyerési arányt valós metrikákként, ne az F1 pontszámot.

Haladó technikák

Figyelemmechanizmusok

A transzformátor alapú modellek (mint az Attention Is All You Need) lehetővé teszik, hogy a hálózatod "összpontosítson" a sorozat legfontosabb időpontjaira. A kriptó esetében ez segít a friss volatilitási csúcsok nagyobb súlyozásában a régebbi adatokhoz képest.

Együttes módszerek

Taníts több architektúrát (MLP, LSTM, XGBoost) és átlagold a predikciókat. Az együttes modellek általában 2-5%-kal jobb pontosságot érnek el, mint az egyedi modellek.

Megerősítéses tanulás

Ahelyett, hogy az ár irányát jeleznéd, taníts egy ügynököt a kumulatív PnL maximalizálására. Az ügynök megtanulja a pozíciók méretezését a bizalom és a piaci feltételek alapján. Ez a kriptókereskedelem AI-jának határa.

Helyezd az ML-t munkába a Smart Money API-val

Összetett pontozási rendszerünk kombinálja a derivatív intelligenciát, a láncon belüli elemzést és a bálnakövetést — mind készen áll az ML modelljeidbe integrálásra további jellemzőkként. Add hozzá őket az LSTM bemeneti jellemzőidhez és figyeld, hogyan ugrik a pontosság 3-5%-kal.

Szerezz ingyenes API kulcsot →