5 Modelos ONNX para Trading en MT5: LSTM, XGBoost, CNN, Random Forest, Transformer

Cinco arquitecturas de machine learning, cinco casos de uso reales para trading, todas exportables a ONNX y consumibles en Expert Advisor MT5.

⚠️ Aviso honesto: Ningún modelo, por sofisticado que sea, garantiza ganancias. La diferencia entre trader profesional y amateur no está en el modelo — está en feature engineering, validación rigurosa, gestión de riesgo y disciplina.

Comparativo rápido

1. Random Forest — el baseline honesto

Framework: Sklearn · Entrenamiento: minutos · Tamaño: ~1-10 MB · Inferencia: < 1 ms

Clasificación binaria de dirección (sube/baja) o multi-clase. Primer modelo que todo proyecto debería probar — si RF con 200 árboles no supera el azar (50%), el problema está en las features, no en el modelo. Entrena en 1 minuto.

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 — ganador de Kaggle aplicado a mercados

Framework: XGBoost · Inferencia: ~1-3 ms

Igual que RF pero típicamente 2-5% más accurate en tabular. Brilla con muchas features (50+ indicadores, orderbook, sentiment). Cuidado: más propenso a overfit en series temporales — usa 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)])

initial_type = [('input', FloatTensorType([None, n_features]))]
onnx_model = convert_xgboost(model, initial_types=initial_type)
with open("xgb.onnx", "wb") as f:
    f.write(onnx_model.SerializeToString())

3. CNN 1D — encuentra patrones visuales

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

Identifica patrones locales en series temporales — como ‘scanner que busca formaciones de candle’ pero aprende los patrones él mismo. Funciona bien en patrones cortos de 5-30 candles, especialmente synthetic indices (Deriv V75). Más rápido que LSTM, exporta limpio a 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 — memoria para dependencias largas

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

Arquitectura ‘estándar’ para series temporales antes de Transformers. Mantiene estado interno (memoria) cargando información por decenas/centenas de timesteps. Útil para swing trading H1/H4/D1, regímenes de volatilidad que cambian lentamente. Cuidado: data leakage es fácil — siempre split temporal estricto, nunca shuffle. GRU es la primita simple de LSTM, a menudo iguala o supera con menos parámetros.

5. Transformer — cuando necesitas más

Framework: PyTorch · Inferencia: ~10-50 ms

La arquitectura que dominó NLP, adaptada para series (Informer, Autoformer, PatchTST). Aprende ‘atención’ entre todos los timesteps simultáneamente. Brilla en multi-asset (predecir EURUSD usando EURUSD + DXY + oro + bonos + VIX).

⚠️ Reality check: El paper ‘Are Transformers Effective for Time Series Forecasting?’ (Zeng et al., AAAI 2023) mostró que MLPs lineales a veces superan Transformers. No uses por moda — solo cuando el problema lo justifique.

¿Cuál elegir para tu proyecto?

Pipeline estándar para cualquier modelo

1. Recolectar datos vía mt5.copy_rates_from_pos()
2. Feature engineering — retornos lagged, indicadores, contexto
3. Split temporal 80/20 — nunca shuffle
4. Entrenar en train, validar en test holdout
5. Exportar a ONNX con el exportador del framework
6. Validar con onnxruntime en Python
7. Embeber en EA vía #resource + OnnxCreateFromBuffer
8. Backtest en Strategy Tester MT5
9. Demo trade 30+ días con risk management
10. Live con stake mínimo, escalado gradual

Principios universales:
1. Modelo simple que funciona > complejo que puede funcionar
2. Feature engineering supera arquitectura 9/10 veces
3. Validación temporal es sagrada — nunca shuffle
4. Backtest profesional usa 6+ meses out-of-sample
5. Risk management mata más bots que modelos malos