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

Random Forest Classifier

Para que serve: classificação binária de direção (sobe/desce próximo candle) ou multi-classe (forte alta / leve alta / lateral / leve baixa / forte baixa). É o primeiro modelo que todo projeto de IA em trading deveria experimentar — se Random Forest com 200 árvores não bate o random (50%), seu problema está nas features, não no modelo.

Quando faz sentido: features tabulares (indicadores técnicos, retornos lagged, volume, hora do dia, dia da semana). Funciona em qualquer timeframe. Robusto a outliers. Não precisa normalização.

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())

Tutorial completo: Exportar Sklearn para ONNX e usar no MT5.

XGBoost Classifier / Regressor

Para que serve: mesmo que Random Forest, mas tipicamente 2-5% mais accurate em problemas tabulares. Trocou Random Forest por XGBoost em centenas de competições Kaggle e quase sempre ganhou. Para trading, brilha quando você tem muitas features e quer que o modelo descubra interações não-lineares.

Quando faz sentido: você já tem RF rodando e quer espremer mais alguns pontos de accuracy. Tem features ricas (50+ indicadores diferentes, dados de orderbook, sentiment). Precisa de regressão (prever magnitude, não só direção).

Cuidado: XGBoost é mais sensível a overfit em séries temporais. Use early_stopping_rounds com validation set temporal separado.

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, eval_metric='logloss'
)
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())

1D CNN para Pattern Recognition

Para que serve: identificar padrões locais em séries temporais. Pense como “scanner que procura formações de candle” — mas em vez de regras hard-coded (martelo, engolfo, estrela cadente), a CNN aprende sozinha quais sequências de candle são preditivas.

Quando faz sentido: quando você suspeita que existem padrões locais de curto prazo (5-30 candles) que se repetem. Funciona bem em ativos com movimentação por “ondas” (synthetic indices Deriv como Volatility 75).

Vantagem técnica: CNNs são mais rápidas de treinar que LSTMs e exportam para ONNX sem dor de cabeça (todas as operações são suportadas).

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 shape: (batch, channels=OHLC, seq_len)
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.flatten(1)
        return self.fc(x)

# Export
torch.onnx.export(model, dummy_input, "cnn1d.onnx",
    input_names=['input'], output_names=['output'], opset_version=15)

LSTM (Long Short-Term Memory)

Para que serve: a arquitetura “padrão de mercado” para séries temporais antes dos Transformers. LSTM mantém estado interno (a “memória”) que carrega informação por dezenas/centenas de timesteps. Útil quando o contexto distante importa — por exemplo, regime de volatilidade que muda lentamente.

Quando faz sentido: swing trading em H1/H4/D1 onde tendência se forma ao longo de 50-200 candles. Multi-step forecasting (prever os próximos 5 candles, não só o próximo). Sequências com dependências temporais não-locais.

Cuidado: LSTM treinada mal facilmente sofre data leakage. Use sempre split temporal estrito. Não use shuffle. Verifique que o backtest reproduz exatamente a inferência live.

O tutorial passo-a-passo tem o código LSTM completo, training loop, e exportação para ONNX. GRU é a versão “mais simples” de LSTM — frequentemente performa igual ou melhor com menos parâmetros.

Transformer / Time-Series Transformer

Para que serve: a arquitetura que dominou NLP e que tem sido adaptada para séries temporais (Informer, Autoformer, PatchTST, Time-Series Transformer). Aprende relações “atenção” entre todos os timesteps simultaneamente — não sequencial como LSTM.

Quando faz sentido: multi-asset ou multi-feature. Por exemplo: prever EURUSD usando EURUSD + USD index + ouro + bonds 10Y + VIX simultaneamente. Transformer aprende quais relações cross-asset importam em cada momento.

Cuidado com export: alguns operadores de attention custom podem não converter para ONNX. Use implementações padrão (nn.TransformerEncoder do PyTorch) que exportam bem. Modelos muito grandes (centenas de MB) carregam lentamente no MT5.