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)
{
    // Создание матриц запросов, ключей и значений
    MatrixMultiply(input_matrix, W_q, Q);
    MatrixMultiply(input_matrix, W_k, K);
    MatrixMultiply(input_matrix, W_v, V);
    
    // Вычисление весов внимания
    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;  // Матрицы состояния, входа и выхода
    Matrix state;    // Текущее состояние системы
    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++)
        {
            // Извлечение текущего входного вектора
            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));

            // Обновление внутреннего состояния
            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;

            // Вычисление выхода: 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);
        
        // Инициализация всех типов памяти
        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++;

    // Анализ характеристик входных данных
    double input_volatility = 0.0;
    double input_magnitude = 0.0;
    double input_complexity = 0.0;

    // Вычисление волатильности, магнитуды и сложности
    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);

        // Оценка сложности через анализ изменений
        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:

// Динамическое вычисление весов для разных типов памяти
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;

// Нормализация весов
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;

        // Извлечение контекста из разных типов памяти
        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);

        // Линейная комбинация контекстов
        double linear_context = short_weight * short_context +
                               medium_weight * medium_context +
                               long_weight * long_context +
                               episodic_weight * episodic_context +
                               pattern_weight * pattern_context;

        // Квантовые эффекты: резонанс и интерференция
        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);

        // Интеграция всех эффектов
        double integrated_context = linear_context * resonance_factor * nonlinear_factor + interference;

        // Определение силы контекстного влияния
        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:

// Оценка важности текущих данных
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;

// Адаптивная скорость обучения
double learning_rate = (importance > avg_importance) ? 0.3 : 0.05;

// Обновление различных типов памяти с разными скоростями
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);

// Эпизодическая память активируется только для важных событий
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);
}

// Паттерновая память обновляется при обнаружении корреляций
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; // признаки + прогноз + метрики
        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[])
    {
        // Формирование мета-входа
        double meta_input[];
        int total_input_size = ArraySize(original_features) + 1 + ArraySize(error_metrics);
        ArrayResize(meta_input, total_input_size);

        // Копирование исходных признаков
        for(int i = 0; i < ArraySize(original_features); i++)
            meta_input[i] = original_features[i];

        // Добавление прогноза основной модели
        meta_input[ArraySize(original_features)] = first_model_prediction;

        // Добавление метрик ошибок
        for(int i = 0; i < ArraySize(error_metrics); i++)
            meta_input[ArraySize(original_features) + 1 + i] = error_metrics[i];

        // Прямое распространение через скрытый слой
        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);
        }

        // Вычисление финального выхода
        double output = 0.0;
        for(int i = 0; i < 16; i++)
            output += hidden[i] * meta_output_weights.Get(i, 0);

        return Sigmoid(output); // Возвращает уверенность от 0 до 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.

// Адаптивная настройка весов памяти в зависимости от инструмента
void AdaptMemoryWeights(string symbol)
{
    if(StringFind(symbol, "BTC") >= 0 || StringFind(symbol, "ETH") >= 0)
    {
        // Настройки для криптовалют
        short_term_base_weight = 0.5;
        episodic_base_weight = 0.25;
        long_term_base_weight = 0.1;
    }
    else if(StringFind(symbol, "USD") >= 0)
    {
        // Настройки для форекса
        short_term_base_weight = 0.35;
        medium_term_base_weight = 0.35;
        long_term_base_weight = 0.2;
    }
    // И так далее для разных типов активов
}

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) // каждую тысячу тиков
    {
        // Анализ энтропии в различных типах памяти
        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_entropy > 2.5 && long_entropy < 0.5)
        {
            Print("ДИАГНОСТИКА: Обнаружен дисбаланс памяти. Увеличиваю связность.");
            // Увеличиваем взаимодействие между типами памяти
            interference_strength += 0.1;
        }
        
        // Если система становится слишком консервативной
        if(pattern_entropy < 0.3)
        {
            Print("ДИАГНОСТИКА: Система слишком консервативна. Добавляю исследовательский шум.");
            exploration_noise += 0.05;
        }
        
        // Анализ качества прогнозов
        double recent_accuracy = prediction_history.GetRecentAccuracy(50);
        if(recent_accuracy < 0.4)
        {
            Print("ДИАГНОСТИКА: Низкая точность прогнозов. Активирую режим переобучения.");
            learning_rate_multiplier = 1.5;
            confidence_threshold += 0.1; // Повышаем требования к уверенности
        }
    }
}

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.

// Пример анализа квантовых эффектов
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("КВАНТОВЫЙ ЭФФЕКТ: Сильный конструктивный резонанс обнаружен");
        else
            Print("КВАНТОВЫЙ ЭФФЕКТ: Сильный деструктивный резонанс обнаружен");
    }
    
    // Анализ интерференционных паттернов
    double interference_pattern = AnalyzeInterferencePattern();
    if(MathAbs(interference_pattern) > threshold)
    {
        Print("КВАНТОВЫЙ ЭФФЕКТ: Обнаружен сложный интерференционный паттерн");
        // Возможно, рынок находится в переходном состоянии
    }
}

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);       // Простое умножение матриц 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);          }       }       // Вычисление весов внимания       Matrix attention_weights;       attention_weights.Init(seq_len, seq_len);       for(int i = 0; i < seq_len; i++)       {          double max_score = -DBL_MAX;                   // Вычисление скоров          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);          }       }       // Применение весов к значениям       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)    {       // Вычисление Q, K, V       matrix Q = input_data.MatMul(W_q);       matrix K = input_data.MatMul(W_k);       matrix V = input_data.MatMul(W_v);              // Применение квантовых эффектов       Q = quantum_proc.ApplyQuantumEffects(Q, input_data);       K = quantum_proc.ApplyQuantumEffects(K, input_data);              // Вычисление весов внимания       matrix scores = Q.MatMul(K.Transpose()) / MathSqrt((double)d_model);              // Softmax по строкам       for(ulong i = 0; i < scores.Rows(); i++)       {          vector row = scores.Row(i);                   // Находим максимальное значение для численной стабильности          double max_val = row.Max();                   // Вычитаем максимум и применяем экспоненту поэлементно          for(ulong j = 0; j < row.Size(); j++)          {             row[j] = MathExp(row[j] - max_val);          }                   // Нормализуем (делим на сумму)          double sum = row.Sum();          row = row / sum;                   // Записываем обратно в матрицу          scores.Row(row, i);       }              // Применение к значениям и выходная проекция       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.

//+------------------------------------------------------------------+
//| Пример использования                                             |
//+------------------------------------------------------------------+
// Использование в 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("Квантовый сигнал: ", DoubleToString(signal, 4));
         
         if(signal > 0.6)
         {
            // Покупка
         }
         else if(signal < 0.4)
         {
            // Продажа
         }
      }
   }
   
   // Диагностика
   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.