Red neuronal cuántica en MQL5 (Parte I): Creamos un archivo de inclusión

Imagínese a un tráder que nunca duerme, nunca entra en pánico y es capaz de analizar miles de patrones de mercado simultáneamente. Además, imagínese que este tráder tiene la memoria de un elefante, la intuición de un genio y la capacidad de aprender al instante. ¿Suena a ciencia ficción? Bienvenido al mundo de las redes neuronales cuánticas en MQL5.

Lo que estamos creando hoy va mucho más allá del simple aprendizaje automático: se trata de una simbiosis entre la mecánica cuántica y la inteligencia artificial, plasmada en un código que puede ejecutarse directamente en su MetaTrader 5. Nuestra arquitectura no solo predice los movimientos de precios, sino que comprende el mercado en un nivel inaccesible para la conciencia humana. 

Una revolución en la comprensión de la memoria

El cerebro humano opera con varios tipos de memoria simultáneamente. Cuando un tráder experimentado observa un gráfico, recuerda instantáneamente situaciones similares del pasado, analiza el contexto actual y se forma una comprensión intuitiva de lo que podría suceder a continuación. Este principio constituye la base de nuestro ContextAnalyzer, un componente revolucionario que recrea la intuición humana en formato digital.

Nuestro sistema de memoria funciona en cinco niveles, cada uno con su especialización propia. La memoria a corto plazo capta los cambios instantáneos del mercado; cada tick, cada movimiento de precios. La memoria a medio plazo acumula información sobre las tendencias horarias y diarias. La memoria a largo plazo almacena patrones fundamentales que se manifiestan a lo largo de meses y años.

Pero la verdadera magia comienza con la memoria episódica. Esta se activa solo cuando ocurre algo realmente importante: un aumento repentino de la volatilidad, noticias inesperadas o un cambio de tendencia. Estos momentos quedan marcados con una fuerza especial, formando "recuerdos" únicos que el sistema utilizará para reconocer situaciones similares en el futuro.

La arquitectura combina la memoria a través de diferentes horizontes temporales (de corto a largo plazo) para adaptarse a la dinámica del mercado. El mecanismo de atención y los Transformers garantizan la selección de la información clave y la abstracción. El modelo de espacio de estados se encarga de las dependencias temporales, mientras que el analizador de contexto integra la memoria considerando la volatilidad. El procesador cuántico amplifica las señales y suprime el ruido, y el MetaVerificationModel verifica la fiabilidad de las predicciones. Todo funciona como un sistema de autoajuste basado en el pensamiento crítico.

La mecánica cuántica en acción

Las redes neuronales clásicas procesan la información de forma lineal: los datos pasan de la entrada a la salida a través de una secuencia de transformaciones, pero nuestro sistema funciona de forma fundamentalmente diferente: aplicamos los principios de la mecánica cuántica, a saber, superposición, interferencia y resonancia.

Cuando los distintos niveles de memoria interactúan entre sí, crean patrones de interferencia, del mismo modo que las ondas de luz pueden reforzarse o anularse mutuamente. Estas interferencias dan lugar a propiedades emergentes que no se pueden obtener sumando simplemente los componentes.

double resonance_factor = 1.0 + 0.5 * MathCos(input_val * linear_context * M_PI);
double interference = 0.3 * MathSin(short_context * medium_context * 2.0 * M_PI) +
                     0.2 * MathCos(long_context * episodic_context * M_PI) +
                     0.1 * MathSin(pattern_context * input_val * 3.0 * M_PI);

Estas fórmulas no son meros cálculos matemáticos: describen cómo las diferentes "capas de la realidad" del mercado "resuenan" entre sí, creando armonías complejas que nuestro sistema es capaz de reconocer y utilizar para realizar pronósticos.

El Transformer como revolución arquitectónica

En el corazón de la IA moderna se encuentra el mecanismo de atención: la capacidad del modelo para centrarse en la información verdaderamente importante e ignorar el ruido. Nuestro UShapeTransformer lleva esta idea al siguiente nivel.

