Квантовая нейросеть на MQL5 (Часть I): Создаем включаемый файл

Представьте себе трейдера, который никогда не спит, никогда не паникует и способен одновременно анализировать тысячи рыночных паттернов. Более того, представьте, что этот трейдер обладает памятью слона, интуицией гения и способностью к мгновенному обучению. Звучит как фантастика? Добро пожаловать в мир квантовых нейронных сетей на MQL5.

То, что мы создаем сегодня, выходит далеко за рамки обычного машинного обучения. Это симбиоз квантовой механики и искусственного интеллекта, воплощенный в коде, который может работать прямо в вашем MetaTrader 5. Наша архитектура не просто предсказывает движения цен — она понимает рынок на уровне, недоступном человеческому сознанию. 

Революция в понимании памяти

Человеческий мозг оперирует несколькими типами памяти одновременно. Когда опытный трейдер смотрит на график, он мгновенно вспоминает похожие ситуации из прошлого, анализирует текущий контекст и формирует интуитивное понимание того, что может произойти дальше. Именно этот принцип лег в основу нашего ContextAnalyzer — революционного компонента, который воссоздает человеческую интуицию в цифровом формате.

Наша система памяти работает на пяти уровнях, каждый из которых имеет свою специализацию. Краткосрочная память фиксирует мгновенные изменения рынка — каждый тик, каждое движение цены. Среднесрочная память накапливает информацию о часовых и дневных трендах. Долгосрочная память хранит фундаментальные закономерности, которые проявляются месяцами и годами.

Но настоящая магия начинается с эпизодической памяти. Она активируется только тогда, когда происходит что-то действительно важное —резкий скачок волатильности, неожиданная новость, смена тренда. Эти моменты запечатлеваются с особой силой, формируя уникальные "воспоминания", которые система будет использовать для распознавания аналогичных ситуаций в будущем.

Архитектура сочетает память разных временных горизонтов (от краткосрочной до долгосрочной) для адаптации к рыночной динамике. Механизм внимания и трансформеры обеспечивают выделение ключевой информации и абстрагирование. State Space Model отвечает за временные зависимости, а Context Analyzer интегрирует память с учётом волатильности. Квантовый процессор усиливает сигналы и подавляет шум, MetaVerificationModel проверяет надёжность прогнозов. Всё работает как самонастраивающаяся система с критическим мышлением.

Квантовая механика в действии

Классические нейронные сети обрабатывают информацию линейно —  данные проходят от входа к выходу через последовательность преобразований. Наша система работает принципиально иначе. Мы применяем принципы квантовой механики: суперпозицию, интерференцию и резонанс.

Когда различные уровни памяти взаимодействуют между собой, они создают интерференционные паттерны — точно так же, как световые волны могут усиливать или подавлять друг друга. Эти интерференции порождают эмерджентные свойства, которые невозможно получить простым сложением компонентов.

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

Эти формулы не просто математические выкладки. Они описывают, как разные "слои реальности" рынка резонируют друг с другом, создавая сложные гармоники, которые наша система способна распознать и использовать для прогнозирования.

Трансформер как архитектурная революция

В основе современного ИИ лежит механизм внимания — способность модели фокусироваться на действительно важной информации, игнорируя шум. Наш UShapeTransformer развивает эту идею до совершенства.

Представьте себе дирижера оркестра, который одновременно слышит каждый инструмент и понимает, как они взаимодействуют между собой. Механизм внимания работает похожим образом — он вычисляет степень важности каждого элемента входной последовательности относительно всех остальных элементов.

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

U-образная архитектура добавляет еще один уровень сложности. Информация сначала проходит через энкодер, который сжимает и абстрагирует входные данные, выделяя наиболее существенные признаки. Затем декодер восстанавливает эту информацию, но уже обогащенную контекстом и пониманием глубинных связей.

Алхимия кода: создание цифрового мозга

Фундамент: структура Matrix
Любое сложное сооружение начинается с крепкого фундамента. В нашем случае это структура Matrix — не просто контейнер для чисел, а интеллектуальная система управления многомерными данными.

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

Казалось бы, простая структура. Но в ней заложена философия безопасности и надежности. Каждое обращение к данным проверяется, каждая операция контролируется. Это особенно критично для финансовых систем, где одна ошибка может стоить реальных денег.

