Machine Learning for Crypto Signal Generation

ម៉ាស៊ីនសិក្សាបានផ្លាស់ប្តូរយ៉ាងជាមូលដ្ឋាននូវការធ្វើជំនួញគ្រីបតូ។ អ្វីដែលពីមុនពឹងផ្អែកទាំងស្រុងលើការវិភាគបច្ចេកទេស និងការបកស្រាយដោយដៃ ឥឡូវនេះទទួលបានអត្ថប្រយោជន៍ពីបណ្តាញប្រព័ន្ធប្រសព្វដែលអាចទាញយកលំនាំពីលានគ្រាប់តម្លៃ រូបថតសៀវភៅកម្មវិធី និងព្រឹត្តិការណ៍នៅលើខ្សែ។ មគ្គុទេសក៍នេះស្វែងយល់អំពីរបៀបបង្កើតប្រព័ន្ធបញ្ជាក់ដែលដឹកនាំដោយម៉ាស៊ីនសម្រាប់សញ្ញាគ្រីបតូ — បច្ចេកទេសដូចគ្នាដែលយើងប្រើនៅ 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 និង dropout សម្រាប់ការធ្វើឱ្យទៀងទាត់។ លទ្ធផល sigmoid បង្ហាប់ស្រទាប់ចុងក្រោយទៅ [0,1] ដែលតំណាងឱ្យប្រូបាប៊ីលីតេទិញ។

LSTM សម្រាប់ការព្យាករលំដាប់

ហេតុអ្វីបណ្តាញដែលដដែលៗ?

ចលនាតម្លៃមិនឯករាជ្យពីគ្នាទៅវិញទៅមកទេ — ពួកវាមានអង្គចងចាំ។ បណ្តាញ LSTM (អង្គចងចាំរយៈពេលខ្លីវែង) អាចរៀនពីការពឹងផ្អែកលើពេលវេលា៖ "ប្រសិនបើសន្ទុះកំពុងកើនឡើង ហើយអត្រាការផ្តល់មូលនិធិទើបតែបត់ជាវិជ្ជមានបន្ទាប់ពី 3 ម៉ោងនៃអវិជ្ជមាន ទង់ 5 នាទីបន្ទាប់មានលទ្ធភាព 58% ដែលនឹងកើនឡើង។"

Python — LSTM សម្រាប់ 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)
# យកពេលវេលាចុងក្រោយ
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]) # គោលដៅបន្ទាប់
return np.array(X), np.array(y)
X, y = create_sequences(X)
# X.shape: (n_samples, 60, 7)

ការបណ្តុះបណ្តាល និងការវាយតម្លៃ

យុទ្ធសាស្ត្របែងចែក Train-Test

សម្រាប់ទិន្នន័យស៊េរីពេលវេលា, កុំច្របូកច្របល់។ ការរសាត់ទិន្នន័យអនាគតនឹងបង្កើនភាពត្រឹមត្រូវ។

Python — ការបែងចែកស៊េរីពេលវេលាត្រឹមត្រូវ
# បែងចែក៖ 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:]

វដ្តបណ្តុះបណ្តាល

ប្រើការខាតបង់ cross-entropy គោលពីរ និងឧបករណ៍បម្រើ 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 — ពិន្ទុ Ensemble
def compute_confirmation_score(symbol, direction):
# 1. ទទួលពិន្ទុ derivatives (អត្រាការផ្តល់មូលនិធិ, LSR)
deriv_score = get_derivatives_score(symbol, direction)
# 2. ទទួលពិន្ទុ on-chain (MVRV, SOPR, ចរន្តផ្លាស់ប្តូរ)
onchain_score = get_onchain_score(symbol)
# 3. ទទួលពិន្ទុ whale (ទិសដៅឯកភាព, 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. Ensemble មានទម្ងន់
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. ដោះស្រាយភាពមិនសមមូលថ្នាក់

