Machine Learning for Crypto Signal Generation

การเรียนรู้ของเครื่องได้เปลี่ยนแปลงการเทรดคริปโตเคอเรนซีอย่างมาก สิ่งที่เคยพึ่งพาการวิเคราะห์ทางเทคนิคและการตีความด้วยมือ ตอนนี้ได้ประโยชน์จากเครือข่ายประสาทเทียมที่สามารถดึงรูปแบบจากข้อมูลราคาหลายล้านจุด, สแนปชอตสมุดคำสั่ง, และเหตุการณ์บนบล็อกเชน คู่มือนี้จะสำรวจวิธีการสร้างระบบยืนยันที่ขับเคลื่อนด้วย ML สำหรับสัญญาณคริปโตเคอเรนซี — เทคนิคเดียวกันที่เราใช้ที่ Smart Money API เพื่อสร้างคะแนนความมั่นใจของเรา

ข้อมูลเชิงลึกหลัก: สัญญาณ ML ทำงานได้ดีที่สุดเมื่อรวมกับเมตริกแบบดั้งเดิม เครือข่ายประสาทเทียมที่ทำนายทิศทางราคาได้ถูกต้อง 52% นั้นไม่มีค่า แต่เครือข่ายที่ยืนยันโมเมนตัมเมื่ออัตราเงินทุนเป็นบวกและความเห็นพ้องของวาฬเป็นขาขึ้น? นั่นคือระบบที่มีอัตราชนะมากกว่า 60%

พื้นฐานทางคณิตศาสตร์

ก่อนที่จะดำดิ่งลงไปในโค้ด ให้เข้าใจคณิตศาสตร์ก่อน ทุกเครือข่ายประสาทเทียมเป็นเครื่องมือประมาณฟังก์ชัน โดยให้คุณสมบัติอินพุต (ราคา, ปริมาณ, อัตราเงินทุน, ความเห็นพ้องของวาฬ) มันเรียนรู้น้ำหนักที่ลดข้อผิดพลาดในการทำนายข้ามข้อมูลประวัติศาสตร์

กรอบการเรียนรู้แบบมีผู้สอน

เริ่มต้นด้วยข้อมูลที่มีป้ายกำกับ: คู่ราคา/สัญญาณในอดีต

Python — การเตรียมข้อมูล
# เตรียมข้อมูลแบบมีผู้สอน
import numpy as np
import pandas as pd
# โหลดข้อมูล OHLCV สำหรับ BTC
df = pd.read_csv('btc_5m.csv')
# คุณสมบัติ: [open, high, low, close, volume, funding_rate, whale_long_pct]
features = df[['open', 'high', 'low', 'close', 'volume', 'fr', 'whale_long']].values
# เป้าหมาย: ราคาขึ้น (1) หรือลง (0) ใน 5 เทียนถัดไป
targets = (df['close'].shift(-5) > df['close']).astype(int).values
# ปรับคุณสมบัติให้อยู่ในช่วง [0,1]
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X = scaler.fit_transform(features)

การวิเคราะห์คุณสมบัติสำหรับคริปโต

ข้อมูล OHLCV ดิบไม่เพียงพอ คุณต้องการ:

กุญแจสำคัญคือการจับ ความไม่สมมาตรของข้อมูล — สัญญาณที่ผู้เทรดส่วนใหญ่ไม่เห็น Smart Money API ของเรารวมทั้งสามชั้น (อนุพันธ์, บนบล็อกเชน, วาฬ) เข้าด้วยกันเป็นคุณสมบัติแบบผสมที่ทำงานได้ดีกว่าเมตริกเดียวใดๆ

โครงสร้างเครือข่ายประสาทเทียม

Multilayer Perceptron (MLP) สำหรับการจำแนกประเภท

เครือข่ายฟีดฟอร์เวิร์ดแบบง่ายทำงานได้ดีอย่างน่าประหลาดใจสำหรับการจำแนกประเภทแบบไบนารี (ซื้อ/ขาย):

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

โครงสร้างนี้มีคุณสมบัติอินพุต 7 ตัวที่ไหลผ่านชั้นที่แคบลงเรื่อยๆ (128 → 64 → 32 → 1) โดยมี ReLU activations และ dropout สำหรับการปรับให้เป็นปกติ ผลลัพธ์ sigmoid บีบชั้นสุดท้ายให้อยู่ในช่วง [0,1] ซึ่งแสดงถึงความน่าจะเป็นในการซื้อ

LSTM สำหรับการทำนายลำดับ

ทำไมต้องใช้เครือข่ายแบบวนซ้ำ?

การเคลื่อนไหวของราคาไม่ได้เป็นอิสระต่อกัน — มันมีความจำ เครือข่าย LSTM (Long Short-Term Memory) สามารถเรียนรู้ความสัมพันธ์เชิงเวลา: "หากโมเมนตัมกำลังเพิ่มขึ้นและอัตราเงินทุนเพิ่งเปลี่ยนเป็นบวกหลังจาก 3 ชั่วโมงที่เป็นลบ เทียน 5 นาทีถัดไปมีแนวโน้ม 58% ที่จะเป็นขาขึ้น"

Python — LSTM สำหรับคริปโต
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

LSTM นี้รับลำดับของ 60 ช่วงเวลา (5 ชั่วโมงของเทียน 5 นาที) และทำนายทิศทางถัดไป สถานะเซลล์เรียนรู้ว่าคุณลักษณะใดสำคัญที่สุดในจุดต่าง ๆ ของลำดับ