Imagínese a un director de orquesta que puede oír todos los instrumentos al mismo tiempo y comprender cómo estos interactúan entre sí. El mecanismo de atención funciona de forma similar: calcula la importancia de cada elemento de la secuencia de entrada en relación con todos los demás elementos.

void Forward(Matrix &input_matrix, Matrix &output_matrix)
{
    // Create matrices of queries, keys, and values
    MatrixMultiply(input_matrix, W_q, Q);
    MatrixMultiply(input_matrix, W_k, K);
    MatrixMultiply(input_matrix, W_v, V);
    
    // Calculate attention weights
    for(int i = 0; i < seq_len; i++)
    {
        for(int j = 0; j < seq_len; j++)
        {
            double dot_product = 0.0;
            for(int k = 0; k < d_model; k++)
                dot_product += Q.Get(i, k) * K.Get(j, k);
            attention_weights.Set(i, j, dot_product / MathSqrt(d_model));
        }
    }
}

La arquitectura en forma de U añade otra capa de complejidad: la información pasa primero por un codificador, que comprime y abstrae los datos de entrada, resaltando las características más significativas. El decodificador reconstruye entonces esta información, pero enriquecida con contexto y una comprensión de las conexiones profundas.

La alquimia del código: creando un cerebro digital

El fundamento: la estructura Matrix
Toda estructura compleja comienza con una base sólida. En nuestro caso, hablamos de una estructura Matrix, no solo un contenedor de números, sino un sistema inteligente para gestionar datos multidimensionales.

struct Matrix
{
    double data[];
    int rows, cols;

    void Init(int r, int c)
    {
        rows = r;
        cols = c;
        ArrayResize(data, r * c);
        ArrayInitialize(data, 0.0);
    }

    double Get(int r, int c)
    {
        if(r < 0 || r >= rows || c < 0 || c >= cols) return 0.0;
        return data[r * cols + c];
    }

    void Set(int r, int c, double val)
    {
        if(r < 0 || r >= rows || c < 0 || c >= cols) return;
        data[r * cols + c] = val;
    }

    void Random(double range = 0.5)
    {
        for(int i = 0; i < ArraySize(data); i++)
            data[i] = (MathRand() / 32767.0 - 0.5) * 2.0 * range;
    }
}

Parece una estructura simple, pero incorpora una lógica de seguridad y fiabilidad. Cada acceso a los datos se comprueba y cada operación se controla. Esto resulta especialmente importante para los sistemas financieros, donde un solo error puede costar mucho dinero.

Modelo de espacio de estados: recordando el pasado, mirando hacia el futuro
Los mercados tienen memoria. Lo que sucedió ayer influye en los eventos de hoy. Lo que sucede hoy determina las posibilidades del mañana. StateSpaceModel plasma esta verdad fundamental en forma matemática.

struct StateSpaceModel
{
    Matrix A, B, C;  // State, input, and output matrices
    Matrix state;    // Current state of the system
    int input_size, state_size;

    void ProcessSequence(Matrix &_input, Matrix &output)
    {
        output.Init(_input.rows, _input.cols);
        
        for(int t = 0; t < _input.rows; t++)
        {
            // Extract the current input vector
            Matrix input_row;
            input_row.Init(1, _input.cols);
            for(int j = 0; j < _input.cols; j++)
                input_row.Set(0, j, _input.Get(t, j));

            // Update internal state
            Matrix new_state;
            new_state.Init(1, state_size);
            
            // state = A * state + B * input
            for(int i = 0; i < state_size; i++)
            {
                double sum = 0.0;
                for(int k = 0; k < state_size; k++)
                    sum += A.Get(i, k) * state.Get(0, k);
                
                for(int k = 0; k < _input.cols; k++)
                    sum += B.Get(k, i) * input_row.Get(0, k);
                    
                new_state.Set(0, i, sum);
            }
            
            state = new_state;

            // Calculate output: output = C * state
            for(int j = 0; j < _input.cols; j++)
            {
                double sum = 0.0;
                for(int k = 0; k < state_size; k++)
                    sum += C.Get(k, j) * state.Get(0, k);
                output.Set(t, j, sum);
            }
        }
    }
}

