Perspectivas bursátiles a través del volumen: más allá de los gráficos OHLC

Introducción

En el campo del análisis técnico, los operadores han confiado históricamente en las fluctuaciones de precios como su principal indicador de la actividad del mercado. Este trabajo presenta una metodología única que combina el análisis matemático avanzado del volumen con técnicas de aprendizaje automático, haciendo hincapié en cómo los patrones de volumen pueden proporcionar una visión más profunda de la dinámica del mercado. Ofrecemos un sofisticado sistema que supera los métodos de análisis técnico convencionales al combinar redes neuronales LSTM con derivadas de volumen basadas en cálculo.

El artículo se divide en tres secciones principales: la primera analiza la importancia fundamental del análisis del volumen y sus bases matemáticas; la segunda examina las aplicaciones prácticas de las derivadas del volumen y las predicciones LSTM en la identificación de oportunidades de mercado; y la tercera explica cómo el análisis de la divergencia del volumen, la confirmación de tendencias y la validación de rupturas pueden utilizarse para mejorar las decisiones de negociación.

Comprender la función principal del volumen

El número total de acciones o contratos negociados durante un período de tiempo específico se conoce como volumen, y es un indicador crucial de la actividad y la liquidez del mercado. Mientras que el precio muestra la dirección del mercado, el volumen muestra la confianza que hay detrás de un movimiento del mercado, destacando la fuerza subyacente y la durabilidad de las tendencias. Es la fuerza que impulsa la evolución de los precios y tiene la capacidad de respaldar o contradecir los movimientos de los precios, ya que los cambios significativos de precios con un volumen elevado suelen indicar niveles de confianza del mercado más altos que aquellos con un volumen reducido. Además, los patrones de volumen suelen predecir cambios en los precios, lo que los convierte en indicaciones valiosas para los operadores que saben cómo utilizarlos junto con la evolución de los precios y el contexto del mercado.

Por qué el volumen es importante

Ejemplo sencillo:

La importancia crucial del análisis de volumen puede demostrarse utilizando una sofisticada técnica matemática que va más allá del análisis estándar, proporcionando a los operadores un marco más avanzado para comprender la dinámica del mercado que el que ofrecen los indicadores convencionales por sí solos. Al centrarnos únicamente en la dinámica del volumen, independientemente de los datos OHLC, podemos obtener información importante sobre el mercado mediante el uso del cálculo y el aprendizaje automático, con especial énfasis en los derivados del volumen y las redes neuronales LSTM. Este novedoso método utiliza sofisticadas ideas matemáticas para identificar cambios minúsculos en el comercio y la participación en el mercado, lo que permite alertar con antelación sobre posibles movimientos del mercado antes de que se reflejen en la evolución de los precios.

Los operadores pueden detectar nuevas tendencias y posibles reversiones con mayor precisión que con las técnicas convencionales de análisis de volumen, observando la tasa de cambio en el volumen (derivada primera) y su aceleración (derivada segunda) junto con las previsiones del aprendizaje automático. Cuando se aplica correctamente, esta base matemática proporciona un enfoque sólido para el análisis de mercado que puede resultar especialmente útil en los mercados actuales, impulsados por algoritmos, en los que el análisis técnico convencional puede no ser suficiente.

Este método analiza tres componentes importantes del volumen: la primera derivada (tasa de cambio del volumen), la segunda derivada (aceleración del cambio del volumen) y las proyecciones LSTM del volumen futuro que confirman las mismas derivadas del volumen. Al eliminar el ruido de los precios, este enfoque se centra exclusivamente en la dinámica de participación en el mercado. 

El EA comienza con las declaraciones estándar de MetaTrader. Incluye la biblioteca Trade para la gestión de pedidos y la biblioteca personalizada Volume_LSTM para predicciones. La propiedad indicator_separate_window indica que esto se mostrará en una ventana separada y asigna tres búferes de indicadores para la visualización.

#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;

Los parámetros están organizados en grupos lógicos. La sección de configuración de LSTM controla el comportamiento de la red neuronal, mientras que los parámetros de entrada administran las reglas comerciales. Cada parámetro tiene un propósito específico: los parámetros LSTM controlan la complejidad y la memoria del modelo de predicción. Los parámetros comerciales definen el tamaño de la posición y los objetivos de ganancias, y los parámetros de gestión de riesgos establecen límites de pérdidas y 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;

