Como Exportar Modelo Python (PyTorch + Sklearn) para ONNX e Usar no MT5

# Bibliotecas essenciais
pip install MetaTrader5 numpy pandas scikit-learn

# Exportadores ONNX
pip install onnx onnxruntime onnxmltools skl2onnx

# Para PyTorch (CPU)
pip install torch torchvision

# Validação
pip install matplotlib

import MetaTrader5 as mt5
import pandas as pd
from datetime import datetime, timedelta

mt5.initialize()

simbolo = "EURUSD"
timeframe = mt5.TIMEFRAME_H1
n_barras = 20000

rates = mt5.copy_rates_from_pos(simbolo, timeframe, 0, n_barras)
df = pd.DataFrame(rates)
df['time'] = pd.to_datetime(df['time'], unit='s')

df.to_csv("dados_eurusd_h1.csv", index=False)
print(f"✓ {len(df)} candles salvos")
mt5.shutdown()

import pandas as pd
import numpy as np

df = pd.read_csv("dados_eurusd_h1.csv")

# Retorno percentual
df['ret'] = df['close'].pct_change()

# Features: últimos 10 retornos
for i in range(1, 11):
    df[f'ret_lag_{i}'] = df['ret'].shift(i)

# Target: 1 se próximo candle subiu
df['target'] = (df['ret'].shift(-1) > 0).astype(int)

df = df.dropna()

feature_cols = [f'ret_lag_{i}' for i in range(1, 11)]
X = df[feature_cols].values.astype(np.float32)
y = df['target'].values

print(f"X shape: {X.shape} | y balance: {y.mean():.3f}")
np.save("X.npy", X)
np.save("y.npy", y)

import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

X = np.load("X.npy")
y = np.load("y.npy")

# Split temporal 80/20
split = int(len(X) * 0.8)
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

model = RandomForestClassifier(
    n_estimators=200,
    max_depth=8,
    min_samples_leaf=20,
    random_state=42,
    n_jobs=-1
)

model.fit(X_train, y_train)
pred = model.predict(X_test)

print(f"Accuracy: {accuracy_score(y_test, pred):.3f}")
print(classification_report(y_test, pred))

import joblib
joblib.dump(model, "modelo_rf.pkl")

import joblib
import numpy as np
from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType

model = joblib.load("modelo_rf.pkl")

# Define o shape da entrada: 10 features
initial_type = [('input', FloatTensorType([None, 10]))]

onnx_model = convert_sklearn(
    model,
    initial_types=initial_type,
    target_opset=15
)

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

print("✓ modelo_rf.onnx criado")

# Validação rápida com onnxruntime
import onnxruntime as ort
sess = ort.InferenceSession("modelo_rf.onnx")

X_teste = np.load("X.npy")[-5:].astype(np.float32)
pred_onnx = sess.run(None, {'input': X_teste})
print(f"Predições ONNX (últimas 5): {pred_onnx[0]}")

import numpy as np
import torch
import torch.nn as nn

X = np.load("X.npy")  # (N, 10)
y = np.load("y.npy")

# Reshape para sequência: (batch, seq_len=10, features=1)
X_seq = X.reshape(-1, 10, 1)

split = int(len(X) * 0.8)
X_train = torch.tensor(X_seq[:split], dtype=torch.float32)
y_train = torch.tensor(y[:split], dtype=torch.long)
X_test  = torch.tensor(X_seq[split:], dtype=torch.float32)
y_test  = torch.tensor(y[split:], dtype=torch.long)

class LSTMTrader(nn.Module):
    def __init__(self, input_size=1, hidden_size=32, num_layers=2):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers,
                            batch_first=True, dropout=0.2)
        self.fc = nn.Linear(hidden_size, 2)
    
    def forward(self, x):
        out, _ = self.lstm(x)
        out = self.fc(out[:, -1, :])  # último timestep
        return out

model = LSTMTrader()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

# Training loop simples
for epoch in range(20):
    optimizer.zero_grad()
    out = model(X_train)
    loss = criterion(out, y_train)
    loss.backward()
    optimizer.step()
    if epoch % 5 == 0:
        with torch.no_grad():
            acc = (model(X_test).argmax(1) == y_test).float().mean()
        print(f"Epoch {epoch} | loss {loss.item():.4f} | val acc {acc:.3f}")

# === EXPORT PARA ONNX ===
model.eval()
dummy_input = torch.randn(1, 10, 1)

torch.onnx.export(
    model,
    dummy_input,
    "modelo_lstm.onnx",
    input_names=['input'],
    output_names=['output'],
    dynamic_axes={
        'input':  {0: 'batch'},
        'output': {0: 'batch'}
    },
    opset_version=15
)

print("✓ modelo_lstm.onnx exportado")

// Carrega arquivo da pasta Files
long handle = OnnxCreate("modelo_rf.onnx", ONNX_DEFAULT);
if(handle == INVALID_HANDLE)
{
    Print("Erro: ", GetLastError());
    return INIT_FAILED;
}

// Define shape: batch=1, features=10
const long input_shape[]  = {1, 10};
const long output_shape[] = {1};
OnnxSetInputShape(handle, 0, input_shape);
OnnxSetOutputShape(handle, 0, output_shape);

// Prepara features dos últimos 10 candles
matrix input(1, 10);
for(int i = 0; i < 10; i++)
{
    double close_atual = iClose(_Symbol, PERIOD_CURRENT, i + 1);
    double close_ant   = iClose(_Symbol, PERIOD_CURRENT, i + 2);
    input[0][i] = (float)((close_atual - close_ant) / close_ant);
}

// Roda inferência
vector output(1);
OnnxRun(handle, ONNX_DEFAULT, input, output);

int direcao = (int)output[0];  // 0 = baixa, 1 = alta
Print("Predição: ", direcao == 1 ? "BUY" : "SELL");