การเตรียมลำดับ

แปลงข้อมูลแบบแบนของคุณเป็นหน้าต่างเลื่อน:

Python — สร้างลำดับ 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)

การฝึกและการประเมิน

กลยุทธ์การแบ่ง Train-Test

สำหรับข้อมูลอนุกรมเวลา อย่าสับเปลี่ยน. การรั่วไหลของข้อมูลในอนาคตจะทำให้ความแม่นยำสูงเกินจริง

Python — การแบ่งอนุกรมเวลาที่ถูกต้อง
# 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:]

ลูปการฝึก

ใช้การสูญเสียเอนโทรปีข้ามไบนารีและตัวปรับให้เหมาะสม Adam:

Python — การฝึก
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}")

การรวมกับ Smart Money API

โมเดล ML ของเราไม่ได้แทนที่เมตริกแบบดั้งเดิม — แต่เสริมให้แข็งแกร่งขึ้น นี่คือวิธีที่ Smart Money API รวมพวกมัน:

Python — การให้คะแนนแบบรวม
def compute_confirmation_score(symbol, direction):
# 1. รับคะแนนอนุพันธ์ (อัตราเงินทุน, LSR)
deriv_score = get_derivatives_score(symbol, direction)
# 2. รับคะแนนออนเชน (MVRV, SOPR, การไหลของแลกเปลี่ยน)
onchain_score = get_onchain_score(symbol)
# 3. รับคะแนนวาฬ (ทิศทางฉันทามติ, pnl)
whale_score = get_whale_score(symbol, direction)
# 4. เรียกใช้โมเดล ML บนคุณลักษณะ
features = [deriv_score, onchain_score, whale_score, volatility, volume_trend]
ml_signal = lstm_model.predict(features)
# 5. การรวมน้ำหนัก
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}
}

แนวปฏิบัติที่ดีที่สุด

1. หลีกเลี่ยงการโอเวอร์ฟิตติ้ง

2. จัดการกับความไม่สมดุลของคลาส

หากคุณมีวัน "ขึ้น" มากกว่าวัน "ลง" โมเดลจะทำนาย "ขึ้น" บ่อยกว่า ใช้ weighted loss:

Python — Weighted BCE
# หาก 60% ของเคสเป็น "ขึ้น" เคส "ลง" ควรมีน้ำหนักมากกว่า
pos_weight = (len(y_train) - y_train.sum()) / y_train.sum()
loss_fn = nn.BCEWithLogitsLoss(pos_weight=torch.tensor(pos_weight))

3. การปรับสเกลฟีเจอร์

โครงข่ายประสาทเทียมไวต่อสเกลของฟีเจอร์ ควรปรับสเกลอินพุตฟีเจอร์เป็น [0,1] หรือ [-1,1] เท่านั้น ทำการ fit scaler ด้วยข้อมูลฝึกเท่านั้น แล้วจึงนำไปใช้กับ validation/test

4. การตรวจสอบแบบ Walk-Forward

แทนที่จะใช้ชุดทดสอบเดียว ให้ใช้ sliding windows: ฝึกด้วยข้อมูล 1 ปี ทดสอบเดือนถัดไป แล้วฝึกใหม่ด้วยข้อมูล 13 เดือนและทดสอบเดือนที่ 14 เป็นต้น วิธีนี้จำลองสภาพการเทรดจริง

5. ตรวจสอบประสิทธิภาพในโลกจริง

ความแม่นยำจากการทดสอบย้อนหลังไม่เท่ากับความแม่นยำจริง นำโมเดลไปใช้งาน ติดตามผลการเทรดจริง และฝึกใหม่ทุกเดือนด้วยข้อมูลใหม่ ใช้ Sharpe ratio และ win rate เป็นเมตริกจริง ไม่ใช่ F1 score

เทคนิคขั้นสูง

กลไก Attention

โมเดลแบบ Transformer (เช่น Attention Is All You Need) ทำให้เครือข่าย "โฟกัส" ที่จุดเวลาสำคัญในลำดับ สำหรับคริปโต น้ำหนักจะให้ความสำคัญกับความผันผวนล่าสุดมากกว่าข้อมูลเก่า

วิธีการ Ensemble

ฝึกหลายสถาปัตยกรรม (MLP, LSTM, XGBoost) และหาค่าเฉลี่ยของการทำนาย โมเดล Ensemble มักให้ความแม่นยำสูงกว่าโมเดลเดี่ยว 2-5%

การเรียนรู้แบบเสริมแรง

แทนที่จะทำนายทิศทางราคา ฝึกเอเจนต์เพื่อเพิ่มกำไรสะสม เอเจนต์เรียนรู้การกำหนดขนาดตำแหน่งตามความมั่นใจและสภาพตลาด นี่คือแนวหน้าของ AI การเทรดคริปโต

นำ ML ไปใช้งานกับ Smart Money API

ระบบการให้คะแนนแบบรวมของเรารวมข่าวกรองอนุพันธ์ การวิเคราะห์ on-chain และการติดตามวาฬ — พร้อมบูรณาการเข้ากับโมเดล ML ของคุณเป็นฟีเจอร์เพิ่มเติม เพิ่มลงในฟีเจอร์อินพุต LSTM ของคุณและดูความแม่นยำเพิ่มขึ้น 3-5%

รับคีย์ API ฟรี →