Machine Learning for Crypto Signal Generation

למידת מכונה שינתה באופן מהותי את המסחר בקריפטו. מה שבעבר הסתמך רק על ניתוח טכני ופרשנות ידנית, נהנה כעת מרשתות עצביות שיכולות לחלץ דפוסים ממיליוני טיקים של מחירים, צילומי מסך של ספר הזמנות ואירועים על השרשרת. מדריך זה בוחן כיצד לבנות מערכות אישור מונעות ML לאיתותי קריפטו — אותן טכניקות שאנו משתמשים בהן ב-Smart Money API כדי להפעיל את ציוני הביטחון שלנו.

תובנה מרכזית: איתותי ML עובדים בצורה הטובה ביותר כאשר הם משולבים עם מדדים מסורתיים. רשת עצבית המנבאת כיוון מחיר עם דיוק של 52% היא חסרת ערך. אבל אחת שמאשרת מומנטום כאשר שיעורי המימון חיוביים והקונצנזוס של הלווייתנים הוא בוליש? זו מערכת עם שיעור ניצחון של 60%+.

יסודות מתמטיים

לפני שצוללים לקוד, חשוב להבין את המתמטיקה. כל רשת עצבית היא בעצם מקרב פונקציות. בהינתן תכונות קלט (מחיר, נפח, שיעור מימון, קונצנזוס לווייתנים), היא לומדת משקולות שממזערות את שגיאת החיזוי על פני נתונים היסטוריים.

מסגרת למידה מונחית

התחל עם נתונים מתויגים: זוגות מחיר/איתות היסטוריים.

Python — הכנת נתונים
# Prepare supervised data
import numpy as np
import pandas as pd
# Load OHLCV data for BTC
df = pd.read_csv('btc_5m.csv')
# Features: [open, high, low, close, volume, funding_rate, whale_long_pct]
features = df[['open', 'high', 'low', 'close', 'volume', 'fr', 'whale_long']].values
# Target: price moved up (1) or down (0) in next 5 candles
targets = (df['close'].shift(-5) > df['close']).astype(int).values
# Normalize features to [0,1]
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X = scaler.fit_transform(features)

הנדסת תכונות עבור קריפטו

נתוני OHLCV גולמיים אינם מספיקים. אתה צריך:

המפתח הוא לכידת אסימטריה במידע — אותות שרוב הסוחרים לא רואים. ה-Smart Money API שלנו משלב את כל שלושת השכבות (נגזרים, on-chain, לווייתנים) לתכונה מורכבת שמשיגה ביצועים טובים יותר מכל מדד בודד.

ארכיטקטורת רשת עצבית

רב-שכבה תפיסה (MLP) לסיווג

רשת feedforward פשוטה עובדת בצורה מפתיעה לטובה לסיווג בינארי (קנה/מכור):

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 לרגולריזציה. הפלט הסיגמואידי דוחס את השכבה האחרונה ל-[0,1], המייצג הסתברות לקנייה.

LSTM לחיזוי רצפים

למה רשתות רקורנטיות?

תנועות מחירים אינן בלתי תלויות — יש להן זיכרון. רשת LSTM (Long Short-Term Memory) יכולה ללמוד תלות טמפורלית: "אם המומנטום עולה ושיעור המימון הפך לחיובי לאחר 3 שעות של שליליים, יש סבירות של 58% שהנר הבא של 5 דקות יהיה בולשי."

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)

אימון והערכה

אסטרטגיית פיצול אימון-מבחן

עבור נתוני סדרות זמן, לעולם אל תערבב. דליפת נתונים עתידית תגזים את הדיוק.

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:]

לולאת אימון

השתמש בפונקציית אובדן 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 — ניקוד אנסמבל
def compute_confirmation_score(symbol, direction):
# 1. קבל ניקוד נגזרות (שיעור מימון, LSR)
deriv_score = get_derivatives_score(symbol, direction)
# 2. קבל ניקוד on-chain (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. התמודדות עם חוסר איזון במחלקות

אם יש לכם יותר ימים "עולים" מאשר ימים "יורדים", המודל יחזק יותר תחזיות עולות. השתמשו בהפסד משוקלל:

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. אימות בהליכה קדימה

במקום מערך בדיקה יחיד, השתמשו בחלונות הזזה: אימנו על נתונים של שנה, בדקו על החודש הבא, ואז אימנו מחדש על 13 חודשים ובדקו על חודש 14, וכו'. זה מדמה תנאי מסחר חיים.

5. מעקב אחר ביצועים בעולם האמיתי

דיוק בבדיקה לאחור לעולם אינו דיוק חי. פרוסו את המודל שלכם, עקבו אחר תוצאות מסחר בפועל, ואימנו מחדש מדי חודש עם נתונים חדשים. השתמשו במנת שרפ וב שיעור ניצחונות כמדדים האמיתיים שלכם, לא בציון F1.

טכניקות מתקדמות

מנגנוני קשב

מודלים מבוססי טרנספורמר (כמו Attention Is All You Need) מאפשרים לרשת שלכם "להתמקד" בנקודות הזמן החשובות ביותר ברצף. עבור קריפטו, זה עוזר לתת משקל גבוה יותר לספייקים האחרונים בתנודתיות מאשר לנתונים ישנים יותר.

שיטות אנסמבל

אימנו מספר ארכיטקטורות (MLP, LSTM, XGBoost) וחשבו ממוצע של תחזיות. מודלי אנסמבל בדרך כלל עולים על מודלים בודדים ב-2-5% בדיוק.

למידת חיזוק

במקום לחזות כיוון מחיר, אימנו סוכן למקסם רווח מצטבר PnL. הסוכן לומד לכוון גודל עמדות על סמך ביטחון ותנאי שוק. זהו החזית של בינה מלאכותית למסחר בקריפטו.

הפעילו למידת מכונה עם Smart Money API

מערכת הניקוד המורכבת שלנו משלבת מודיעין נגזרים, ניתוח על-שרשרת ומעקב אחר לווייתנים — כולם מוכנים לשילוב במודלי הלמידה שלכם כמאפיינים נוספים. הוסיפו אותם למאפייני הקלט של ה-LSTM שלכם וצפו בדיוק קופץ ב-3-5%.

קבלו מפתח API בחינם →