Esta función calcula la tasa de cambio de volumen (primera derivada) y la aceleración del cambio de volumen (segunda derivada). Cambia las derivadas existentes para mantener el historial, calcula la nueva primera derivada como la diferencia entre el volumen actual y el anterior, calcula la nueva segunda derivada como el cambio en las primeras derivadas y proporciona información sobre el impulso y la aceleración del volumen.

Al observar la primera derivada del volumen, esencialmente estamos rastreando si la actividad comercial aumenta o disminuye con el tiempo. Este patrón de fluctuación del volumen nos brinda nuestra primera capa de información sobre el impulso del mercado. Una primera derivada consistentemente positiva sugiere un creciente interés del mercado, mientras que una negativa sugiere una disminución del compromiso.

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];
}

Estas funciones administran el ciclo de vida comercial, TrackNewTrade registra nuevas posiciones en el primer espacio disponible y RemoveTrade borra el registro cuando se cierran las posiciones. Ambas funciones mantienen la integridad del sistema de seguimiento comercial.

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;
        }
    }
}

Esta función de seguimiento de ganancias:

1. Identifica el día de negociación actual.
2. Calcula las ganancias obtenidas de las operaciones cerradas.
3. Añade ganancias no realizadas de posiciones abiertas.
4. Mantiene el seguimiento diario de las ganancias en múltiples operaciones.
5. Ayuda a hacer cumplir los límites de pérdidas diarias.

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;
}

La función de stop dinámico:

1. Itera a través de todas las posiciones abiertas.
2. Calcula la ganancia en puntos para cada posición.
3. Actualiza los niveles de stop loss en función de las ganancias.
4. Implementa un mecanismo de seguimiento para fijar las ganancias.
5. Maneja posiciones de compra y venta de manera diferente.

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
        }
    }
}

Al mostrar la aceleración o desaceleración de la actividad comercial, la segunda derivada del volumen proporciona información aún más detallada. Un valor positivo para esta segunda derivada es un fuerte indicio de un impulso creciente del mercado, ya que muestra que el volumen está aumentando y lo hace a un ritmo acelerado. Debido a que indica un interés cada vez mayor de los participantes del mercado, esta aceleración del volumen ocurre con frecuencia antes de movimientos notables del mercado. Proporcionamos un marco sólido para predecir el comportamiento del mercado fusionando estos derivados con predicciones de redes neuronales LSTM de patrones de volumen futuros. Nuestro estudio obtiene una capa adicional de validación gracias a la capacidad del LSTM para identificar patrones intrincados en secuencias de volumen, lo que ayuda a determinar si es probable que persistan las tendencias de volumen observadas.

La lógica comercial principal:

1. Comprueba la formación de nuevas barras.
2. Verifica los límites de pérdidas diarias.
3. Actualiza la información comercial.
4. Realiza análisis de volumen.
5. Genera predicciones LSTM si está habilitado.
6. Toma decisiones comerciales basadas en múltiples factores.
7. Abre posiciones cuando las condiciones se alinean.

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
        }
    }
}

Los cálculos del indicador técnico:

1. Configurar buffers de datos para valores de indicadores.
2. Copiar datos de indicadores desde los controladores.
3. Actualizar matrices locales con nuevos valores.
4. Mantener datos de indicadores para la toma de decisiones.

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 trabaja en conjunto para crear un sistema comercial integral que combina análisis de volumen, predicciones LSTM e indicadores técnicos tradicionales manteniendo prácticas sólidas de gestión de riesgos.

El archivo Volume_LSTM.mqh implementa una red neuronal de memoria a corto y largo plazo (LSTM) diseñada específicamente para predecir volúmenes comerciales.

El código comienza con una estructura Matrix2D fundamental que maneja operaciones de matriz 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
}

La célula LSTM se implementa como una estructura integral:

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;
};

La implementación incluye funciones de activación de redes neuronales estándar:

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

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

Los pesos se inicializan utilizando una variación de la inicialización de 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
        }
    }
}

La implementación incluye la normalización de datos:

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;
    }
}

