Informações detalhadas sobre trading baseado em volume: Indo além dos gráficos OHLC

Introdução

No campo da análise técnica, os traders historicamente confiaram nas oscilações de preço como o principal indicador da atividade do mercado. Este trabalho apresenta uma metodologia única, que combina análise matemática avançada do volume com métodos de machine learning, destacando como os padrões de volume podem oferecer uma compreensão mais profunda da dinâmica do mercado. Propomos um sistema sofisticado que supera os métodos tradicionais de análise técnica, unindo redes neurais LSTM com derivadas do volume baseadas em análise matemática.

O artigo está dividido em três partes principais: na primeira, discute-se a importância fundamental da análise de volume e suas bases matemáticas; na segunda, examina-se a aplicação prática das derivadas do volume e das previsões LSTM para identificar oportunidades de mercado; e na terceira, é explicado como a análise de divergência de volumes, a confirmação de tendência e a validação de rompimentos podem ser utilizados para aumentar a eficácia das decisões de trading.

Compreendendo a função principal do volume

O número total de ações ou contratos negociados em um determinado período de tempo é chamado de volume e é um dos indicadores mais importantes da atividade de mercado e da liquidez. Enquanto o preço mostra a direção do movimento do mercado, o volume revela a confiança por trás desse movimento, destacando a força subjacente e a durabilidade das tendências. Ele é a força motriz por trás das variações de preço, podendo sustentar ou contradizer as mudanças, já que variações significativas de preço com alto volume geralmente indicam um nível maior de confiança do mercado do que quando ocorrem com baixo volume. Além disso, os padrões de volume muitas vezes antecipam mudanças de preço, tornando-se guias valiosos para traders que sabem como utilizá-los em conjunto com o comportamento dos preços e o contexto do mercado.

Por que o volume importa

Um exemplo simples:

A importância crítica da análise de volume pode ser demonstrada por meio de um método matemático avançado, que vai além da análise padrão, oferecendo aos traders uma base mais sofisticada para compreender a dinâmica do mercado do que seria possível apenas com indicadores convencionais. Ao focar exclusivamente na dinâmica dos volumes, independentemente dos dados OHLC, é possível extrair informações relevantes do mercado com o auxílio da análise matemática e do machine learning, com especial atenção às derivadas do volume e às redes neurais LSTM. Esse novo método aplica conceitos matemáticos complexos para identificar mudanças sutis no trading e na participação de mercado, fornecendo alertas precoces sobre possíveis alterações antes mesmo que se manifestem no movimento dos preços.

Os traders conseguem detectar novas tendências e possíveis reversões com maior precisão do que pelos métodos convencionais de análise de volume, ao observar a velocidade de variação do volume (primeira derivada) e sua aceleração (segunda derivada), em conjunto com as previsões do machine learning. Quando aplicado corretamente, esse alicerce matemático fornece uma abordagem eficaz para a análise de mercado, que pode ser especialmente útil nos ambientes atuais dominados por algoritmos, onde a análise técnica tradicional pode não ser suficiente.

Esse método considera três componentes essenciais do volume: a primeira derivada (velocidade de variação do volume), a segunda derivada (aceleração da variação do volume) e as previsões LSTM para o volume futuro, que validam essas mesmas derivadas. Ao eliminar o ruído dos preços, essa abordagem concentra-se exclusivamente na dinâmica da participação de mercado. 

O EA começa com as declarações padrão do MetaTrader. Ele inclui a biblioteca de trading para o gerenciamento de ordens e a biblioteca personalizada Volume_LSTM para previsões. A propriedade indicator_separate_window indica que os resultados serão exibidos em uma janela separada e reserva três buffers de indicadores para visualização.

#property copyright "Your Name"
#property version   "1.00"
#property strict
#property indicator_separate_window
#property indicator_buffers 3
#include <Trade\Trade.mqh>
#include <Volume_LSTM.mqh>
CTrade trade;

Os parâmetros são organizados em grupos lógicos. A seção de configuração da LSTM controla o comportamento da rede neural, enquanto os parâmetros de entrada regem as regras de trading. Cada parâmetro possui uma função definida: os parâmetros da LSTM ajustam a complexidade do modelo de previsão e a capacidade de memória. Os parâmetros de trading determinam o tamanho das posições e as metas de lucro, enquanto os parâmetros de gestão de risco definem os limites de perdas e os trailing stops.

input group "Configuración LSTM"
input bool     UseLSTM = true;              
input int      LSTMHiddenSize = 32;         
input int      LSTMLookback = 10;           

