Pipelines de processamento de dados em MQL5
Introdução: por que o pré-processamento de dados é importante
Ao projetar e desenvolver sistemas e modelos de previsão baseados em inteligência artificial, é tentador concentrar toda a atenção na arquitetura das redes de aprendizado profundo ou na complexidade da estratégia de negociação. No entanto, um dos fatores mais importantes para o desempenho de um modelo muitas vezes não é a própria rede neural, mas a qualidade e a consistência dos dados utilizados. Na prática, os dados financeiros brutos, como barras OHLC, volumes de ticks e spreads, raramente estão prontos para serem utilizados diretamente na modelagem. Esses valores podem apresentar escalas diferentes, conter valores atípicos provocados por movimentos bruscos do mercado ou incluir características categóricas, como as sessões de negociação. Sem um pré-processamento adequado, os modelos matemáticos não conseguem lidar corretamente com todas essas particularidades.
Como vimos na análise anterior, se estivermos treinando uma rede neural simples com indicadores normalizados de retorno dos preços e volatilidade, o Standard-Scaler provavelmente será uma escolha adequada, pois permite colocar diferentes características em escalas comparáveis. Em outro cenário, se utilizarmos um modelo LSTM no formato ONNX, treinado em Python com funções de ativação sigmoides, o escalonamento min-max poderá ser mais apropriado, já que os valores transformados geralmente se ajustam melhor ao intervalo limitado dessas funções de ativação. Por outro lado, ao modelar o comportamento das negociações durante um evento noticioso importante, quando spreads e volumes podem aumentar drasticamente, um método de escalonamento robusto pode ajudar a preservar a estrutura central dos dados, reduzindo a influência desses valores anômalos.
O ponto principal é que o pré-processamento não deve ser tratado como uma etapa secundária. A escolha do método de escalonamento influencia diretamente a maneira como as características interagem durante o treinamento e pode determinar a diferença entre um modelo capaz de generalizar bem e outro que apresenta vieses ou comportamento instável.
Sem um pré-processamento adequado, até mesmo as redes neurais mais sofisticadas terão dificuldades para identificar padrões de maneira eficiente. Por exemplo, uma variável como o spread, medido em frações de ponto percentual, pode acabar tendo sua influência ofuscada pelo volume, cujos valores podem chegar à casa dos milhares. Da mesma forma, atribuir valores inteiros às sessões de negociação, como Ásia (0), Europa (1) e Estados Unidos (2), pode introduzir relações artificiais entre categorias e levar o modelo a interpretações equivocadas.
É por isso que o pré-processamento pode ser considerado a base de fluxos de trabalho confiáveis em machine learning. No ecossistema Python, a biblioteca SCIKIT-LEARN é conhecida por suas ferramentas de padronização, normalização, escalonamento robusto e codificação one-hot, utilizadas para preparar os dados destinados aos modelos nas etapas posteriores do fluxo de machine learning. Cada transformação busca garantir que as características de entrada contribuam de maneira significativa para o treinamento. Entretanto, no contexto da negociação financeira, as bibliotecas MQL5 disponíveis atualmente apresentam uma lacuna em relação aos recursos de pré-processamento. Para superar essa limitação, podemos implementar classes MQL5 que reproduzam, em certa medida, as funcionalidades do SCIKIT-LEARN, criando pipelines de processamento de dados adaptados à previsão de séries temporais financeiras.
Superando a lacuna entre os ecossistemas
No Python, a biblioteca SCIKIT-LEARN é amplamente reconhecida como um padrão do setor para o pré-processamento de dados em machine learning. Com poucas linhas de código, os desenvolvedores podem utilizar o Standard-Scaler para centralizar as características, o Min-Max-Scaler para ajustá-las a um intervalo fixo, o Robust-Scaler para reduzir a influência dos valores atípicos sobre o escalonamento ou o One-Hot-Encoder para converter características categóricas em representações binárias. Além disso, a classe de pipeline do SCIKIT-LEARN permite encadear essas etapas de maneira integrada, garantindo que todos os conjuntos de dados fornecidos ao modelo passem pela mesma sequência de transformações. Essa arquitetura modular, baseada no conceito plug-and-play, contribuiu para a rápida adoção do machine learning em diversos setores.
Já os desenvolvedores MQL5 enfrentam uma realidade bastante diferente. Embora a linguagem MQL5 seja relativamente eficiente no processamento de dados de negociação, ela ainda não oferece recursos nativos de pré-processamento comparáveis aos do SCIKIT-LEARN. Cada transformação, seja escalonamento, codificação ou até mesmo imputação de valores ausentes, precisa ser implementada manualmente, muitas vezes por meio de trechos de código isolados. Isso não apenas aumenta a probabilidade de erros, como também dificulta a reprodução dos resultados dos testes e a manutenção da consistência entre os dados de treinamento e de teste.
Na minha opinião, a solução pode estar no desenvolvimento de uma classe de pipeline de pré-processamento em MQL5 que reproduza a abordagem conceitual do SCIKIT-LEARN. Se implementarmos módulos reutilizáveis, como CStandardScaler, CMinMaxScaler, CRobustScaler e COneHotEncoder, poderemos reunir as etapas de pré-processamento em um único contêiner. Essa estrutura permitirá preparar sistematicamente os dados brutos de séries temporais financeiras antes de utilizá-los em modelos de aprendizado profundo, independentemente de esses modelos terem sido desenvolvidos diretamente em MQL5 ou importados por meio do ONNX. Com essa abordagem, os desenvolvedores MQL5 poderão adaptar ao MQL5 os fluxos de trabalho já conhecidos no ecossistema Python, abrindo caminho para experimentos mais eficientes, desenvolvimento mais rápido e, possivelmente, sistemas de inteligência artificial mais confiáveis.
Estrutura do pipeline de pré-processamento
Para entender o funcionamento de um pipeline de pré-processamento de dados, podemos compará-lo a uma linha de produção. Os dados brutos entram por uma extremidade e passam por uma sequência de transformações até chegarem à saída em um formato adequado para o modelo. Cada etapa executa uma tarefa específica, como imputar valores ausentes, codificar categorias ou escalonar características numéricas. No Python, essas operações geralmente são encapsuladas em um objeto pipeline da biblioteca SCIKIT-LEARN. Em MQL5, precisamos desenvolver uma estrutura equivalente utilizando classes personalizadas. Nossa classe receberá o nome CPreprocessingPipeline. Vamos implementá-la em MQL5 da seguinte maneira:
// Preprocessing Pipeline class CPreprocessingPipeline { private: SPreprocessorStep m_steps[]; IPreprocessor *m_preprocessors[]; int m_step_count; public: CPreprocessingPipeline() : m_step_count(0) {} ~CPreprocessingPipeline() { for(int i = 0; i < m_step_count; i++) delete m_preprocessors[i]; } void AddImputeMedian(int column) { ArrayResize(m_steps, m_step_count + 1); ArrayResize(m_preprocessors, m_step_count + 1); m_steps[m_step_count].type = PREPROCESSOR_IMPUTE_MEDIAN; m_steps[m_step_count].column = column; m_preprocessors[m_step_count] = new CImputeMedian(column); m_step_count++; } void AddImputeMode(int column) { ArrayResize(m_steps, m_step_count + 1); ArrayResize(m_preprocessors, m_step_count + 1); m_steps[m_step_count].type = PREPROCESSOR_IMPUTE_MODE; m_steps[m_step_count].column = column; m_preprocessors[m_step_count] = new CImputeMode(column); m_step_count++; } void AddStandardScaler() { ArrayResize(m_steps, m_step_count + 1); ArrayResize(m_preprocessors, m_step_count + 1); m_steps[m_step_count].type = PREPROCESSOR_STANDARD_SCALER; m_steps[m_step_count].column = -1; m_preprocessors[m_step_count] = new CStandardScaler(); m_step_count++; } void AddRobustScaler() { ArrayResize(m_steps, m_step_count + 1); ArrayResize(m_preprocessors, m_step_count + 1); m_steps[m_step_count].type = PREPROCESSOR_ROBUST_SCALER; m_steps[m_step_count].column = -1; m_preprocessors[m_step_count] = new CRobustScaler(); m_step_count++; } void AddMinMaxScaler(double new_min = 0.0, double new_max = 1.0) { ArrayResize(m_steps, m_step_count + 1); ArrayResize(m_preprocessors, m_step_count + 1); m_steps[m_step_count].type = PREPROCESSOR_MINMAX_SCALER; m_steps[m_step_count].column = -1; m_preprocessors[m_step_count] = new CMinMaxScaler(new_min, new_max); m_step_count++; } void AddOneHotEncoder(int column) { ArrayResize(m_steps, m_step_count + 1); ArrayResize(m_preprocessors, m_step_count + 1); m_steps[m_step_count].type = PREPROCESSOR_ONEHOT_ENCODER; m_steps[m_step_count].column = column; m_preprocessors[m_step_count] = new COneHotEncoder(column); m_step_count++; } bool FitPipeline(matrix &data) { matrix temp; temp.Copy(data); for(int i = 0; i < m_step_count; i++) { matrix out; if(!m_preprocessors[i].Fit(temp)) return false; if(!m_preprocessors[i].Transform(temp, out)) return false; temp.Copy(out); } return true; } bool TransformPipeline(matrix &data, matrix &out) { out.Copy(data); for(int i = 0; i < m_step_count; i++) { matrix temp; if(!m_preprocessors[i].Transform(out, temp)) return false; out.Copy(temp); } return true; } bool FitTransformPipeline(matrix &data, matrix &out) { if(!FitPipeline(data)) return false; return TransformPipeline(data, out); } };
Essa classe funciona como um contêiner para as diferentes etapas de transformação. Os desenvolvedores podem adicionar etapas utilizando métodos como AddStandardScaler(), AddRobustScaler(), AddMinMaxScaler() ou AddOneHotEncoder(). Cada etapa é representada por uma classe independente, como CStandardScaler, por exemplo. Essas classes implementam uma interface padronizada, com métodos como Fit(), Transform() e FitTransform(). Depois de configurar o pipeline, ajustamos seus parâmetros aos dados de treinamento, permitindo que ele determine estatísticas como médias, medianas e modas, além de aprender o mapeamento das categorias. Após essas etapas e a obtenção de resultados satisfatórios no treinamento e nos testes, o modelo pode ser aplicado a novos conjuntos de dados submetidos à mesma sequência de transformações. Essa consistência ajuda a evitar erros comuns na avaliação de modelos, como o vazamento de dados (data leakage).
Essa arquitetura modular oferece diversas vantagens. Primeiro, favorece a reutilização, pois o mesmo objeto de pipeline pode ser empregado em diferentes experimentos. Segundo, facilita a manutenção do código, já que cada classe de transformação possui menos dependências em relação às demais e, portanto, pode ser depurada com maior facilidade. Por fim, garante maior consistência ao assegurar que os dados de treinamento, validação e teste passem pela mesma sequência de transformações. Em outras palavras, um pipeline de pré-processamento introduz nos fluxos de trabalho de machine learning em MQL5 uma organização mais rigorosa e padronizada, aproximando-os da confiabilidade oferecida pelo ecossistema Python.
Standard-Scaler
O Standard-Scaler é provavelmente uma das ferramentas de pré-processamento mais utilizadas em machine learning. Seu objetivo é centralizar cada característica em torno de zero e escaloná-la de acordo com seu desvio padrão. Matematicamente, essa transformação é definida pela seguinte fórmula:

Em que:
- μ (mi) representa a média da característica;
- σ (sigma) representa seu desvio padrão;
- x representa um ponto de dados do conjunto.
Como resultado, cada característica passa a apresentar média zero e desvio padrão igual a um. Isso geralmente torna o conjunto de dados mais homogêneo, reduzindo o risco de determinadas características exercerem uma influência desproporcional durante o treinamento. Nossa classe CStandardScaler é implementada em MQL5 da seguinte maneira:
// Standard Scaler class CStandardScaler : public IPreprocessor { private: double m_means[]; double m_stds[]; bool m_is_fitted; public: CStandardScaler() : m_is_fitted(false) {} bool Fit(matrix &data) { int rows = int(data.Rows()); int cols = int(data.Cols()); ArrayResize(m_means, cols); ArrayResize(m_stds, cols); for(int j = 0; j < cols; j++) { vector column(rows); for(int i = 0; i < rows; i++) column[i] = data[i][j]; m_means[j] = column.Mean(); m_stds[j] = column.Std(); if(m_stds[j] == 0.0) m_stds[j] = EPSILON; } m_is_fitted = true; return true; } bool Transform(matrix &data, matrix &out) { if(!m_is_fitted) return false; int rows = int(data.Rows()); int cols = int(data.Cols()); out.Init(rows, cols); for(int j = 0; j < cols; j++) for(int i = 0; i < rows; i++) out[i][j] = (!MathIsValidNumber(data[i][j]) ? DBL_MIN : (data[i][j] - m_means[j]) / m_stds[j]); return true; } bool FitTransform(matrix &data, matrix &out) { if(!Fit(data)) return false; return Transform(data, out); } };
Na classe MQL5 apresentada acima, reproduzimos o funcionamento do Standard-Scaler calculando a média e o desvio padrão de cada coluna durante a etapa Fit(). Esses valores são armazenados internamente e posteriormente utilizados na etapa Transform() para ajustar cada ponto de dados. Quando a variância de uma característica é zero, acrescenta-se um pequeno valor positivo (épsilon) para evitar a divisão por zero e garantir a estabilidade numérica.
Em aplicações de negociação financeira, o Standard-Scaler é particularmente útil para processar características cujos valores apresentam escalas diferentes ou são provenientes de diferentes timeframes. Considere, por exemplo, os spreads, geralmente expressos em frações de pip, enquanto outras características, como o volume de ticks, podem apresentar valores na casa dos milhares. Sem padronização, o modelo pode atribuir uma importância desproporcional à variável de maior escala simplesmente devido à magnitude de seus valores. Ao padronizar ambas as características, permitimos que o modelo as avalie em condições relativamente equivalentes.
Outro exemplo prático é a preparação de dados de entrada para uma rede neural, como retornos logarítmicos, médias móveis e indicadores de volatilidade. A aplicação desse método de escalonamento padroniza as características, favorecendo a convergência eficiente durante o treinamento de modelos como os perceptrons multicamadas (MLP) e até mesmo as máquinas de vetores de suporte (SVM).
Min-Max Scaler
Enquanto o Standard-Scaler padroniza as características para que apresentem média zero e variância unitária, o Min-Max Scaler ajusta seus valores a um intervalo específico, geralmente entre 0 e 1. A fórmula dessa transformação é a seguinte:

Essa transformação mantém os valores dentro do intervalo desejado, o que pode ser especialmente útil em modelos sensíveis à magnitude dos dados de entrada. Entre eles estão as redes neurais que utilizam funções de ativação sigmoide ou tangente hiperbólica. Nossa classe CMinMaxScaler é implementada em MQL5 da seguinte maneira:
// MinMax Scaler class CMinMaxScaler : public IPreprocessor { private: double m_mins[]; double m_maxs[]; double m_new_min; double m_new_max; bool m_is_fitted; public: CMinMaxScaler(double new_min = 0.0, double new_max = 1.0) : m_new_min(new_min), m_new_max(new_max), m_is_fitted(false) {} bool Fit(matrix &data) { int rows = int(data.Rows()); int cols = int(data.Cols()); ArrayResize(m_mins, cols); ArrayResize(m_maxs, cols); for(int j = 0; j < cols; j++) { vector column(rows); for(int i = 0; i < rows; i++) column[i] = data[i][j]; m_mins[j] = column.Min(); m_maxs[j] = column.Max(); if(m_maxs[j] - m_mins[j] == 0.0) m_maxs[j] += EPSILON; } m_is_fitted = true; return true; } bool Transform(matrix &data, matrix &out) { if(!m_is_fitted) return false; int rows = int(data.Rows()); int cols = int(data.Cols()); out.Init(rows, cols); for(int j = 0; j < cols; j++) for(int i = 0; i < rows; i++) { if(!MathIsValidNumber(data[i][j])) out[i][j] = DBL_MIN; else { double scale = (m_new_max - m_new_min) / (m_maxs[j] - m_mins[j]); out[i][j] = (data[i][j] - m_mins[j]) * scale + m_new_min; } } return true; } bool FitTransform(matrix &data, matrix &out) { if(!Fit(data)) return false; return Transform(data, out); } };
Essa classe implementa o escalonamento min-max identificando primeiro os valores mínimo e máximo de cada coluna durante a etapa Fit(). Em seguida, esses valores são utilizados na etapa Transform() para ajustar a escala dos dados. Os desenvolvedores podem definir limites personalizados, como o intervalo de -1 a +1, em vez do intervalo padrão [0,1], para atender aos requisitos do modelo utilizado. Assim como no Standard-Scaler, o épsilon evita divisões por zero, mesmo quando todos os valores de uma característica são iguais.
Um exemplo prático de aplicação em negociação financeira é o escalonamento dos preços de fechamento antes de fornecê-los a um modelo LSTM no formato ONNX. Como as redes neurais geralmente apresentam melhor desempenho quando os dados de entrada estão restritos a um intervalo reduzido, o escalonamento min-max favorece gradientes mais suaves e uma convergência mais rápida durante o treinamento. Da mesma forma, ao trabalhar com indicadores de momentum ou osciladores que apresentam valores absolutos elevados, o Min-Max Scaler permite ajustá-los a um intervalo estável e previsível.
Uma das principais vantagens do escalonamento min-max é sua simplicidade e a capacidade de preservar a forma da distribuição original dos dados. Diferentemente da padronização, que altera a variância do conjunto de dados, o escalonamento min-max ajusta linearmente os valores a um intervalo fixo. No entanto, esse método pode ser sensível a valores atípicos, pois um único valor extremo pode distorcer o escalonamento de todas as observações de uma característica. Para conjuntos de dados estáveis ou quando combinado com a remoção de valores atípicos, o Min-Max Scaler pode ser uma das melhores opções para preparar características e dados de entrada de modelos de aprendizado profundo.
Algoritmo de escalonamento Robust Scaler
Os mercados financeiros são conhecidos por sua imprevisibilidade e pela ocorrência de movimentos anômalos. Eventos noticiosos repentinos frequentemente provocam uma forte ampliação dos spreads entre os preços de compra e venda ou um aumento significativo do volume negociado, muito acima das médias históricas. Nessas situações, métodos de pré-processamento como o Standard-Scaler e o Min-Max Scaler podem produzir resultados distorcidos, pois dependem de estatísticas sensíveis a valores atípicos: o primeiro utiliza a média e o desvio padrão, enquanto o segundo utiliza os valores extremos do conjunto de dados. É justamente nesses cenários que o Robust Scaler se torna especialmente útil.
O Robust Scaler centraliza os dados em torno da mediana e, em seguida, realiza o escalonamento com base no intervalo interquartil (interquartile range, IQR). O IQR é definido como a diferença entre o 75º percentil (Q3) e o 25º percentil (Q1). Assim, essa transformação é expressa pela seguinte fórmula:

Em que:
- IQR é a diferença entre o 75º percentil (Q3) e o 25º percentil (Q1);
- Median representa a mediana do conjunto de dados;
- x representa um ponto de dados do conjunto.
Como esse algoritmo reduz a influência dos valores extremos, ele geralmente é resistente a valores atípicos. No contexto dos dados de negociação, isso significa que, mesmo diante de um choque de mercado pouco frequente, a maioria das características permanece em uma escala adequada para a modelagem. Nossa implementação dessa classe em MQL5 é apresentada a seguir:
// Robust Scaler class CRobustScaler : public IPreprocessor { private: double m_medians[]; double m_iqrs[]; bool m_is_fitted; public: CRobustScaler() : m_is_fitted(false) {} bool Fit(matrix &data) { int rows = int(data.Rows()); int cols = int(data.Cols()); ArrayResize(m_medians, cols); ArrayResize(m_iqrs, cols); for(int j = 0; j < cols; j++) { vector column(rows); for(int i = 0; i < rows; i++) column[i] = data[i][j]; m_medians[j] = column.Median(); double q25 = column.Quantile(0.25); double q75 = column.Quantile(0.75); m_iqrs[j] = q75 - q25; if(m_iqrs[j] == 0.0) m_iqrs[j] = EPSILON; } m_is_fitted = true; return true; } bool Transform(matrix &data, matrix &out) { if(!m_is_fitted) return false; int rows = int(data.Rows()); int cols = int(data.Cols()); out.Init(rows, cols); for(int j = 0; j < cols; j++) for(int i = 0; i < rows; i++) out[i][j] = (!MathIsValidNumber(data[i][j]) ? DBL_MIN : (data[i][j] - m_medians[j]) / m_iqrs[j]); return true; } bool FitTransform(matrix &data, matrix &out) { if(!Fit(data)) return false; return Transform(data, out); } };
A classe CRobustScaler, implementada em MQL5 e apresentada acima, calcula as medianas e os quartis durante a etapa Fit() e utiliza esses valores para realizar o escalonamento na etapa Transform(). Além disso, emprega um mecanismo de proteção baseado em épsilon para garantir a estabilidade numérica caso o intervalo interquartil (IQR) seja igual a zero.* Nossa implementação permite processar conjuntos de dados que, devido a oscilações bruscas e irregulares do mercado, poderiam comprometer a interpretação dos padrões pelos modelos.
Para ilustrar, imagine que estamos treinando um modelo com dados de volume de ticks. Durante as sessões de negociação habituais, os volumes podem permanecer relativamente estáveis, mas, quando uma notícia importante é divulgada, podem facilmente aumentar dez vezes. A padronização ou o escalonamento min-max poderiam ampliar a escala da distribuição das características, comprimindo os valores considerados normais em um intervalo extremamente estreito, praticamente insignificante. Já o Robust Scaler concentra-se nos 50% centrais dos dados, o que geralmente ajuda a preservar a maioria dos padrões das características de entrada do modelo. Isso o torna adequado para aplicações de aprendizado profundo que precisam lidar com distribuições voláteis e de caudas pesadas, frequentemente encontradas no mercado de câmbio e em determinados mercados de criptomoedas.
Codificação one-hot
Na negociação financeira, nem todas as características são numéricas. Algumas são discretas ou categóricas, pois representam condições específicas do mercado. Por exemplo, podemos classificar os horários de negociação nas sessões asiática, europeia e norte-americana. Também podemos categorizar os regimes de mercado como altista, baixista ou lateral (flat). Esses são apenas alguns exemplos, mas o ponto principal é que os modelos de machine learning não conseguem interpretar diretamente valores categóricos não numéricos. Além disso, atribuir números inteiros a essas categorias, como Ásia = 0, Europa = 1 e Estados Unidos = 2, cria uma relação de ordem artificial que pode distorcer o aprendizado do modelo.
Uma solução comum para esse problema é a codificação one-hot (one-hot encoding). Nesse método, cada categoria é convertida em um vetor binário. Por exemplo, as sessões asiática, europeia e norte-americana podem ser representadas, respectivamente, por [1,0,0], [0,1,0] e [0,0,1]. Isso permite que o modelo diferencie as categorias sem pressupor uma relação de ordem entre elas. Nossa implementação desse método em MQL5 é apresentada a seguir:
// One-Hot Encoder class COneHotEncoder : public IPreprocessor { private: int m_column; double m_categories[]; bool m_is_fitted; public: COneHotEncoder(int column) : m_column(column), m_is_fitted(false) {} bool Fit(matrix &data) { int rows = int(data.Rows()); vector values; int unique = 0; for(int i = 0; i < rows; i++) { if(!MathIsValidNumber(data[i][m_column])) continue; int idx = CVectorUtils::BinarySearch(values, data[i][m_column]); if(idx == -1) { values.Resize(unique + 1); values[unique] = data[i][m_column]; unique++; } } values.Swap(m_categories); //ArrayCopy(m_categories, values); m_is_fitted = true; return true; } bool Transform(matrix &data, matrix &out) { if(!m_is_fitted) return false; int rows = int(data.Rows()); int cols = int(data.Cols()); int cat_count = ArraySize(m_categories); if(data.Cols() == cols - 1 + cat_count) return false; out.Resize( rows, cols - 1 + cat_count); out.Fill(0.0); for(int i = 0; i < rows; i++) { int out_col = 0; for(int j = 0; j < cols; j++) { if(j == m_column) continue; out[i][out_col] = data[i][j]; out_col++; } for(int k = 0; k < cat_count; k++) if(data[i][m_column] == m_categories[k]) { out[i][out_col + k] = 1.0; break; } } m_is_fitted = true; return true; } bool FitTransform(matrix &data, matrix &out) { if(!Fit(data)) return false; return Transform(data, out); } };
A classe CONeHotEncoder, apresentada acima, implementa essa transformação. Durante a etapa Fit(), identifica as categorias únicas presentes na coluna de características selecionada. Na etapa Transform(), a coluna de dados categóricos é substituída por várias colunas binárias, uma para cada categoria identificada. O resultado é uma matriz de características expandida, na qual as informações categóricas são representadas em um formato adequado para o modelo.
Para demonstrar a utilidade dessa abordagem, podemos retomar o exemplo da codificação das sessões de negociação. Se utilizarmos os códigos numéricos originais, ou seja, 0 para a Ásia, 1 para a Europa e 2 para os Estados Unidos, a rede neural poderá interpretar incorretamente a diferença entre as sessões asiática e norte-americana como maior do que a diferença entre as sessões asiática e europeia, mesmo em características que não apresentam necessariamente uma relação temporal. Com a codificação one-hot, cada sessão recebe uma representação independente, permitindo que o modelo aprenda diferentes padrões de comportamento para cada categoria sem pressupor relações de ordem. Isso é fundamental para os modelos de negociação, pois diferentes sessões podem apresentar sinais específicos de liquidez, volatilidade e direção dos movimentos de preços.
Reunindo todas as etapas
As ferramentas de escalonamento e codificação já oferecem recursos importantes quando utilizadas individualmente, mas seu verdadeiro potencial aparece quando são combinadas em um único fluxo de trabalho: o pipeline de pré-processamento. Ao integrar diferentes transformações, garantimos que todos os conjuntos de dados passem pela mesma sequência de processamento antes de serem fornecidos ao modelo.
Considere o seguinte cenário. Suponha que estejamos preparando um conjunto de dados com quatro características principais:
- Preço de fechamento
- Volume de ticks
- Spread
- Sessão de negociação (variável categórica)
A primeira etapa geralmente consiste em tratar os valores ausentes. Esse é um aspecto que alguns desenvolvedores MQL5 podem negligenciar, pois frequentemente utilizam os dados fornecidos pela corretora sem qualquer tratamento adicional. No entanto, nunca devemos presumir que todas as informações necessárias estejam disponíveis. Por exemplo, se houver valores ausentes nos dados de volume de ticks, podemos utilizar o método AddImputeMedian(1), em que 1 representa o índice da característica correspondente ao volume de ticks entre as quatro características selecionadas. Isso permite substituir os valores ausentes pela mediana da respectiva coluna. Da mesma forma, se faltarem informações sobre a sessão de negociação, podemos utilizar AddImputeMode(3) para preencher os valores ausentes com a categoria mais frequente, adotando essa solução como uma alternativa prática. Essas escolhas podem ser ajustadas pelo desenvolvedor conforme as necessidades de seu sistema ou modelo. Os exemplos apresentados aqui têm finalidade exclusivamente ilustrativa.
Depois de tratar os valores ausentes, a próxima etapa consiste em converter os dados categóricos em uma representação binária que não introduza relações de ordem artificiais. Para isso, aplicamos o método AddOneHotEncoder(3), que expande a coluna das sessões de negociação em vetores binários, garantindo que cada sessão tenha sua própria representação.
A próxima etapa, ou terceira etapa, pode ser a aplicação de um método de escalonamento. Para nosso conjunto de dados, podemos escolher uma das seguintes funções: AddStandardScaler(), AddRobustScaler() ou AddminMaxScaler(). O objetivo dessa etapa é ajustar todas as características numéricas para que apresentem escalas comparáveis. Depois de adicionar essas etapas ao pipeline, podemos chamar a função FitPipeline() com o conjunto de dados de treinamento. Essa função permite determinar todos os parâmetros necessários, como média (Mean), mediana (Median), moda (Mode) e mapeamentos de categorias (Category Mappings). Posteriormente, podemos utilizar TransformPipeline() tanto no conjunto de treinamento quanto no conjunto de teste (ou nas etapas de otimização e teste forward), garantindo a consistência das transformações sem permitir o vazamento de informações futuras para o treinamento.
O resultado é uma matriz de características limpa, escalonada e codificada, pronta para ser utilizada em um modelo de aprendizado profundo, independentemente de esse modelo ter sido implementado diretamente em MQL5 ou importado por meio do ONNX. Esse pipeline torna o pré-processamento transparente, reproduzível e modular, permitindo que os desenvolvedores dediquem mais atenção aos sinais de negociação e à estratégia, em vez de se concentrarem no tratamento inicial dos dados. O funcionamento das classes do nosso pipeline de pré-processamento pode ser demonstrado por meio do script anexado ao final deste artigo. Uma execução de teste com o símbolo USD JPY apresenta os seguintes resultados:
2025.09.12 17:05:50.150 Pipeline_Illustration (USDJPY,H4) RAW (first 6 rows) [rows=2999, cols=4] 2025.09.12 17:05:50.150 Pipeline_Illustration (USDJPY,H4) 147.625000, 6894.000000, 20.000000, 2.000000 2025.09.12 17:05:50.150 Pipeline_Illustration (USDJPY,H4) 147.837000, 14153.000000, 20.000000, 1.000000 2025.09.12 17:05:50.150 Pipeline_Illustration (USDJPY,H4) 147.885000, 16794.000000, 20.000000, 1.000000 2025.09.12 17:05:50.150 Pipeline_Illustration (USDJPY,H4) 147.489000, 8010.000000, 20.000000, 0.000000 2025.09.12 17:05:50.150 Pipeline_Illustration (USDJPY,H4) 147.219000, 6710.000000, 20.000000, 0.000000 2025.09.12 17:05:50.150 Pipeline_Illustration (USDJPY,H4) 147.194000, 13686.000000, 20.000000, 3.000000 2025.09.12 17:05:50.163 Pipeline_Illustration (USDJPY,H4) TRANSFORMED (FitTransform on all) [rows=2999, cols=32] 2025.09.12 17:05:50.163 Pipeline_Illustration (USDJPY,H4) 0.353976, 0.081606, 0.052632, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.163 Pipeline_Illustration (USDJPY,H4) 0.363616, 0.167533, 0.052632, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.163 Pipeline_Illustration (USDJPY,H4) 0.365798, 0.198795, 0.052632, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.163 Pipeline_Illustration (USDJPY,H4) 0.347792, 0.094816, 0.052632, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.163 Pipeline_Illustration (USDJPY,H4) 0.335516, 0.079428, 0.052632, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.163 Pipeline_Illustration (USDJPY,H4) 0.334379, 0.162005, 0.052632, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) TRAIN (after TransformPipeline) [rows=2249, cols=32] 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) 0.353976, 0.081606, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) 0.363616, 0.167533, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) 0.365798, 0.198795, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) 0.347792, 0.094816, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) 0.335516, 0.079428, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) 0.334379, 0.162005, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) TEST (after TransformPipeline) [rows=750, cols=32] 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) 0.538217, 0.098806, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) 0.536307, 0.280804, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) 0.545628, 0.163082, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) 0.540217, 0.121817, -0.028571, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) 0.533852, 0.093858, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) 0.532215, 0.071675, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, ... 2025.09.12 17:05:50.170 Pipeline_Illustration (USDJPY,H4) Preprocessing pipeline demo complete.
Comparação dos métodos de escalonamento na negociação financeira
A escolha do método de escalonamento mais adequado raramente oferece uma solução universal. Cada método apresenta vantagens e limitações, e a melhor opção geralmente depende do tipo de dados e do comportamento do mercado analisado. A tabela comparativa abaixo destaca as situações em que cada método apresenta melhores resultados:
| Método de escalonamento | Pontos fortes | Pontos fracos | Mais indicado para |
|---|---|---|---|
| Standard-Scaler | Adequado para dados com distribuição gaussiana. Produz características com média zero e variância unitária. | Sensível a valores atípicos. | Indicadores técnicos e abordagens baseadas em volatilidade. |
| Min-Max Scaler | Adequado para funções de ativação com intervalos limitados. Produz valores dentro de um intervalo fixo, geralmente [0,1]. | Muito sensível a valores atípicos, pois valores extremos distorcem o escalonamento. | É indicado para redes neurais com funções de ativação sigmoide ou tangente hiperbólica. |
| Robust Scaler | A utilização da mediana e do intervalo interquartil torna o método menos resistente a valores atípicos. | Possibilidade de desvios frequentes em relação à precisão absoluta do escalonamento. | Análise de dados com distribuições de caudas pesadas, volumes de ticks e spreads em condições de instabilidade do mercado. |
Como vimos na análise anterior, se estivermos treinando uma rede neural simples com indicadores normalizados de retorno dos preços e volatilidade, o Standard-Scaler provavelmente será uma escolha adequada, pois permite colocar diferentes características em escalas comparáveis. Em outro cenário, se utilizarmos um modelo LSTM no formato ONNX, treinado em Python com funções de ativação sigmoides, o escalonamento min-max poderá ser mais apropriado, já que os valores transformados geralmente se ajustam melhor ao intervalo limitado dessas funções de ativação. Por outro lado, ao modelar o comportamento das negociações durante um evento noticioso importante, quando spreads e volumes podem aumentar drasticamente, um método de escalonamento robusto pode ajudar a preservar a estrutura central dos dados, reduzindo a influência desses valores anômalos.
O ponto principal é que o pré-processamento não deve ser tratado como uma etapa secundária. A escolha do método de escalonamento influencia diretamente a maneira como as características interagem durante o treinamento e pode determinar a diferença entre um modelo capaz de generalizar bem e outro que apresenta vieses ou comportamento instável.
Preparação de dados para aprendizado profundo
Os modelos de aprendizado profundo, ou redes neurais, geralmente apresentam requisitos rigorosos quanto aos dados de entrada, independentemente de terem sido desenvolvidos diretamente em MQL5 ou importados por meio do ONNX. Por exemplo, um modelo treinado em Python com dados normalizados poderá apresentar um desempenho inferior ou até falhar completamente se receber características brutas e não escalonadas provenientes do MQL5. Isso reforça a importância dos pipelines de pré-processamento, que não devem ser considerados recursos opcionais, mas componentes essenciais para aplicações de negociação financeira e fluxos de trabalho profissionais.
Considere um modelo ONNX treinado no TensorFlow com preços normalizados por meio do escalonamento min-max. Se esse mesmo modelo for posteriormente implantado em MQL5, mas receber dados OHLC brutos, os pesos aprendidos durante o treinamento não estarão ajustados à escala desses novos dados de entrada, resultando em previsões imprecisas. A inclusão de uma etapa CMinMaxScaler() no pipeline, utilizando os mesmos parâmetros de mínimo e máximo empregados durante o treinamento em Python, garante a consistência do pré-processamento entre os dois ambientes.
Além do escalonamento, a codificação categórica também desempenha um papel importante. Uma rede neural treinada com codificação one-hot, como no exemplo das sessões de negociação apresentado anteriormente, espera receber o mesmo formato binário durante a inferência. Se a correspondência entre categorias e vetores não for mantida, por exemplo, se a Ásia tiver sido representada por [0,1,0] durante o treinamento, mas passar a ser representada por [1,0,0] na inferência, as previsões do modelo poderão perder o sentido. Ao utilizar um pipeline de processamento de dados que registra e preserva os mapeamentos de categorias aprendidos durante o treinamento, reduzimos esse tipo de risco.
A persistência dos dados é outro aspecto fundamental. Parâmetros como médias, valores mínimos e máximos e mapeamentos de categorias precisam ser armazenados após o treinamento e reutilizados durante a inferência. Sem essa consistência, o retreinamento e a inferência podem se tornar progressivamente divergentes. No Python, a biblioteca SCIKIT-LEARN permite serializar esses parâmetros com ferramentas como joblib ou pickle. Em MQL5, os desenvolvedores podem obter um resultado semelhante salvando as variáveis de estado do pipeline, armazenadas em arrays, em arquivos binários (.bin) ou CSV (.csv) e carregando-as novamente durante a inicialização do EA.
Desafios e boas práticas
Embora esses pipelines de pré-processamento contribuam para aumentar a precisão e a consistência dos fluxos de trabalho em MQL5, sua implementação apresenta alguns desafios que precisam ser superados para garantir a confiabilidade dos resultados. Vamos abordar cinco deles. O primeiro envolve o tratamento de valores não numéricos (NaN) e dados ausentes. Os conjuntos de dados financeiros frequentemente contêm valores ausentes devido ao fechamento dos mercados, a registros incompletos de preços ou a fluxos irregulares de dados fornecidos pelas corretoras. Em pipelines desenvolvidos em MQL5, valores como DBL_MIN são frequentemente utilizados como marcadores para identificar registros ausentes. Por isso, é essencial realizar a imputação desses valores de maneira consistente, utilizando métodos como a mediana para dados numéricos ou a moda para dados discretos ou categóricos. Isso evita que informações inválidas sejam fornecidas ao modelo.
O segundo desafio é evitar o vazamento de dados (data leakage). Um erro comum consiste em ajustar os métodos de escalonamento ou codificação utilizando todo o conjunto de dados antes de dividi-lo em conjuntos de treinamento, validação e teste. Essa prática pode permitir que informações futuras influenciem o treinamento, produzindo resultados de desempenho artificialmente elevados. O Testador de Estratégias do MQL5 foi concebido para trabalhar com dados de preços atuais ou históricos, mas, quando são utilizados dados adicionais como entradas do modelo, é necessário realizar verificações específicas para impedir esse tipo de vazamento. A prática recomendada é executar Fit() exclusivamente com os dados de treinamento e, posteriormente, aplicar Transform() separadamente aos conjuntos de treinamento e teste.
O terceiro desafio está relacionado ao escalonamento de diferentes tipos de dados. Quando um conjunto contém características numéricas e categóricas, é necessário aplicar as transformações com cuidado. Para garantir que as novas colunas binárias sejam incorporadas corretamente à matriz numérica resultante, deve-se primeiro aplicar os métodos de codificação e, em seguida, os de escalonamento.
O quarto desafio envolve a depuração das transformações. Para verificar se os resultados estão corretos, é útil imprimir as primeiras linhas dos dados transformados. Recursos de depuração, como a função Print(), permitem identificar rapidamente se as operações de codificação e escalonamento estão sendo executadas corretamente.
Por fim, a reprodutibilidade dos resultados não deve ser considerada algo garantido. Para manter a consistência entre diferentes experimentos, os parâmetros do pipeline de processamento de dados, incluindo valores mínimos, medianas e mapeamentos de categorias, precisam ser armazenados junto com o modelo treinado. Isso garante que exatamente as mesmas transformações de pré-processamento possam ser aplicadas durante os backtests, na negociação em tempo real e até mesmo no retreinamento do modelo.
Seguir essas cinco recomendações ajudará os desenvolvedores a evitar erros comuns e a alcançar, nos pipelines de processamento de dados em MQL5, o mesmo nível de confiabilidade de seus equivalentes em Python.
Conclusão
O pré-processamento de dados certamente não é a parte mais atraente do machine learning, mas provavelmente é uma de suas etapas mais importantes. Sem uma preparação cuidadosa, até mesmo os modelos de aprendizado profundo mais avançados terão dificuldades para lidar com dados de negociação brutos, não escalonados ou codificados de maneira inconsistente. Para os desenvolvedores familiarizados com o MetaTrader 5, essa limitação tradicionalmente representa um obstáculo à adoção plena dos fluxos de trabalho de machine learning. Diferentemente do Python, que conta com as ferramentas avançadas do SCIKIT-LEARN, o MQL5 não oferece pipelines nativos de pré-processamento. Como demonstramos, uma solução possível é desenvolver pipelines de pré-processamento modulares e reutilizáveis diretamente em MQL5.
Ao tratar esses componentes não como ferramentas opcionais, mas como partes essenciais dos fluxos de trabalho de inteligência artificial, os desenvolvedores poderão adaptar seus sistemas de negociação aos requisitos rigorosos do machine learning, oferecendo à maioria dos modelos, sejam eles desenvolvidos pelos próprios usuários ou baseados em ONNX, as melhores condições possíveis para alcançar bons resultados.
| Nome | Descrição |
|---|---|
| PipeLine.mqh | Classe base que implementa as funcionalidades do pipeline. |
| Pipeline_Illustration.mq5 | Script que faz referência à classe base e demonstra como utilizá-la. |
Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/19544
Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.
Esse artigo foi escrito por um usuário do site e reflete seu ponto de vista pessoal. A MetaQuotes Ltd. não se responsabiliza pela precisão das informações apresentadas nem pelas possíveis consequências decorrentes do uso das soluções, estratégias ou recomendações descritas.