StateSpaceModel: память о прошлом, взгляд в будущее
Рынки обладают памятью. То, что происходило вчера, влияет на события сегодня. То, что происходит сегодня, определяет возможности завтра. StateSpaceModel воплощает эту фундаментальную истину в математической форме.

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

Красота этой модели в ее простоте и мощности. Три матрицы определяют, как система эволюционирует во времени. Матрица A описывает внутреннюю динамику — как прошлые состояния влияют на будущие. Матрица B определяет, как внешние воздействия (новые данные) изменяют состояние системы. Матрица C показывает, как внутреннее состояние проявляется во внешних наблюдениях.

ContextAnalyzer: цифровая интуиция
Самый сложный и инновационный компонент нашей системы — это ContextAnalyzer . Здесь происходит настоящая магия: превращение сырых данных в понимание.

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

Система постоянно анализирует характер входящих данных. Высокая волатильность заставляет уделять больше внимания краткосрочной памяти. Сложные паттерны активируют эпизодическую и паттерновую память. Это не жесткие правила, а динамические веса, которые адаптируются к текущей рыночной ситуации.

Далее происходит самое интересное — квантовые взаимодействия между различными типами памяти:

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

Это не просто математические операции. Каждая формула имеет глубокий смысл. Резонанс возникает, когда текущие данные "синхронизируются" с накопленным контекстом. Интерференция создает сложные паттерны взаимодействия между различными временными масштабами. Нелинейные факторы добавляют адаптивность, позволяя системе реагировать на изменения рыночных условий.

Система обучения и адаптации
Настоящий интеллект проявляется не в способности запоминать, а в способности учиться и адаптироваться. Наша система постоянно анализирует важность поступающей информации и соответственно обновляет свою память:

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

Система работает как живой организм. Она не просто накапливает информацию — она понимает, что важно, а что можно игнорировать. Важные события запоминаются надолго, рутинные данные быстро забываются. Паттерны, которые повторяются, усиливаются. Случайный шум фильтруется.

MetaVerificationModel: искусство сомнения
Одна из главных проблем машинного обучения — переуверенность моделей. Система может выдавать прогнозы с высокой "уверенностью", даже когда входные данные противоречивы или недостаточны. MetaVerificationModel решает эту проблему, добавляя слой критического мышления:

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

Мета-модель анализирует не только исходные данные и прогноз основной модели, но и историю ошибок, текущие метрики качества, паттерны поведения рынка. Она учится распознавать ситуации, когда основная модель склонна к ошибкам, и соответственно снижает доверие к ее прогнозам.

Балансировка памяти
Одним из ключевых аспектов эффективной работы системы является правильная настройка различных типов памяти. Каждый рынок имеет свои особенности, и универсальных настроек не существует.

Для волатильных рынков, таких как криптовалюты, следует увеличить влияние краткосрочной и эпизодической памяти. Система должна быстро реагировать на резкие изменения и запоминать экстремальные события. Для более стабильных инструментов, например, государственных облигаций, больший вес следует отдать долгосрочной и паттерновой памяти.

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

Система самодиагностики
Интеллектуальная система должна понимать свои собственные ограничения. Мы реализуем функции самодиагностики, которые отслеживают различные аспекты работы модели:

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; // Повышаем требования к уверенности
        }
    }
}

Квантовые эффекты в действии

Самая интригующая часть нашей системы — это квантово-вдохновленные взаимодействия между различными компонентами. Рассмотрим, как они работают на практике.

Резонанс возникает, когда входящие данные "настроены" на ту же "частоту", что и накопленная память. Это создает эффект усиления сигнала —важные паттерны становятся более выраженными, а шум подавляется.

Интерференция работает как система перекрестных проверок. Когда различные типы памяти согласованы между собой, это усиливает общий сигнал. Когда они противоречат друг другу, это создает "деструктивную интерференцию", которая заставляет систему быть более осторожной в прогнозах.

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

Философия искусственного интеллекта в трейдинге

Создание нашей квантовой нейронной сети поднимает глубокие вопросы о природе интеллекта и предсказуемости финансовых рынков. Может ли машина по-настоящему "понимать" рынок, или она лишь выявляет сложные корреляции в данных? Мы предлагаем третий путь: архитектура, которая выходит за рамки простого запоминания паттернов или поиска корреляций. Наша система формирует многоуровневое представление рыночной реальности, где каждый уровень отвечает за уникальный аспект восприятия и анализа.