input group "Entry Parameters"
input double   Lots = 0.1;         
input double   TPPoints = 100;      
input int      Periods = 4;         
input int      AccelBars = 4;       
input int      MaxBarsInTrade = 2; 
input double   ProfitClose = 15;    
input double   MaxDailyLoss = -25; 
input double   TrailingStart = 5;  
input double   TrailingStep = 5;

Essa função calcula a velocidade de variação do volume (primeira derivada) e a aceleração da variação do volume (segunda derivada). Ela atualiza as derivadas existentes para preservar o histórico, calcula a nova primeira derivada como a diferença entre o volume atual e o anterior, calcula a nova segunda derivada como a variação das primeiras derivadas e fornece informações sobre a dinâmica e a aceleração do volume.

Ao observar a primeira derivada do volume, estamos basicamente acompanhando se a atividade de trading está aumentando ou diminuindo ao longo do tempo. Esse padrão de flutuações do volume nos dá a primeira noção da dinâmica do mercado. Uma primeira derivada consistentemente positiva indica crescimento do interesse do mercado, enquanto uma negativa aponta para redução desse interesse.

void CalculateDerivatives() {
    for(int i = 0; i < ArraySize(volumes)-1; i++) {
        firstDerivative[i] = firstDerivative[i+1];
        secondDerivative[i] = secondDerivative[i+1];
    }

    firstDerivative[ArraySize(volumes)-1] = volumes[ArraySize(volumes)-1] - volumes[ArraySize(volumes)-2];
    secondDerivative[ArraySize(volumes)-1] = firstDerivative[ArraySize(volumes)-1] - firstDerivative[ArraySize(volumes)-2];
}

Essas funções controlam o ciclo de vida das operações, TrackNewTrade registra novas posições no primeiro slot disponível, RemoveTrade limpa o registro quando as posições são encerradas. Obe funções mantêm a integridade do sistema de acompanhamento das operações.

void TrackNewTrade(ulong ticket) {
    for(int i = 0; i < ArraySize(openTrades); i++) {
        if(openTrades[i].ticket == 0) {
            openTrades[i].ticket = ticket;
            openTrades[i].openTime = TimeCurrent();
            openTrades[i].barsOpen = 0;
            break;
        }
    }
}

void RemoveTrade(ulong ticket) {
    for(int i = 0; i < ArraySize(openTrades); i++) {
        if(openTrades[i].ticket == ticket) {
            openTrades[i].ticket = 0;
            openTrades[i].openTime = 0;
            openTrades[i].barsOpen = 0;
            break;
        }
    }
}

Essa função de monitoramento de lucro:

1. Define o dia de trading atual
2. Calcula o lucro realizado das operações fechadas
3. Adiciona o lucro não realizado das posições abertas
4. Mantém o acompanhamento diário de lucros em múltiplas operações
5. Ajuda a respeitar os limites diários de perda

double GetDailyProfit() {
    datetime today = StringToTime(TimeToString(TimeCurrent(), TIME_DATE));

    if(lastDayChecked != today) {
        lastDayChecked = today;
        dailyProfit = 0;

        HistorySelect(today, TimeCurrent());
        int deals = HistoryDealsTotal();

        for(int i = 0; i < deals; i++) {
            ulong ticket = HistoryDealGetTicket(i);
            if(ticket > 0) {
                if(HistoryDealGetString(ticket, DEAL_SYMBOL) == _Symbol)
                    dailyProfit += HistoryDealGetDouble(ticket, DEAL_PROFIT);
            }
        }
    }
    
    // Add floating P/L
    double floatingProfit = 0;
    for(int i = PositionsTotal() - 1; i >= 0; i--) {
        ulong ticket = PositionGetTicket(i);
        if(ticket > 0 && PositionSelectByTicket(ticket)) {
            if(PositionGetString(POSITION_SYMBOL) == _Symbol)
                floatingProfit += PositionGetDouble(POSITION_PROFIT);
        }
    }

    return dailyProfit + floatingProfit;
}

A função de trailing stop:

1. Percorre todas as posições abertas
2. Calcula o lucro em pontos de cada posição
3. Atualiza os níveis de stop loss conforme o lucro
4. Implementa o mecanismo de trailing para proteger ganhos
5. Trata operações de compra e venda de forma diferenciada

