Machine Learning untuk Generasi Sinyal Crypto

Machine learning telah mengubah secara fundamental trading cryptocurrency. Apa yang dulu hanya mengandalkan analisis teknis dan interpretasi manual, sekarang mendapatkan manfaat dari neural networks yang dapat mengekstrak pola dari jutaan tick harga, snapshot order book, dan peristiwa on-chain. Panduan ini mengeksplorasi cara membangun sistem konfirmasi berbasis ML untuk sinyal cryptocurrency — teknik yang sama yang kami gunakan di Smart Money API untuk menggerakkan skor kepercayaan kami.

Poin kunci: Sinyal ML bekerja paling baik ketika dikombinasikan dengan metrik tradisional. Neural network yang memprediksi arah harga dengan akurasi 52% tidak berguna. Tetapi yang mengkonfirmasi momentum ketika funding rate positif dan konsensus whale bullish? Itu adalah sistem dengan win rate 60%+.

Dasar Matematis

Sebelum menyelami kode, pahami matematikanya. Setiap neural network pada dasarnya adalah pendekat fungsi. Dengan fitur input (harga, volume, funding rate, konsensus whale), ia mempelajari bobot yang meminimalkan kesalahan prediksi di seluruh data historis.

Kerangka Pembelajaran Terawasi

Mulai dengan data berlabel: pasangan harga/sinyal historis.

Python — Persiapan Data
# Siapkan data terawasi
import numpy as np
import pandas as pd
# Muat data OHLCV untuk BTC
df = pd.read_csv('btc_5m.csv')
# Fitur: [open, high, low, close, volume, funding_rate, whale_long_pct]
features = df[['open', 'high', 'low', 'close', 'volume', 'fr', 'whale_long']].values
# Target: harga naik (1) atau turun (0) dalam 5 candle berikutnya
targets = (df['close'].shift(-5) > df['close']).astype(int).values
# Normalisasi fitur ke [0,1]
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X = scaler.fit_transform(features)

Rekayasa Fitur untuk Crypto

Data OHLCV mentah tidak cukup. Anda membutuhkan:

Kuncinya adalah menangkap asimetri informasi — sinyal yang tidak dilihat oleh mayoritas trader. Smart Money API kami menggabungkan ketiga lapisan (derivatif, on-chain, paus) menjadi fitur komposit yang mengungguli metrik tunggal mana pun.

Arsitektur Jaringan Saraf

Multilayer Perceptron (MLP) untuk Klasifikasi

Jaringan feedforward sederhana bekerja dengan sangat baik untuk klasifikasi biner (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

Arsitektur ini memiliki 7 fitur input yang mengalir melalui lapisan yang semakin menyempit (128 → 64 → 32 → 1), dengan aktivasi ReLU dan dropout untuk regularisasi. Output sigmoid memampatkan lapisan akhir ke [0,1], mewakili probabilitas beli.

LSTM untuk Prediksi Urutan

Mengapa Jaringan Recurrent?

Pergerakan harga tidak independen — mereka memiliki memori. Jaringan LSTM (Long Short-Term Memory) dapat mempelajari ketergantungan temporal: "Jika momentum naik dan tingkat pendanaan baru saja berubah positif setelah 3 jam negatif, lilin 5 menit berikutnya memiliki kemungkinan 58% untuk 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 waktu 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 waktu (5 jam lilin 5 menit) dan memprediksi arah berikutnya. Status sel mempelajari fitur mana yang paling penting pada titik berbeda dalam urutan.

Persiapan Urutan

Ubah data datar Anda menjadi jendela geser:

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

Pelatihan dan Evaluasi

Strategi Pembagian Train-Test

Untuk data deret waktu, jangan diacak. Kebocoran data masa depan akan melebih-lebihkan akurasi.

Python — Pembagian deret waktu yang tepat
# 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:]

Loop Pelatihan

Gunakan kerugian entropi silang biner dan pengoptimal Adam:

Python — Pelatihan
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 — mereka memperkuatnya. Berikut cara Smart Money API menggabungkannya:

Python — Skor Ensemble
def compute_confirmation_score(symbol, direction):
# 1. Dapatkan skor derivatif (tingkat pendanaan, 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 paus (arah konsensus, pnl)
whale_score = get_whale_score(symbol, direction)
# 4. Jalankan model ML pada fitur
features = [deriv_score, onchain_score, whale_score, volatility, volume_trend]
ml_signal = lstm_model.predict(features)
# 5. Ensemble berbobot
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}
}

Best Practices

1. Hindari Overfitting

2. Tangani Ketidakseimbangan Kelas

Jika Anda memiliki lebih banyak hari "naik" daripada hari "turun", model akan lebih sering memprediksi naik. Gunakan weighted loss:

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

3. Normalisasi Fitur

Neural network sensitif terhadap skala fitur. Selalu normalisasikan fitur input ke [0,1] atau [-1,1]. Sesuaikan scaler hanya pada data pelatihan, lalu terapkan ke validation/test.

4. Walk-Forward Validation

Alih-alih menggunakan satu set test, gunakan sliding windows: latih pada data 1 tahun, uji pada bulan berikutnya, lalu latih ulang pada 13 bulan dan uji pada bulan ke-14, dst. Ini mensimulasikan kondisi trading live.

5. Pantau Kinerja Dunia Nyata

Akurasi backtest tidak pernah sama dengan akurasi live. Terapkan model Anda, lacak hasil trading aktual, dan latih ulang setiap bulan dengan data baru. Gunakan Sharpe ratio dan win rate sebagai metrik nyata, bukan F1 score.

Advanced Techniques

Attention Mechanisms

Model berbasis Transformer (seperti Attention Is All You Need) memungkinkan jaringan Anda "fokus" pada timepoints terpenting dalam suatu urutan. Untuk crypto, ini membantu memberi bobot lebih tinggi pada lonjakan volatilitas terbaru dibanding data lama.

Ensemble Methods

Latih beberapa arsitektur (MLP, LSTM, XGBoost) dan rata-ratakan prediksi. Model ensemble biasanya mengungguli model tunggal dengan akurasi 2-5%.

Reinforcement Learning

Alih-alih memprediksi arah harga, latih agen untuk memaksimalkan PnL kumulatif. Agen belajar menyesuaikan ukuran posisi berdasarkan kepercayaan diri dan kondisi pasar. Ini adalah frontier AI untuk trading crypto.

Manfaatkan ML dengan Smart Money API

Sistem skor komposit kami menggabungkan intelijen derivatif, analisis on-chain, dan pelacakan whale — siap diintegrasikan ke model ML Anda sebagai fitur tambahan. Tambahkan ke fitur input LSTM Anda dan saksikan akurasi melonjak 3-5%.

Dapatkan Free API Key →