கிரிப்டோ சிக்னல் ஜெனரேஷனுக்கான மெஷின் லர்னிங்

மெஷின் லர்னிங் கிரிப்டோகரன்சி டிரேடிங்கை அடிப்படையாக மாற்றியுள்ளது. முன்பு தொழில்நுட்ப பகுப்பாய்வு மற்றும் கைமுறை விளக்கத்தை மட்டுமே நம்பியிருந்தது, இப்போது மில்லியன் கணக்கான விலை டிக்ஸ், ஆர்டர் புக் ஸ்னாப்ஷாட்கள் மற்றும் ஆன்-செயின் நிகழ்வுகளிலிருந்து வடிவங்களை பிரித்தெடுக்கும் நியூரல் நெட்வர்க்ஸ் பயன்படுத்தப்படுகிறது. இந்த வழிகாட்டி கிரிப்டோகரன்சி சிக்னல்களுக்கான ML-ஓட்டிய உறுதிப்படுத்தல் அமைப்புகளை எவ்வாறு உருவாக்குவது என்பதை ஆராய்கிறது — ஸ்மார்ட் மனி API இல் நமது நம்பிக்கை மதிப்பெண்களை சக்தியாக்கும் அதே நுட்பங்கள்.

முக்கிய நுண்ணறிவு: ML சிக்னல்கள் பாரம்பரிய மெட்ரிக்ஸுடன் இணைக்கப்படும்போது சிறப்பாக செயல்படுகின்றன. 52% துல்லியத்துடன் விலை திசையை கணிக்கும் ஒரு நியூரல் நெட்வர்க் பயனற்றது. ஆனால் நிதியளிப்பு விகிதங்கள் நேர்மறையாக இருக்கும்போது மற்றும் திமிங்கல கருத்து புல்லிஷ் ஆக இருக்கும்போது உந்தத்தை உறுதிப்படுத்தும் ஒன்று? அது 60%+ வெற்றி விகித அமைப்பு.

கணித அடிப்படைகள்

குறியீட்டில் முழுகுவதற்கு முன், கணிதத்தை புரிந்து கொள்ளுங்கள். ஒவ்வொரு நியூரல் நெட்வர்க்கும் அடிப்படையில் ஒரு செயல்பாட்டு தோராயமாகும். உள்ளீட்டு அம்சங்கள் (விலை, தொகுதி, நிதியளிப்பு விகிதம், திமிங்கல கருத்து) கொடுக்கப்பட்டால், வரலாற்று தரவுகளில் கணிப்பு பிழையை குறைக்கும் எடைகளை அது கற்றுக்கொள்கிறது.

கண்காணிக்கப்பட்ட கற்றல் கட்டமைப்பு

லேபிள்ட் தரவுடன் தொடங்குங்கள்: வரலாற்று விலை/சிக்னல் ஜோடிகள்.

பைதான் — தரவு தயாரிப்பு
# கண்காணிக்கப்பட்ட தரவை தயாரிக்கவும்
உள்ளேறு நம்பை np
உள்ளேறு பாண்டாஸ் pd
# BTC க்கான OHLCV தரவை ஏற்றவும்
df = pd.read_csv('btc_5m.csv')
# அம்சங்கள்: [திறப்பு, உயர், தாழ், மூடல், தொகுதி, நிதியளிப்பு_விகிதம், திமிங்கல_நீண்ட_பிசி]
features = df[['திறப்பு', 'உயர்', 'தாழ்', 'மூடல்', 'தொகுதி', 'fr', 'திமிங்கல_நீண்ட']].values
# இலக்கு: அடுத்த 5 மெழுகுவர்த்திகளில் விலை உயர்ந்தது (1) அல்லது குறைந்தது (0)
targets = (df['மூடல்'].shift(-5) > df['மூடல்']).astype(int).values
# அம்சங்களை [0,1] க்கு இயல்பாக்கவும்
இருந்து sklearn.preprocessing உள்ளேறு MinMaxScaler
scaler = MinMaxScaler()
X = scaler.fit_transform(features)

கிரிப்டோவுக்கான அம்சம் பொறியியல்

மூல OHLCV தரவு போதாது. உங்களுக்கு தேவை:

முக்கியமானது பிடிப்பது தகவல் சமச்சீரின்மை — பெரும்பாலான வர்த்தகர்கள் பார்க்காத சிக்னல்கள். எங்கள் ஸ்மார்ட் மனி API மூன்று அடுக்குகளையும் (டெரிவேடிவ்ஸ், ஆன்-செயின், திமிங்கல்கள்) ஒரு கூட்டு அம்சமாக இணைக்கிறது, இது எந்த ஒரு மெட்ரிக் மட்டும் தனியாக செயல்படுவதை விட சிறப்பாக செயல்படுகிறது.

நியூரல் நெட்வர்க் கட்டமைப்பு

வகைப்படுத்தலுக்கான மல்டிலேயர் பெர்செப்ட்ரான் (MLP)

ஒரு எளிய ஃபீட்ஃபார்வர்ட் நெட்வர்க் பைனரி வகைப்படுத்தலுக்கு (வாங்கு/விற்கு) ஆச்சரியப்படும் வகையில் நன்றாக செயல்படுகிறது:

பைதான் — பைடார்ச் MLP
உள்ளேறு டார்ச்
உள்ளேறு டார்ச்.என்.என் ஆக என்.என்
வகுப்பு கிரிப்டோMLP(என்.என்.மாட்யூல்):
def __init__(சுய, input_size=7):
சூப்பர்().__init__()
சுய.fc1 = என்.என்.லீனியர்(input_size, 128)
சுய.fc2 = என்.என்.லீனியர்(128, 64)
சுய.fc3 = என்.என்.லீனியர்(64, 32)
சுய.fc4 = என்.என்.லீனியர்(32, 1)
சுய.dropout = என்.என்.டிராப்அவுட்(0.3)
def முன்னோக்கி(சுய, x):
x = டார்ச்.ரெலு(சுய.fc1(x))
x = சுய.dropout(x)
x = டார்ச்.ரெலு(சுய.fc2(x))
x = சுய.dropout(x)
x = டார்ச்.ரெலு(சுய.fc3(x))
x = டார்ச்.சிக்மாய்டு(சுய.fc4(x))
திரும்ப x

இந்த கட்டமைப்பு 7 உள்ளீட்டு அம்சங்களை முறையே குறுகிய அடுக்குகள் (128 → 64 → 32 → 1) மூலம் பாய்ச்சுகிறது, ரெலு செயல்பாடுகள் மற்றும் டிராப்அவுட் ஒழுங்குபடுத்தலுடன். சிக்மாய்டு வெளியீடு இறுதி அடுக்கை [0,1] க்கு அழுத்துகிறது, வாங்குவதற்கான நிகழ்தகவை குறிக்கிறது.

LSTM for Sequence Prediction

Why Recurrent Networks?

Price movements aren't independent — they have memory. An LSTM (Long Short-Term Memory) network can learn temporal dependencies: "If momentum is rising and funding rate just flipped positive after 3 hours of negatives, the next 5-minute candle is 58% likely to be bullish."

Python — LSTM for 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)
# Take last timestep
last_hidden = lstm_out[:, -1, :]
x = torch.relu(self.fc1(last_hidden))
x = torch.sigmoid(self.fc2(x))
return x

This LSTM takes sequences of 60 timesteps (5 hours of 5-minute candles) and predicts the next direction. The cell state learns which features matter most at different points in the sequence.

Sequence Preparation

Transform your flat data into sliding windows:

Python — Create LSTM sequences
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)

Training and Evaluation

Train-Test Split Strategy

For time-series data, never shuffle. Future data leakage will overstate accuracy.

Python — Proper time-series split
# 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:]

Training Loop

Use binary cross-entropy loss and Adam optimizer:

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

Integrating with Smart Money API

Our ML models don't replace traditional metrics — they amplify them. Here's how Smart Money API combines them:

Python — Ensemble scoring
def compute_confirmation_score(symbol, direction):
# 1. Get derivatives score (funding rate, LSR)
deriv_score = get_derivatives_score(symbol, direction)
# 2. Get on-chain score (MVRV, SOPR, exchange flow)
onchain_score = get_onchain_score(symbol)
# 3. Get whale score (consensus direction, pnl)
whale_score = get_whale_score(symbol, direction)
# 4. Run ML model on features
features = [deriv_score, onchain_score, whale_score, volatility, volume_trend]
ml_signal = lstm_model.predict(features)
# 5. Weighted 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, mlml_signal}
}