void ApplyTrailingStop(double point) {
    for(int i = PositionsTotal() - 1; i >= 0; i--) {
        ulong ticket = PositionGetTicket(i);
        if(ticket <= 0) continue;

        if(PositionSelectByTicket(ticket)) {
            double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
            double currentPrice = PositionGetDouble(POSITION_PRICE_CURRENT);
            double currentSL = PositionGetDouble(POSITION_SL);
            long posType = PositionGetInteger(POSITION_TYPE);

            // Calculate and update trailing stop
            double profitPoints;
            if(posType == POSITION_TYPE_BUY) {
                profitPoints = (currentPrice - openPrice) / point;
                if(profitPoints >= TrailingStart) {
                    double newSL = openPrice + (profitPoints - TrailingStep) * point;
                    if(currentSL < newSL || currentSL == 0) {
                        trade.PositionModify(ticket, newSL, PositionGetDouble(POSITION_TP));
                    }
                }
            }
            // Similar logic for SELL positions
        }
    }
}

Mostrando a aceleração ou desaceleração da atividade de trading, a segunda derivada do volume fornece ainda mais detalhes. Um valor positivo dessa segunda derivada é uma forte evidência de que a dinâmica de mercado está aumentando, já que mostra que o volume cresce em ritmo acelerado. Como isso indica um rápido crescimento no interesse dos participantes, esse aumento de volume geralmente antecede mudanças relevantes no mercado. Fornecemos uma base confiável para prever o comportamento do mercado, ao combinar essas derivadas com previsões de volumes futuros usando a rede neural LSTM. Nossa pesquisa recebeu uma camada adicional de validação graças à capacidade da LSTM de identificar padrões complexos na sequência de volumes, o que ajuda a determinar se as tendências observadas no volume tendem a persistir.

A lógica principal de trading:

1. Verifica a formação de novas barras
2. Checa os limites diários de perda
3. Atualiza as informações da operação
4. Executa a análise de volume
5. Gera previsões LSTM, se habilitadas
6. Toma decisões de trading com base em múltiplos fatores
7. Abre posições quando as condições coincidem

void OnTick() {
    static datetime lastBar = 0;
    datetime currentBar = iTime(_Symbol, PERIOD_CURRENT, 0);

    if(lastBar == currentBar) return;
    lastBar = currentBar;

    if(GetDailyProfit() < MaxDailyLoss) {
        CloseAllPositions();
        return;
    }

    // Update and calculate
    UpdateTradesInfo();
    CheckTimeBasedClose();
    
    if(!CanTrade()) return;

    // Volume analysis and LSTM prediction
    // ... volume calculations ...
    
    if(UseLSTM && volumePredictor != NULL) {
        // LSTM prediction logic
        // ... prediction calculations ...
    }

    CalculateDerivatives();
    
    // Trading decisions based on calculations
    if(consecutiveAccel >= AccelBars) {
        if((!UseADX && !UseOBV) || ConfirmLongSignal()) {
            // Open buy position
        }
    }
    else if(consecutiveAccel <= -AccelBars) {
        if(!UseADX && !UseOBV || ConfirmShortSignal()) {
            // Open sell position
        }
    }
}

Cálculos de indicadores técnicos:

1. Configuração dos buffers de dados para os valores dos indicadores
2. Cópia dos dados dos indicadores a partir dos handles
3. Atualização dos arrays locais com novos valores
4. Manutenção dos dados dos indicadores para suporte às decisões

void CalculateADX() {
    if(!UseADX) return;

    double adx_buffer[];
    double plusdi_buffer[];
    double minusdi_buffer[];
    ArraySetAsSeries(adx_buffer, true);
    ArraySetAsSeries(plusdi_buffer, true);
    ArraySetAsSeries(minusdi_buffer, true);

    CopyBuffer(adx_handle, MAIN_LINE, 0, ArraySize(adx_main), adx_buffer);
    CopyBuffer(adx_handle, PLUSDI_LINE, 0, ArraySize(adx_plus), plusdi_buffer);
    CopyBuffer(adx_handle, MINUSDI_LINE, 0, ArraySize(adx_minus), minusdi_buffer);

    ArrayCopy(adx_main, adx_buffer);
    ArrayCopy(adx_plus, plusdi_buffer);
    ArrayCopy(adx_minus, minusdi_buffer);
}

Cada componente atua em conjunto, formando um sistema de trading abrangente, que combina análise de volumes, previsões LSTM e indicadores técnicos tradicionais, mantendo ao mesmo tempo métodos consistentes de gestão de risco.