La lógica central de predicción:

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, estos son los resultados para EURUSD con períodos de tiempo de 30 minutos. Estos son los ajustes Setting_eurusd.set

GBPUSD con período de marco de tiempo de 30 minutos.

GBPUSD_settings.set

Una gran optimización podría llevar a obtener mejores resultados en pares grandes, y la falta de tiempo no ayuda a extender este artículo. Recomiendo encarecidamente realizar una gran optimización para cada par y espero que algunos usuarios agreguen comentarios con nuevas configuraciones posibles en los comentarios.

Técnicas avanzadas

Confirmación de tendencia

Un alto volumen durante los aumentos de precios indica un fuerte apoyo del mercado y una probable continuación de la tendencia. Por el contrario, un volumen elevado durante las bajadas de precios refleja una fuerte presión de venta y confirma una tendencia negativa. Un volumen bajo durante los movimientos de precios advierte sobre tendencias débiles o insostenibles, lo que a menudo indica rupturas falsas o manipulación.

Validación de ruptura

Las rupturas con gran volumen confirman la convicción del mercado, lo que conduce a cambios de precios sostenidos. Las rupturas de bajo volumen a menudo resultan en señales falsas, como "trampas alcistas" o "trampas bajistas", y es probable que fallen. Los picos de volumen durante las rupturas validan fuertemente el movimiento e indican un sólido soporte del mercado.

Divergencia de volumen

La divergencia de volumen, donde las tendencias de precios y volumen difieren, indica posibles reversiones o debilidades en las tendencias. La caída del volumen con precios en aumento indica un debilitamiento de la tendencia alcista, mientras que la caída del volumen con precios en descenso sugiere una menor presión de venta y un posible fondo del mercado. Estos patrones pueden ayudar a identificar puntos de inflexión cuando se combinan con otros indicadores.

Conclusión

Al fusionar métodos de aprendizaje automático de vanguardia con el análisis de volumen convencional, el EA de comercio basado en volumen ofrece un método avanzado de comercio algorítmico. El sistema exhibe un enfoque sólido para la investigación de mercado y la ejecución comercial al utilizar redes neuronales LSTM para la predicción del volumen, además de indicadores técnicos tradicionales como ADX y OBV.

El enfoque de múltiples capas del EA para la gestión de riesgos, que incluye estrictos límites de pérdidas diarias, trailing stops dinámicos y un exhaustivo seguimiento de posiciones, es su punto más fuerte. Este énfasis en la gestión de riesgos, junto con parámetros de entrada ajustables y gestión de sesiones variables, brinda a los traders una herramienta flexible que puede adaptarse a diferentes situaciones del mercado y al mismo tiempo mantener procedimientos comerciales disciplinados.

Lo más importante es que se produce un sistema híbrido especial combinando el análisis de las derivadas de volumen con las predicciones LSTM. Gracias a esta combinación, el EA puede detectar cambios en el mercado antes de que se materialicen por completo, y la validación de los indicadores convencionales ayuda a reducir las señales falsas. La estructura de código modular también permite realizar mejoras futuras y un mantenimiento sencillo.

Sin embargo, los usuarios deben tener en cuenta que, debido a la complejidad del sistema, es necesario realizar pruebas retrospectivas meticulosas y ajustar los parámetros antes de la implementación en vivo. A pesar de su potencia, el componente LSTM requiere una gran cantidad de potencia de procesamiento y datos de entrenamiento adecuados. A pesar de estos problemas, el EA es una herramienta útil para los traders que buscan automatizar sus métodos de trading basados en el volumen debido a su profundo compromiso con la fusión de tecnología de vanguardia con conceptos de trading probados y verdaderos.

Espero que este artículo sea útil para considerar el uso de OHLCV y no sólo los precios.

Nombre del archivo	Descripción
MQL5/Profiles/Tester/Setting_eurusd.set	Configuración de entradas, por ejemplo, con EURUSD
MQL5/Profiles/Tester/GBPUSD_settings.set	Configuración de entradas, por ejemplo, GBPUSD
MQL5/Experts/Volume_high_low_difference_LSTM.mq5	Asesor experto para utilizar en los ejemplos
MQL5/Include/Volume_LSTM.mqh	Archivo "Include" (.mqh). Recuerda cambiar la ruta en el EA respecto a dónde lo guardaste.