சிறந்த நடைமுறைகள்

1. மிகைப்படுத்தலைத் தவிர்க்கவும்

2. வகை சமநிலையைக் கையாளவும்

உங்களிடம் "up" நாட்கள் "down" நாட்களை விட அதிகமாக இருந்தால், மாதிரி அடிக்கடி up ஐ கணிக்கும். எடையுள்ள இழப்பைப் பயன்படுத்தவும்:

Python — Weighted BCE
# 60% வழக்குகள் up ஆக இருந்தால், down வழக்குகள் அதிக எடையுடன் இருக்க வேண்டும்
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] க்கு இயல்பாக்கவும். பயிற்சி தரவுகளில் மட்டுமே scaler ஐ மீண்டும் பொருத்தவும், பின்னர் சரிபார்ப்பு/சோதனைக்கு பயன்படுத்தவும்.

4. Walk-Forward Validation

ஒரு சோதனைத் தொகுப்புக்கு பதிலாக, sliding windows பயன்படுத்தவும்: 1-ஆண்டு தரவுகளில் பயிற்சி, அடுத்த மாதத்தில் சோதனை, பின்னர் 13 மாதங்களில் மீண்டும் பயிற்சி மற்றும் 14வது மாதத்தில் சோதனை, முதலியன. இது நேரடி வர்த்தக நிலைமைகளை உருவகப்படுத்துகிறது.

5. நிஜ உலக செயல்திறனை கண்காணிக்கவும்

பின்தொடர்தல் துல்லியம் ஒருபோதும் நேரடி துல்லியம் அல்ல. உங்கள் மாதிரியை பயன்படுத்தி, உண்மையான வர்த்தக முடிவுகளை கண்காணித்து, புதிய தரவுகளுடன் மாதந்தோறும் மீண்டும் பயிற்சி அளிக்கவும். பயன்படுத்தவும் Sharpe ratio மற்றும் win rate உங்கள் உண்மையான அளவீடுகளாக, F1 score அல்ல.

மேம்பட்ட நுட்பங்கள்

Attention Mechanisms

Transformer-based models (like Attention Is All You Need) உங்கள் நெட்வொர்க்கை ஒரு வரிசையில் மிக முக்கியமான நேரங்களில் "கவனம்" செலுத்த அனுமதிக்கிறது. கிரிப்டோவுக்கு, இது சமீபத்திய ஏற்ற இறக்கங்களை பழைய தரவுகளை விட அதிக எடையுடன் கருத உதவுகிறது.

Ensemble Methods

பல கட்டமைப்புகளை (MLP, LSTM, XGBoost) பயிற்சி அளித்து கணிப்புகளை சராசரியாக்கவும். Ensemble models பொதுவாக ஒற்றை மாதிரிகளை விட 2-5% துல்லியத்தை மேம்படுத்துகின்றன.

Reinforcement Learning

விலை திசையை கணிப்பதற்கு பதிலாக, ஒரு முகவரை cumulative PnL ஐ அதிகரிக்க பயிற்சி அளிக்கவும். முகவர் நம்பிக்கை மற்றும் சந்தை நிலைமைகளின் அடிப்படையில் நிலைகளை அளவிட கற்றுக்கொள்கிறது. இது கிரிப்டோ வர்த்தக AI இன் எல்லை.

Put ML to work with Smart Money API

எங்கள் composite scoring system derivatives intelligence, on-chain analysis, மற்றும் whale tracking ஆகியவற்றை இணைக்கிறது — உங்கள் ML மாதிரிகளில் கூடுதல் அம்சங்களாக ஒருங்கிணைக்க தயாராக உள்ளது. அவற்றை உங்கள் LSTM உள்ளீட்டு அம்சங்களில் சேர்க்கவும் மற்றும் துல்லியம் 3-5% ஜம்ப் செய்வதைக் கவனிக்கவும்.

Get Free API Key →