O arquivo Volume_LSTM.mqh implementa a rede neural de memória de longa e curta duração (LSTM), projetada especificamente para a previsão dos volumes de trading.

O código começa com a estrutura fundamental Matrix2D, responsável pelo tratamento das operações matriciais 2D:

struct Matrix2D {
    double values[];
    int rows;
    int cols;
    
    void Init(int r, int c) {
        rows = r;
        cols = c;
        ArrayResize(values, rows * cols);
        ArrayInitialize(values, 0);
    }
    // ... other methods
}

A célula LSTM é implementada como uma estrutura complexa:

struct LSTMCell {
    double forget_gate[];
    double input_gate[];
    double cell_state[];
    double output_gate[];
    double hidden_state[];
    
    Matrix2D Wf;  // Forget gate weights
    Matrix2D Wi;  // Input gate weights
    Matrix2D Wc;  // Cell state weights
    Matrix2D Wo;  // Output gate weights
    
    double bf[];  // Forget gate bias
    double bi[];  // Input gate bias
    double bc[];  // Cell state bias
    double bo[];  // Output gate bias
    
    int hidden_size;
    int input_size;
};

A implementação inclui as funções padrão de ativação da rede neural:

double Sigmoid(double x) {
    return 1.0 / (1.0 + MathExp(-x));
}

double Tanh(double x) {
    return (MathExp(x) - MathExp(-x)) / (MathExp(x) + MathExp(-x));
}

Os pesos são inicializados com a técnica de inicialização Xavier/Glorot:

void InitializeWeights() {
    double scale = MathSqrt(2.0 / (lstm.input_size + lstm.hidden_size));
    
    // Initialize weight matrices
    lstm.Wf.Init(lstm.hidden_size, lstm.input_size);
    lstm.Wi.Init(lstm.hidden_size, lstm.input_size);
    // ... other initializations

    // Random initialization with scaling
    for(int i = 0; i < lstm.hidden_size; i++) {
        for(int j = 0; j < lstm.input_size; j++) {
            lstm.Wf.Set(i, j, (MathRand() / 32768.0 - 0.5) * scale);
            // ... other weight initializations
        }
    }
}

A implementação contempla a normalização dos dados:

void NormalizeVolumes() {
    volume_mean = 0;
    double sum_squared = 0;
    
    // Calculate mean
    for(int i = 0; i < ArraySize(historical_volumes); i++) {
        volume_mean += historical_volumes[i];
    }
    volume_mean /= ArraySize(historical_volumes);
    
    // Calculate standard deviation
    for(int i = 0; i < ArraySize(historical_volumes); i++) {
        sum_squared += MathPow(historical_volumes[i] - volume_mean, 2);
    }
    volume_std = MathSqrt(sum_squared / ArraySize(historical_volumes));
    
    // Normalize volumes
    if(volume_std == 0) volume_std = 1;  // Prevent division by zero
    for(int i = 0; i < ArraySize(historical_volumes); i++) {
        historical_volumes[i] = (historical_volumes[i] - volume_mean) / volume_std;
    }
}

Lógica principal de previsão:

double PredictNextVolume() {
    if(!is_initialized) return 0;
    
    double input1 = historical_volumes[ArraySize(historical_volumes)-1];
    
    // LSTM forward pass
    for(int h = 0; h < lstm.hidden_size; h++) {
        double ft = 0, it = 0, ct = 0, ot = 0;
        
        // Calculate gates
        for(int i = 0; i < lstm.input_size; i++) {
            ft += lstm.Wf.Get(h, i) * input1;
            it += lstm.Wi.Get(h, i) * input1;
            ct += lstm.Wc.Get(h, i) * input1;
            ot += lstm.Wo.Get(h, i) * input1;
        }
        
        // Apply gates and calculate states
        lstm.forget_gate[h] = Sigmoid(ft + lstm.bf[h]);
        lstm.input_gate[h] = Sigmoid(it + lstm.bi[h]);
        double c_tilde = Tanh(ct + lstm.bc[h]);
        lstm.cell_state[h] = lstm.forget_gate[h] * lstm.cell_state[h] + 
                            lstm.input_gate[h] * c_tilde;
        lstm.output_gate[h] = Sigmoid(ot + lstm.bo[h]);
        lstm.hidden_state[h] = lstm.output_gate[h] * Tanh(lstm.cell_state[h]);
    }
    
    // Calculate final prediction
    double prediction = 0;
    for(int h = 0; h < lstm.hidden_size; h++)
        prediction += lstm.hidden_state[h];
    prediction /= lstm.hidden_size;
    
    return prediction * volume_std + volume_mean;  // Denormalize
}