ប្រសិនបើអ្នកមានថ្ងៃ "ឡើង" ច្រើនជាងថ្ងៃ "ចុះ" ម៉ូដែលនឹងទស្សន៍ទាយឡើងញឹកញាប់ជាង។ ប្រើការខាតបង់ដែលមានទម្ងន់៖

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]។ កែសម្រួលស្កេលែលឡើងវិញលើទិន្នន័យបណ្តុះបណ្តាលតែប៉ុណ្ណោះ បន្ទាប់មកអនុវត្តចំពោះសុពលភាព/តេស្ត។

4. ការផ្ទៀងផ្ទាត់ដោយដំណើរការទៅមុខ

ជំនួសឱ្យការកំណត់តេស្តតែមួយ ប្រើបង្អួចរអិល៖ បណ្តុះបណ្តាលលើទិន្នន័យ 1-ឆ្នាំ ធ្វើតេស្តលើខែបន្ទាប់ បន្ទាប់មកបណ្តុះបណ្តាលឡើងវិញលើ 13 ខែ ហើយធ្វើតេស្តលើខែទី 14 ជាដើម។ វាធ្វើឱ្យមានលក្ខណៈស្រដៀងនឹងលក្ខខណ្ឌពាណិជ្ជកម្មផ្ទាល់។

5. តាមដានដំណើរការពិតប្រាកដ

ភាពត្រឹមត្រូវនៃការធ្វើតេស្តថយក្រោយមិនដែលដូចភាពត្រឹមត្រូវផ្ទាល់នោះទេ។ ដាក់ឱ្យដំណើរការម៉ូដែលរបស់អ្នក តាមដានលទ្ធផលពាណិជ្ជកម្មពិតប្រាកដ និងបណ្តុះបណ្តាលឡើងវិញរៀងរាល់ខែជាមួយទិន្នន័យថ្មី។ ប្រើ Sharpe ratio និង អត្រាឈ្នះ ជាម៉ែត្រពិតប្រាកដរបស់អ្នក មិនមែនពិន្ទុ F1 នោះទេ។

បច្ចេកទេសកម្រិតខ្ពស់

មេកានិចយកចិត្តទុកដាក់

ម៉ូដែលផ្អែកលើ Transformer (ដូចជា Attention Is All You Need) អនុញ្ញាតឱ្យបណ្តាញរបស់អ្នក "ផ្តោត" លើពេលវេលាដ៏សំខាន់បំផុតក្នុងលំដាប់។ ចំពោះគ្រីបតូ វាជួយឱ្យមានទម្ងន់ខ្លាំងជាងលើការប្រែប្រួលថ្មីៗជាងទិន្នន័យចាស់។

វិធីសាស្រ្តរួម

បណ្តុះបណ្តាលស្ថាបត្យកម្មច្រើន (MLP, LSTM, XGBoost) និងមធ្យមនៃការទស្សន៍ទាយ។ ម៉ូដែលរួមធម្មតាល្អជាងម៉ូដែលតែមួយដោយភាពត្រឹមត្រូវ 2-5%។

ការរៀនដោយការពង្រឹង

ជំនួសឱ្យការទស្សន៍ទាយទិសដៅតម្លៃ បណ្តុះបណ្តាលភ្នាក់ងារដើម្បីធ្វើឱ្យប្រាក់ចំណេញសរុបអតិបរមា។ ភ្នាក់ងាររៀនកំណត់ទំហំតាមភាពជឿជាក់និងលក្ខខណ្ឌទីផ្សារ។ នេះគឺជាព្រំដែននៃ AI ពាណិជ្ជកម្មគ្រីបតូ។

ដាក់ ML ឱ្យធ្វើការជាមួយ Smart Money API

ប្រព័ន្ធពិន្ទុរួមរបស់យើងរួមបញ្ចូលគុណវុឌ្ឍិនិយម derivatives ការវិភាគ on-chain និងការតាមដាន whale — ទាំងអស់រួចរាល់ដើម្បីបញ្ចូលទៅក្នុងម៉ូដែល ML របស់អ្នកជាលក្ខណៈបន្ថែម។ បន្ថែមវាទៅលក្ខណៈបញ្ចូល LSTM របស់អ្នក ហើយមើលភាពត្រឹមត្រូវកើនឡើង 3-5%។

ទទួលកូនសោ API ឥតគិតថ្លៃ →