Machine Learning untuk Penjanaan Isyarat Kripto

Pembelajaran mesin telah mengubah perdagangan kripto secara asas. Apa yang dahulunya bergantung sepenuhnya pada analisis teknikal dan tafsiran manual kini mendapat manfaat daripada rangkaian neural yang dapat mengekstrak corak daripada berjuta-juta tanda harga, snapshot buku pesanan, dan peristiwa on-chain. Panduan ini meneroka cara membina sistem pengesahan berasaskan ML untuk isyarat kripto — teknik yang sama yang kami gunakan di Smart Money API untuk menggerakkan skor keyakinan kami.

Pandangan utama: Isyarat ML berfungsi dengan terbaik apabila digabungkan dengan metrik tradisional. Rangkaian neural yang meramalkan arah harga dengan ketepatan 52% adalah tidak berguna. Tetapi satu yang mengesahkan momentum apabila kadar pembiayaan adalah positif dan konsensus ikan paus adalah bullish? Itu adalah sistem dengan kadar kemenangan 60%+.

Asas Matematik

Sebelum menyelami kod, fahami matematiknya. Setiap rangkaian neural pada dasarnya adalah penghampiran fungsi. Dengan ciri input (harga, volum, kadar pembiayaan, konsensus ikan paus), ia mempelajari berat yang meminimumkan ralat ramalan merentasi data sejarah.

Rangka Kerja Pembelajaran Berpandu

Mulakan dengan data berlabel: pasangan harga/isyarat sejarah.

Python — Penyediaan Data
# Sediakan data berpandu
import numpy as np
import pandas as pd
# Muat data OHLCV untuk BTC
df = pd.read_csv('btc_5m.csv')
# Ciri: [open, high, low, close, volume, funding_rate, whale_long_pct]
features = df[['open', 'high', 'low', 'close', 'volume', 'fr', 'whale_long']].values
# Sasaran: harga bergerak naik (1) atau turun (0) dalam 5 lilin seterusnya
targets = (df['close'].shift(-5) > df['close']).astype(int).values
# Normalisasi ciri kepada [0,1]
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X = scaler.fit_transform(features)

Kejuruteraan Ciri untuk Kripto

Data OHLCV mentah tidak mencukupi. Anda perlu:

Kuncinya adalah menangkap asimetri maklumat — isyarat yang tidak dilihat oleh majoriti pedagang. Smart Money API kami menggabungkan ketiga-tiga lapisan (derivatif, on-chain, ikan paus) menjadi satu ciri komposit yang mengatasi mana-mana metrik tunggal sahaja.

Seni Bina Rangkaian Neural

Multilayer Perceptron (MLP) untuk Pengelasan

Rangkaian suapan ke hadapan yang mudah berfungsi dengan baik untuk pengelasan binari (beli/jual):

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

Seni bina ini mempunyai 7 ciri input yang mengalir melalui lapisan yang semakin sempit (128 → 64 → 32 → 1), dengan pengaktifan ReLU dan dropout untuk pengawalseliaan. Output sigmoid memampatkan lapisan akhir ke [0,1], mewakili kebarangkalian beli.

LSTM untuk Ramalan Urutan

Mengapa Rangkaian Berulang?

Pergerakan harga tidak bebas — ia mempunyai memori. Rangkaian LSTM (Long Short-Term Memory) boleh mempelajari kebergantungan temporal: "Jika momentum meningkat dan kadar pembiayaan baru sahaja bertukar positif selepas 3 jam negatif, lilin 5 minit seterusnya mempunyai 58% kemungkinan untuk menjadi bullish."

Python — LSTM untuk 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)
# Ambil langkah masa terakhir
last_hidden = lstm_out[:, -1, :]
x = torch.relu(self.fc1(last_hidden))
x = torch.sigmoid(self.fc2(x))
return x

LSTM ini mengambil urutan 60 langkah masa (5 jam lilin 5 minit) dan meramalkan arah seterusnya. Keadaan sel mempelajari ciri mana yang paling penting pada titik yang berbeza dalam urutan.

Penyediaan Urutan

Ubah data rata anda kepada tetingkap gelongsor:

Python — Cipta Urutan 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]) # sasaran seterusnya
return np.array(X), np.array(y)
X, y = create_sequences(X)
# X.shape: (n_samples, 60, 7)

Latihan dan Penilaian

Strategi Pembahagian Latihan-Ujian

Untuk data siri masa, jangan sesekali mengacak. Kebocoran data masa depan akan melebihkan ketepatan.

Python — Pembahagian siri masa yang betul
# Bahagian: 70% latihan, 20% val, 10% ujian
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:]

Gelung Latihan

Gunakan kerugian entropi silang binari dan pengoptimum Adam:

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

Integrasi dengan Smart Money API

Model ML kami tidak menggantikan metrik tradisional — ia menguatkannya. Berikut adalah cara Smart Money API menggabungkannya:

Python — Penilaian Ensemble
def compute_confirmation_score(symbol, direction):
# 1. Dapatkan skor derivatif (kadar pembiayaan, LSR)
deriv_score = get_derivatives_score(symbol, direction)
# 2. Dapatkan skor on-chain (MVRV, SOPR, aliran pertukaran)
onchain_score = get_onchain_score(symbol)
# 3. Dapatkan skor ikan paus (arah konsensus, pnl)
whale_score = get_whale_score(symbol, direction)
# 4. Jalankan model ML pada ciri
features = [deriv_score, onchain_score, whale_score, volatility, volume_trend]
ml_signal = lstm_model.predict(features)
# 5. Ensemble berwajaran
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}
}

Amalan Terbaik

1. Elakkan Overfitting

2. Urus Ketidakseimbangan Kelas

Jika anda mempunyai lebih banyak hari "naik" berbanding hari "turun", model akan lebih kerap meramal naik. Gunakan kerugian berwajaran:

Python — Weighted BCE
# Jika 60% kes adalah naik, kes turun harus diberi berat lebih
pos_weight = (len(y_train) - y_train.sum()) / y_train.sum()
loss_fn = nn.BCEWithLogitsLoss(pos_weight=torch.tensor(pos_weight))

3. Penormalan Ciri

Rangkaian neural sensitif kepada skala ciri. Sentiasa menormalkan ciri input kepada [0,1] atau [-1,1]. Sesuaikan semula scaler pada data latihan sahaja, kemudian aplikasikan kepada pengesahan/ujian.

4. Pengesahan Walk-Forward

Daripada set ujian tunggal, gunakan tetingkap gelongsor: latih pada data 1 tahun, uji pada bulan berikutnya, kemudian latih semula pada 13 bulan dan uji pada bulan ke-14, dan sebagainya. Ini mensimulasikan keadaan dagangan langsung.

5. Pantau Prestasi Dunia Sebenar

Ketepatan ujian belakang tidak sama dengan ketepatan langsung. Gunakan model anda, jejaki hasil dagangan sebenar, dan latih semula setiap bulan dengan data baru. Gunakan Sharpe ratio dan kadar kemenangan sebagai metrik sebenar anda, bukan skor F1.

Teknik Lanjutan

Mekanisme Perhatian

Model berasaskan Transformer (seperti Attention Is All You Need) membolehkan rangkaian anda "fokus" pada titik masa paling penting dalam urutan. Untuk kripto, ini membantu memberi berat lebih tinggi kepada lonjakan turun naik terkini berbanding data lama.

Kaedah Ensemble

Latih pelbagai seni bina (MLP, LSTM, XGBoost) dan puratakan ramalan. Model ensemble biasanya mengatasi model tunggal dengan ketepatan 2-5%.

Pembelajaran Pengukuhan

Daripada meramal arah harga, latih ejen untuk memaksimumkan PnL kumulatif. Ejen belajar untuk menyesuaikan saiz posisi berdasarkan keyakinan dan keadaan pasaran. Ini adalah hadapan AI dagangan kripto.

Gunakan ML dengan Smart Money API

Sistem pemarkahan komposit kami menggabungkan kecerdasan derivatif, analisis on-chain, dan penjejakan ikan paus — semua sedia untuk diintegrasikan ke dalam model ML anda sebagai ciri tambahan. Tambahkan mereka kepada ciri input LSTM anda dan lihat ketepatan meningkat 3-5%.

Dapatkan Kunci API Percuma →