Resultados

EURUSD, estes são os resultados para o par EURUSD em períodos de 30 minutos. Abaixo estão os parâmetros Setting_eurusd.set

GBPUSD em timeframe de 30 minutos.

GBPUSD settings.set

Uma otimização mais ampla pode levar a resultados ainda melhores nos pares principais, mas a limitação de tempo impede que este artigo se aprofunde nesse aspecto. Recomendo fortemente a realização de uma otimização mais extensa para cada par e espero que alguns usuários compartilhem comentários com novas configurações possíveis na seção de comentários.

Métodos avançados

Confirmação de tendência

Alto volume de compras durante a alta dos preços indica forte suporte de mercado e provável continuidade da tendência. Da mesma forma, alto volume de vendas durante a queda dos preços reflete intensa pressão vendedora e confirma a tendência negativa. Baixo volume durante movimentos de preço alerta sobre tendências fracas ou instáveis, frequentemente sinalizando falsos rompimentos ou manipulações.

Confirmação de rompimento

Rompimentos acompanhados de altos volumes confirmam a confiança do mercado, resultando em mudanças de preço mais sustentáveis. Já rompimentos em baixos volumes frequentemente produzem falsos sinais, como "armadilhas de alta" ou "armadilhas de baixa", que tendem a falhar. Saltos abruptos no volume durante os rompimentos reforçam de forma convincente esse movimento, indicando um suporte confiável do mercado.

Divergência de volumes

A divergência de volumes, na qual as tendências de preço e volume se movem em direções diferentes, sinaliza possíveis reversões ou fragilidade nas tendências. A queda do volume durante a alta dos preços indica enfraquecimento da tendência de alta, enquanto a redução do volume durante a queda dos preços sugere diminuição da pressão vendedora e possível formação de fundo de mercado. Combinados a outros indicadores, esses padrões podem auxiliar na identificação de pontos de virada.

Considerações finais

Ao unir métodos modernos de machine learning com a análise tradicional de volumes, o EA baseado em volume oferece uma abordagem contemporânea para o trading algorítmico. O sistema demonstra uma forma eficaz de analisar o mercado e executar operações, utilizando redes neurais LSTM para previsão de volumes em conjunto com indicadores técnicos tradicionais, como ADX e OBV.

A abordagem em múltiplos níveis do EA para gestão de riscos, que inclui limites diários de perdas bem definidos, trailing stops dinâmicos e monitoramento rigoroso das posições, constitui um de seus pontos fortes. Essa ênfase no gerenciamento de riscos, combinada com parâmetros de entrada configuráveis e controle flexível de sessões, oferece ao trader uma ferramenta adaptável a diferentes cenários de mercado, sem abrir mão de procedimentos de trading disciplinados.

O aspecto mais relevante é que se cria um sistema híbrido especializado ao combinar a análise das derivadas do volume com previsões via LSTM. Graças a essa integração, o EA consegue identificar mudanças no mercado antes que elas se consolidem, enquanto a verificação por indicadores tradicionais contribui para reduzir falsos sinais. A estrutura modular do código também facilita futuras melhorias e simplifica a manutenção.

No entanto, os usuários devem estar cientes de que, devido à complexidade do sistema, é essencial realizar backtests detalhados e ajustar cuidadosamente os parâmetros antes de qualquer uso em conta real. Apesar de seu potencial, o componente LSTM exige alta capacidade de processamento e dados de treinamento adequados. Mesmo com esses desafios, o EA representa uma ferramenta valiosa para traders que buscam automatizar estratégias baseadas em volume, por sua capacidade de integrar tecnologias avançadas com conceitos comprovados de trading.

Espero que este artigo seja útil para a análise do uso de OHLCV, e não apenas de preços.

Nome do arquivo	Descrição
MQL5/Profiles/Tester/Setting_eurusd.set	Configuração de entrada, no exemplo do par de moedas EURUSD
MQL5/Profiles/Tester/GBPUSD_settings.set	Configuração de entrada, no exemplo do par de moedas GBPUSD
MQL5/Experts/Volume_high_low_difference_LSTM.mq5	EA para uso nos exemplos
MQL5/Include/Volume_LSTM.mqh	Incluir o arquivo mqh. Não se esqueça de alterar o caminho no EA, indicando o local de armazenamento