La belleza de este modelo reside en su sencillez y su potencia. Tres matrices determinan cómo evoluciona el sistema a lo largo del tiempo. La matriz A describe la dinámica interna: cómo los estados pasados influyen en los estados futuros. La matriz B define cómo las influencias externas (nuevos datos) cambian el estado del sistema. La matriz C muestra cómo el estado interno se manifiesta en las observaciones externas.

ContextAnalyzer: intuición digital
El componente más complejo e innovador de nuestro sistema es el ContextAnalyzer. Aquí es donde ocurre la verdadera magia: la transformación de datos brutos en una comprensión contextual del mercado.

void ProcessWithContext(Matrix &_input, Matrix &output)
{
    output.Init(_input.rows, _input.cols);

    static Matrix short_term_memory, medium_term_memory, long_term_memory;
    static Matrix episodic_memory, pattern_memory;
    static bool memory_initialized = false;
    static int sequence_counter = 0;
    static double importance_buffer[100];
    static int buffer_index = 0;

    if(!memory_initialized)
    {
        short_term_memory.Init(5, context_size);
        medium_term_memory.Init(50, context_size);
        long_term_memory.Init(10, context_size);
        episodic_memory.Init(20, context_size);
        pattern_memory.Init(15, context_size);
        
        // Initialize all memory types
        ArrayInitialize(short_term_memory.data, 0.0);
        ArrayInitialize(medium_term_memory.data, 0.0);
        ArrayInitialize(long_term_memory.data, 0.0);
        ArrayInitialize(episodic_memory.data, 0.0);
        ArrayInitialize(pattern_memory.data, 0.0);
        ArrayInitialize(importance_buffer, 0.0);
        
        memory_initialized = true;
    }

    sequence_counter++;

    // Analyze input data characteristics
    double input_volatility = 0.0;
    double input_magnitude = 0.0;
    double input_complexity = 0.0;

    // Calculate volatility, magnitude, and complexity
    for(int i = 0; i < _input.rows; i++)
    {
        double row_sum = 0.0, row_variance = 0.0;
        for(int j = 0; j < _input.cols; j++)
        {
            double val = _input.Get(i, j);
            row_sum += val;
            input_magnitude += MathAbs(val);
        }

        double row_mean = row_sum / _input.cols;
        for(int j = 0; j < _input.cols; j++)
        {
            double val = _input.Get(i, j);
            row_variance += (val - row_mean) * (val - row_mean);
        }

        input_volatility += MathSqrt(row_variance / _input.cols);

        // Evaluate complexity through change analysis
        for(int j = 1; j < _input.cols; j++)
        {
            if(MathAbs(_input.Get(i, j) - _input.Get(i, j-1)) > 0.1)
                input_complexity += 1.0;
        }
    }

    input_volatility /= _input.rows;
    input_magnitude /= (_input.rows * _input.cols);
    input_complexity /= (_input.rows * (_input.cols - 1));

El sistema analiza constantemente la naturaleza de los datos entrantes. La alta volatilidad obliga a prestar más atención a la memoria a corto plazo, mientras que los patrones complejos activan la memoria episódica y la memoria de patrones. No son reglas rígidas, sino pesos dinámicos que se adaptan a la situación actual del mercado.

Luego ocurre lo más interesante, es decir, las interacciones cuánticas entre diferentes tipos de memoria:

// Dynamic calculation of weights for different memory types
double short_weight = 0.4 + 0.4 * input_volatility;
double medium_weight = 0.3 + 0.2 * (1.0 - input_volatility);
double long_weight = 0.2 + 0.3 * (1.0 - input_volatility);
double episodic_weight = 0.1 + 0.3 * input_complexity;
double pattern_weight = 0.15 + 0.25 * input_complexity;

// Normalize weights
double total_weight = short_weight + medium_weight + long_weight + episodic_weight + pattern_weight;
short_weight /= total_weight;
medium_weight /= total_weight;
long_weight /= total_weight;
episodic_weight /= total_weight;
pattern_weight /= total_weight;

for(int i = 0; i < _input.rows; i++)
{
    for(int j = 0; j < _input.cols; j++)
    {
        double input_val = _input.Get(i, j);
        double context_idx = j % context_size;

        // Extract context from different memory types
        double short_context = short_term_memory.Get(sequence_counter % 5, context_idx);
        double medium_context = medium_term_memory.Get(sequence_counter % 50, context_idx);
        double long_context = long_term_memory.Get(sequence_counter % 10, context_idx);
        double episodic_context = episodic_memory.Get(sequence_counter % 20, context_idx);
        double pattern_context = pattern_memory.Get(sequence_counter % 15, context_idx);

        // Linear combination of contexts
        double linear_context = short_weight * short_context +
                               medium_weight * medium_context +
                               long_weight * long_context +
                               episodic_weight * episodic_context +
                               pattern_weight * pattern_context;

        // Quantum effects: resonance and interference
        double resonance_factor = 1.0 + 0.5 * MathCos(input_val * linear_context * M_PI);
        double interference = 0.3 * MathSin(short_context * medium_context * 2.0 * M_PI) +
                             0.2 * MathCos(long_context * episodic_context * M_PI) +
                             0.1 * MathSin(pattern_context * input_val * 3.0 * M_PI);

        double nonlinear_factor = 1.0 + input_volatility * MathSin(linear_context * 2.0 * M_PI);

        // Integrate all effects
        double integrated_context = linear_context * resonance_factor * nonlinear_factor + interference;

        // Determine the strength of contextual influence
        double context_strength = 0.4 + 0.3 * input_complexity;
        double final_output = (1.0 - context_strength) * input_val + context_strength * integrated_context;

        output.Set(i, j, final_output);
    }
}

No se trata simplemente de operaciones matemáticas, cada fórmula tiene un significado profundo. La resonancia se produce cuando los datos actuales se "sincronizan" con el contexto acumulado. La interferencia crea patrones complejos de interacción entre diferentes escalas temporales. Los factores no lineales aportan adaptabilidad, lo cual permite que el sistema responda a las cambiantes condiciones del mercado.

El sistema de entrenamiento y adaptación
La verdadera inteligencia no se manifiesta en la capacidad de recordar, sino en la capacidad de aprender y adaptarse. Nuestro sistema analiza constantemente la importancia de la información entrante y actualiza su memoria como corresponde:

// Evaluate the importance of current data
double importance = input_volatility + input_complexity + MathAbs(input_val);
importance_buffer[buffer_index] = importance;
buffer_index = (buffer_index + 1) % 100;

double avg_importance = 0.0;
for(int k = 0; k < 100; k++) avg_importance += importance_buffer[k];
avg_importance /= 100.0;

// Adaptive learning rate
double learning_rate = (importance > avg_importance) ? 0.3 : 0.05;

// Update different memory types at different speeds
double new_short = short_context * (1.0 - 0.4) + final_output * 0.4;
short_term_memory.Set(sequence_counter % 5, context_idx, new_short);

double new_medium = medium_context * (1.0 - 0.1) + final_output * 0.1;
medium_term_memory.Set(sequence_counter % 50, context_idx, new_medium);

double new_long = long_context * (1.0 - 0.02) + final_output * 0.02;
long_term_memory.Set(sequence_counter % 10, context_idx, new_long);

// Episodic memory is activated only for important events
if(importance > avg_importance * 1.5)
{
    double new_episodic = episodic_context * 0.7 + final_output * 0.3;
    episodic_memory.Set(sequence_counter % 20, context_idx, new_episodic);
}

// Pattern memory is updated when correlations are detected
double pattern_correlation = input_val * linear_context;
if(MathAbs(pattern_correlation) > 0.1)
{
    double pattern_update = pattern_correlation * learning_rate;
    double new_pattern = pattern_context * 0.9 + pattern_update * 0.1;
    pattern_memory.Set(sequence_counter % 15, context_idx, new_pattern);
}

El sistema funciona como un organismo vivo: no solo acumula información, sino que entiende qué es importante y qué se puede ignorar. Los acontecimientos importantes se recuerdan durante mucho tiempo, y los datos rutinarios se olvidan rápidamente. Los patrones que se repiten se refuerzan. Y se filtra el ruido aleatorio.

MetaVerificationModel: el arte de la duda
Uno de los principales problemas en el aprendizaje automático es el exceso de confianza en el modelo. El sistema puede generar predicciones con un alto grado de "confianza" incluso cuando los datos de entrada son inconsistentes o insuficientes. MetaVerificationModel resuelve este problema agregando una capa de pensamiento crítico:

struct MetaVerificationModel
{
    Matrix meta_weights;
    Matrix meta_output_weights;

    void Init()
    {
        int meta_input_size = FEATURES_COUNT + 1 + 3; // features + forecast + metrics
        meta_weights.Init(meta_input_size, 16);
        meta_weights.Random(0.3);
        meta_output_weights.Init(16, 1);
        meta_output_weights.Random(0.5);
    }

    double Forward(double &original_features[], double first_model_prediction, double &error_metrics[])
    {
        // Forming the meta input
        double meta_input[];
        int total_input_size = ArraySize(original_features) + 1 + ArraySize(error_metrics);
        ArrayResize(meta_input, total_input_size);

        // Copy the original features
        for(int i = 0; i < ArraySize(original_features); i++)
            meta_input[i] = original_features[i];

        // Add the main model forecast
        meta_input[ArraySize(original_features)] = first_model_prediction;

        // Add error metrics
        for(int i = 0; i < ArraySize(error_metrics); i++)
            meta_input[ArraySize(original_features) + 1 + i] = error_metrics[i];

        // Forward propagation through the hidden layer
        double hidden[];
        ArrayResize(hidden, 16);

        for(int i = 0; i < 16; i++)
        {
            double sum = 0.0;
            for(int j = 0; j < ArraySize(meta_input) && j < meta_weights.cols; j++)
                sum += meta_input[j] * meta_weights.Get(j, i);
            hidden[i] = Tanh(sum);
        }

        // Calculate the final output
        double output = 0.0;
        for(int i = 0; i < 16; i++)
            output += hidden[i] * meta_output_weights.Get(i, 0);

        return Sigmoid(output); // Return confidence from 0 to 1
    }
}

El metamodelo analiza no solo los datos iniciales y la previsión del modelo principal, sino también la historia de errores, las métricas de calidad actuales y los patrones de comportamiento del mercado. El metamodelo aprende a reconocer situaciones en las que el modelo subyacente es propenso a errores y, en consecuencia, reduce la confianza en sus predicciones.

El equilibrio de la memoria
Uno de los aspectos clave para el funcionamiento eficiente del sistema es la configuración correcta de los distintos tipos de memoria. Cada mercado tiene sus propias características y no existen configuraciones universales.

En mercados volátiles como el de las criptomonedas, debe incrementarse la influencia de la memoria a corto plazo y la memoria episódica. El sistema debe responder rápidamente a los cambios repentinos y recordar los eventos extremos. Para instrumentos más estables, como los bonos del gobierno, lo mejor es dar más importancia a la memoria a largo plazo y a los patrones de comportamiento.

// Adaptive adjustment of memory weights depending on the instrument
void AdaptMemoryWeights(string symbol)
{
    if(StringFind(symbol, "BTC") >= 0 || StringFind(symbol, "ETH") >= 0)
    {
        // Settings for cryptocurrencies
        short_term_base_weight = 0.5;
        episodic_base_weight = 0.25;
        long_term_base_weight = 0.1;
    }
    else if(StringFind(symbol, "USD") >= 0)
    {
        // Forex settings
        short_term_base_weight = 0.35;
        medium_term_base_weight = 0.35;
        long_term_base_weight = 0.2;
    }
    // And so on for different types of assets
}

El sistema de autodiagnóstico
Un sistema inteligente debe comprender sus propias limitaciones. Nosotros hemos implementado funciones de autodiagnóstico que supervisan diversos aspectos del funcionamiento del modelo:

void RunDiagnostics()
{
    static int diagnostic_counter = 0;
    diagnostic_counter++;
    
    if(diagnostic_counter % 1000 == 0) // every thousand ticks
    {
        // Entropy analysis in different types of memory
        double short_entropy = context_analyzer.CalculateMemoryEntropy(short_term_memory);
        double long_entropy = context_analyzer.CalculateMemoryEntropy(long_term_memory);
        double pattern_entropy = context_analyzer.CalculateMemoryEntropy(pattern_memory);
        
        // If short-term memory is too chaotic and long-term memory is too stable
        if(short_entropy > 2.5 && long_entropy < 0.5)
        {
            Print("DIAGNOSIS: Memory imbalance detected. Increasing connectivity.");
            // Increase interaction between memory types
            interference_strength += 0.1;
        }
        
        // If the system becomes too conservative
        if(pattern_entropy < 0.3)
        {
            Print("DIAGNOSIS: The system is too conservative. Adding exploratory noise.");
            exploration_noise += 0.05;
        }
        
        // Analyze forecast quality
        double recent_accuracy = prediction_history.GetRecentAccuracy(50);
        if(recent_accuracy < 0.4)
        {
            Print("DIAGNOSIS: Low accuracy of forecasts. Activating retraining mode.");
            learning_rate_multiplier = 1.5;
            confidence_threshold += 0.1; // Raise the bar for confidence
        }
    }
}

Efectos cuánticos en acción

La parte más fascinante de nuestro sistema son las interacciones de inspiración cuántica entre los diferentes componentes. Veamos cómo funcionan en la práctica.

La resonancia se produce cuando los datos entrantes están "sintonizados" a la misma "frecuencia" que la memoria almacenada. Esto crea un efecto de amplificación de la señal: los patrones importantes se hacen más pronunciados y se suprime el ruido.

La interferencia funciona como un sistema de verificación cruzada. Cuando se combinan diferentes tipos de memoria, la señal general se refuerza. Cuando se contradicen entre sí, esto crea una "interferencia destructiva" que vuelve al sistema más cauteloso en sus predicciones.

// Example of analysis of quantum effects
void AnalyzeQuantumEffects(double input_val, double linear_context)
{
    double resonance = MathCos(input_val * linear_context * M_PI);
    
    if(MathAbs(resonance) > 0.8)
    {
        if(resonance > 0)
            Print("QUANTUM EFFECT: Strong constructive resonance detected");
        else
            Print("QUANTUM EFFECT: Strong destructive resonance detected");
    }
    
    // Analyze interference patterns
    double interference_pattern = AnalyzeInterferencePattern();
    if(MathAbs(interference_pattern) > threshold)
    {
        Print("QUANTUM EFFECT: Complex interference pattern detected");
        // The market may be in a transitional state
    }
}

La filosofía de la inteligencia artificial en el trading

La creación de nuestra red neuronal cuántica plantea interrogantes profundos sobre la naturaleza de la inteligencia y la previsibilidad de los mercados financieros. ¿Puede una máquina realmente "comprender" el mercado, o se limita a detectar correlaciones complejas entre los datos? Nosotros proponemos una tercera vía: una arquitectura que va más allá de la simple memorización de patrones o el hallazgo de correlaciones. Nuestro sistema crea una representación multinivel de la realidad del mercado, donde cada nivel es responsable de un aspecto único de la percepción y el análisis.

• La memoria a corto plazo capta los cambios instantáneos en el sentimiento del mercado: cada tick, cada fluctuación de precios. Es como un radar sensible que detecta impulsos momentáneos.

• La memoria a medio plazo rastrea las tendencias y los ciclos que se forman en marcos temporales horarios y diarios, identificando patrones en el desarrollo de los movimientos del mercado.

• La memoria a largo plazo almacena patrones económicos fundamentales que surgen a lo largo de meses y años, ofreciendo al sistema información estratégica.

• La memoria episódica detecta eventos únicos y críticos: picos bruscos de volatilidad, noticias inesperadas o cambios de tendencia. Estos "recuerdos" permiten al sistema anticipar la repetición de escenarios similares.

• La memoria de patrones actúa como una intuición digital, extrayendo estructuras profundas que se repiten en distintos periodos de tiempo y condiciones de mercado.

Los efectos cuánticos —resonancia, interferencia y coherencia— añaden un nuevo nivel de complejidad. Estos permiten que el sistema perciba la incertidumbre no como un obstáculo, sino como una fuente de información valiosa. Al igual que las partículas cuánticas que existen en una superposición de estados, nuestra red es capaz de considerar simultáneamente múltiples escenarios de mercado posibles, amplificando las señales significativas y suprimiendo el ruido. Esto convierte la incertidumbre en una herramienta de aprendizaje, permitiendo que el sistema se adapte a la naturaleza caótica de los mercados.

Beneficios de las matrices MQL5 integradas: de la bicicleta a la nave espacial

Inicialmente, nuestro sistema se basaba en nuestra propia implementación de operaciones matriciales, lo que equivalía a reinventar la rueda. Sin embargo, los desarrolladores de MQL5 han hecho un trabajo excepcional al proporcionar los tipos matrix y vector integrados, así como la biblioteca <matrix.mqh>, que han convertido nuestra "bicicleta" en una nave espacial de alto rendimiento. El uso de operaciones matriciales nativas nos ha permitido reducir drásticamente la cantidad de código, mejorar su legibilidad y su rendimiento.

Ventajas de las matrices MQL5 integradas:

• Alto rendimiento: las operaciones como la multiplicación de matrices (MatMul, operador @) utilizan las instrucciones vectoriales del procesador, lo que proporciona una aceleración varias veces superior a la de los ciclos manuales.

• Robustez: los tipos de datos integrados eliminan los errores de indexación y garantizan la estabilidad numérica, algo fundamental para los cálculos financieros, donde cualquier imprecisión puede ocasionar pérdidas.

• Concisión y claridad: el código se ha acercado a la notación matemática, lo que facilita su desarrollo y mantenimiento. Por ejemplo, en lugar de ciclos engorrosos para la multiplicación de matrices, basta con escribir Q = input @ W_q.

• Herramientas de aprendizaje automático listas para usar: las funciones RandUniform, Exp, Sigmoid, ReLU y otras funciones, permiten centrarse en la lógica de alto nivel en lugar de en los cálculos de bajo nivel.

• Gestión de memoria optimizada: los tipos integrados minimizan la asignación de memoria, lo cual resulta especialmente importante al procesar grandes volúmenes de datos de mercado en tiempo real.

Como ejemplo, veamos cómo cambia el código al usar tipos integrados:

Entonces

Ahora

void Forward(Matrix &input_matrix, Matrix &output_matrix)    {       int seq_len = input_matrix.rows;              Matrix Q, K, V;       Q.Init(seq_len, d_model);       K.Init(seq_len, d_model);       V.Init(seq_len, d_model);       // Simple matrix multiplication Q = input * W_q       for(int i = 0; i < seq_len; i++)       {          for(int j = 0; j < d_model; j++)          {             double q_sum = 0.0, k_sum = 0.0, v_sum = 0.0;             for(int k = 0; k < d_model; k++)             {                double input_val = input_matrix.Get(i, k);                q_sum += input_val * W_q.Get(k, j);                k_sum += input_val * W_k.Get(k, j);                v_sum += input_val * W_v.Get(k, j);             }             Q.Set(i, j, q_sum);             K.Set(i, j, k_sum);             V.Set(i, j, v_sum);          }       }       // Calculate attention weights       Matrix attention_weights;       attention_weights.Init(seq_len, seq_len);       for(int i = 0; i < seq_len; i++)       {          double max_score = -DBL_MAX;                   // Calculate scores          for(int j = 0; j < seq_len; j++)          {             double score = 0.0;             for(int k = 0; k < d_model; k++)                score += Q.Get(i, k) * K.Get(j, k);                          score /= MathSqrt(d_model);             attention_weights.Set(i, j, score);             if(score > max_score) max_score = score;          }          // Softmax          double sum_exp = 0.0;          for(int j = 0; j < seq_len; j++)          {             double exp_val = MathExp(attention_weights.Get(i, j) - max_score);             attention_weights.Set(i, j, exp_val);             sum_exp += exp_val;          }          if(sum_exp > 0)          {             for(int j = 0; j < seq_len; j++)                attention_weights.Set(i, j, attention_weights.Get(i, j) / sum_exp);          }       }       // Apply weights to values       output_matrix.Init(seq_len, d_model);       for(int i = 0; i < seq_len; i++)       {          for(int j = 0; j < d_model; j++)          {             double sum = 0.0;             for(int k = 0; k < seq_len; k++)                sum += attention_weights.Get(i, k) * V.Get(k, j);             output_matrix.Set(i, j, sum);          }       }    }

matrix Forward(const matrix &input_data)    {       // Calculate Q, K, V       matrix Q = input_data.MatMul(W_q);       matrix K = input_data.MatMul(W_k);       matrix V = input_data.MatMul(W_v);              // Apply quantum effects       Q = quantum_proc.ApplyQuantumEffects(Q, input_data);       K = quantum_proc.ApplyQuantumEffects(K, input_data);              // Calculate attention weights       matrix scores = Q.MatMul(K.Transpose()) / MathSqrt((double)d_model);              // Softmax across rows       for(ulong i = 0; i < scores.Rows(); i++)       {          vector row = scores.Row(i);                   // Find the maximum value for numerical stability          double max_val = row.Max();                   // Subtract the maximum and apply the exponential element-wise          for(ulong j = 0; j < row.Size(); j++)          {             row[j] = MathExp(row[j] - max_val);          }                   // Normalize (divide by the sum)          double sum = row.Sum();          row = row / sum;                   // Write back to the matrix          scores.Row(row, i);       }              // Apply to values and output projection       matrix attention_output = scores.MatMul(V);       return attention_output.MatMul(W_o);    }

El código optimizado completo se puede consultar en el archivo adjunto QuantumNeuralMQL.mqh.

El conocimiento de las capacidades de MQL5 ha resultado clave para crear redes neuronales complejas. En lugar de dedicar tiempo a escribir nuestras propias implementaciones de operaciones básicas, podemos centrarnos en desarrollar arquitecturas innovadoras como nuestro ContextAnalyzer o QuantumProcessor. El estudio de la documentación de MQL5 (como las operaciones matriciales) abre la puerta a la implementación eficiente de algoritmos matemáticamente complejos, lo que hace que el proceso de creación de redes neuronales no solo sea productivo, sino también atractivo.

Por último, vamos a usar un pequeño script para asegurarnos de que el código funciona.

//+------------------------------------------------------------------+
//| Usage example                                                    |
//+------------------------------------------------------------------+
// Using in EA:
SimpleQuantumNeural neural_net;

int OnInit()
{
   neural_net.Init();
   return INIT_SUCCEEDED;
}

void OnTick()
{
   double features[];
   if(MarketDataCollector::CollectSimpleFeatures(_Symbol, PERIOD_H1, 10, features))
   {
      double prediction[];
      neural_net.Forward(features, prediction);
      
      if(ArraySize(prediction) > 0)
      {
         double signal = prediction[0];
         Comment("Quantum signal: ", DoubleToString(signal, 4));
         
         if(signal > 0.6)
         {
            // Buy
         }
         else if(signal < 0.4)
         {
            // Sell
         }
      }
   }
   
   // Diagnostics
   static int counter = 0;
   counter++;
   if(counter % 100 == 0)
      neural_net.PrintDiagnostics();
}

Conclusión

El sistema creado no supone solo un algoritmo, sino una estructura de autoaprendizaje capaz de adaptarse y desarrollar su propia comprensión del mercado.

Componentes clave:

• Matrices — base matemática
• State Space Model — dinámica a lo largo del tiempo.
• Transformer — atención y generalización
• Context Analyzer — comprensión multinivel
• Meta Verification Model — comprobación de conclusiones

El efecto principal se logra mediante la interacción de estos módulos. La segunda parte del artículo tratará sobre los ejemplos de uso, la configuración y la optimización del sistema en la práctica. La transición hacia nuevas formas de inteligencia artificial en el trading no ha hecho más que empezar.