5 Model ONNX untuk Trading MT5: LSTM, XGBoost, CNN, Random Forest, Transformer

Lima arsitektur machine learning, lima kasus penggunaan trading nyata, semua dapat diekspor ke ONNX dan dikonsumsi di Expert Advisor MT5.

⚠️ Disclaimer jujur: Tidak ada model, betapapun canggihnya, yang menjamin keuntungan. Perbedaan antara trader profesional dan amatir bukan pada model — itu feature engineering, validasi ketat, manajemen risiko, dan disiplin.

Perbandingan cepat

1. Random Forest — baseline jujur

Framework: Sklearn · Latih: menit · Ukuran: ~1-10 MB · Inferensi: < 1 ms

Klasifikasi biner arah (naik/turun) atau multi-class. Model pertama yang setiap project harus coba — jika RF dengan 200 tree tidak mengalahkan random (50%), masalah ada di features, bukan model. Latih dalam 1 menit.

from sklearn.ensemble import RandomForestClassifier
from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType

model = RandomForestClassifier(n_estimators=200, max_depth=8)
model.fit(X_train, y_train)

initial_type = [('input', FloatTensorType([None, n_features]))]
onnx_model = convert_sklearn(model, initial_types=initial_type, target_opset=15)

with open("rf.onnx", "wb") as f:
    f.write(onnx_model.SerializeToString())

2. XGBoost — pemenang Kaggle diterapkan pada pasar

Framework: XGBoost · Inferensi: ~1-3 ms

Sama dengan RF tapi biasanya 2-5% lebih akurat pada tabular. Cemerlang dengan banyak features (50+ indikator, orderbook, sentiment). Hati-hati: lebih rentan overfit pada deret waktu — pakai early_stopping_rounds.

import xgboost as xgb
from onnxmltools.convert import convert_xgboost
from onnxconverter_common.data_types import FloatTensorType

model = xgb.XGBClassifier(n_estimators=300, max_depth=6,
                          learning_rate=0.05, early_stopping_rounds=20)
model.fit(X_train, y_train, eval_set=[(X_val, y_val)])

3. CNN 1D — menemukan pola visual

Framework: PyTorch/TF · Inferensi: ~1-5 ms

Mengidentifikasi pola lokal di deret waktu — seperti ‘scanner yang mencari formasi candle’ tapi belajar polanya sendiri. Bekerja baik untuk pola pendek 5-30 candle, terutama synthetic indices (Deriv V75). Lebih cepat dilatih dari LSTM, ekspor bersih ke ONNX.

import torch.nn as nn

class CNN1D(nn.Module):
    def __init__(self, in_channels=4, seq_len=30, n_classes=2):
        super().__init__()
        self.conv1 = nn.Conv1d(in_channels, 32, kernel_size=5, padding=2)
        self.conv2 = nn.Conv1d(32, 64, kernel_size=3, padding=1)
        self.pool  = nn.MaxPool1d(2)
        self.fc    = nn.Linear(64 * (seq_len // 4), n_classes)
    
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        return self.fc(x.flatten(1))

4. LSTM / GRU — memori untuk dependensi panjang

Framework: PyTorch/TF · Inferensi: ~2-10 ms

Arsitektur ‘standar’ untuk deret waktu sebelum Transformer. LSTM menyimpan state internal (memori) membawa informasi melalui puluhan/ratusan timestep. Berguna untuk swing trading H1/H4/D1, regime volatilitas yang berubah perlahan. Hati-hati: mudah data leakage — selalu split temporal ketat, jangan shuffle. GRU adalah sepupu LSTM yang lebih sederhana, sering setara dengan parameter lebih sedikit.

5. Transformer — ketika Anda butuh lebih

Framework: PyTorch · Inferensi: ~10-50 ms

Arsitektur yang mendominasi NLP, diadaptasi untuk deret waktu (Informer, Autoformer, PatchTST). Belajar ‘attention’ antar timestep simultan. Cemerlang untuk multi-asset (prediksi EURUSD pakai EURUSD + DXY + emas + bonds + VIX).

⚠️ Reality check: Paper ‘Are Transformers Effective for Time Series Forecasting?’ (Zeng et al., AAAI 2023) menunjukkan MLP linear sederhana kadang mengalahkan Transformer. Jangan pakai karena hype — gunakan ketika problem benar-benar membenarkannya.

Pilih yang mana untuk project Anda?

Pipeline standar untuk semua model

1. Kumpulan data via mt5.copy_rates_from_pos()
2. Feature engineering — lagged returns, indikator, konteks
3. Split temporal 80/20 — jangan shuffle
4. Latih di train, validasi di test holdout
5. Export ke ONNX dengan exporter framework
6. Validasi dengan onnxruntime di Python
7. Embed di EA via #resource + OnnxCreateFromBuffer
8. Backtest di MT5 Strategy Tester
9. Demo trade 30+ hari dengan risk management
10. Live dengan stake minimal, scaling gradual

Prinsip universal:
1. Model sederhana yang bekerja > kompleks yang mungkin bekerja
2. Feature engineering mengalahkan arsitektur 9/10 kali
3. Validasi temporal sakral — jangan shuffle deret keuangan
4. Backtest profesional pakai 6+ bulan out-of-sample
5. Risk management membunuh lebih banyak bot daripada model buruk