• Краткосрочная память фиксирует мгновенные изменения настроений участников рынка — каждый тик, каждое колебание цены. Она подобна чуткому радару, улавливающему сиюминутные импульсы.

• Среднесрочная память отслеживает тренды и циклы, формирующиеся на часовых и дневных таймфреймах, выявляя закономерности в развитии рыночных движений.

• Долгосрочная память хранит фундаментальные экономические закономерности, которые проявляются на протяжении месяцев и лет, обеспечивая системе стратегическое видение.

• Эпизодическая память запечатлевает уникальные, критически важные события — резкие скачки волатильности, неожиданные новости или смены трендов. Эти "воспоминания" позволяют системе предвидеть повторение схожих сценариев.

• Память паттернов действует как цифровая интуиция, извлекая глубинные структуры, которые повторяются на различных временных масштабах и в разных рыночных условиях.

Квантовые эффекты — резонанс, интерференция и когерентность — добавляют новый уровень сложности. Они позволяют системе воспринимать неопределенность не как препятствие, а как источник ценной информации. Подобно квантовым частицам, которые существуют в суперпозиции состояний, наша сеть способна одновременно учитывать множество возможных рыночных сценариев, усиливая значимые сигналы и подавляя шум. Это превращает неопределенность в инструмент познания, позволяя системе адаптироваться к хаотичной природе рынков.

Преимущества встроенных матриц MQL5: от велосипеда к космическому кораблю

Изначально наша система опиралась на собственную реализацию матричных операций, что было сродни изобретению велосипеда. Однако разработчики MQL5 проделали выдающуюся работу, предоставив встроенные типы matrix и vector, а также библиотеку <matrix.mqh>, которые превратили наш "велосипед" в высокопроизводительный космический корабль. Использование нативных матричных операций позволило радикально сократить объем кода, повысить его читаемость и производительность.

Преимущества встроенных матриц MQL5:

• Высокая производительность: операции вроде матричного умножения (MatMul, оператор @) используют векторные инструкции процессора, обеспечивая ускорение в разы по сравнению с ручными циклами.

• Надежность: встроенные типы исключают ошибки индексации и обеспечивают числовую стабильность, что критично для финансовых вычислений, где любая неточность может привести к убыткам.

• Краткость и ясность: код стал ближе к математической записи, что упрощает его разработку и поддержку. Например, вместо громоздких циклов для умножения матриц достаточно написать Q = input @ W_q.

• Готовые инструменты для машинного обучения: функции RandUniform, Exp, Sigmoid, ReLU и другие позволяют сосредоточиться на высокоуровневой логике, а не на низкоуровневых вычислениях.

• Оптимизированное управление памятью: встроенные типы минимизируют аллокации памяти, что особенно важно при обработке больших объемов рыночных данных в реальном времени.

Для примера посмотрим, как меняется код с использованием встроенных типов:

Было

Стало

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

Полный оптимизированнй код можно посмотреть в приложенном файле QuantumNeuralMQL.mqh.

Знание возможностей MQL5 оказалось ключом к созданию сложных нейронных сетей. Вместо того, чтобы тратить время на написание собственных реализаций базовых операций, мы можем сосредоточиться на разработке инновационных архитектур, таких как наш ContextAnalyzer или QuantumProcessor. Изучение документации MQL5 (например, matrix operations) открывает двери для эффективной реализации математически сложных алгоритмов, делая процесс создания нейронных сетей не только продуктивным, но и увлекательным.

Наконец, используем небольшой скрипт, чтобы убедиться что код работает.

//+------------------------------------------------------------------+
//| Пример использования                                             |
//+------------------------------------------------------------------+
// Использование в 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();
}

Заключение

Созданная система — не просто алгоритм, а самообучающаяся структура, способная адаптироваться и формировать собственное понимание рынка.

Ключевые компоненты:

• Матрицы — математическая основа
• State Space Model — динамика во времени
• Transformer — внимание и обобщение
• Context Analyzer — многоуровневое понимание
• Meta Verification Model — проверка выводов

Главный эффект достигается за счёт взаимодействия этих модулей. Во второй части статьи будут рассмотрены примеры использования, настройка и оптимизация системы на практике. Переход к новым формам ИИ в трейдинге только начинается.