Нейросети в трейдинге: Адаптивная факторная токенизация (Окончание)

Введение

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

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

В первой статье мы сосредоточились на модуле AutoToken. Его задача — превратить разрозненный набор рыночных факторов в компактные, информативные токены. В классическом подходе трейдер вручную решает, какие индикаторы комбинировать, какие лаги учитывать и какие признаки группировать. Такой подход неизбежно ограничен субъективностью и масштабируемостью. AutoToken снимает это ограничение, он обучаемым образом формирует структуру представления признаков, снижая шум и устраняя избыточность.

Во второй статье мы сделали следующий шаг. Структурированные токены — это лишь материал, им нужна архитектура взаимодействия. Именно здесь был реализован механизм Multi-Mix Attention. В отличие от классического Self-Attention, где зависимости вычисляются заново для каждого входа, Multi-Mix Attention формирует параметрическую структуру межтокенных связей. Это важное различие. Финансовые рынки содержат устойчивые корреляционные зависимости, они меняются, но не хаотично. Возможность аккумулировать такие связи в параметрах модели делает архитектуру более устойчивой и менее подверженной переобучению.

Дополнительно был реализован механизм Sparse MoE. Он позволяет модели не усреднять поведение всех вычислительных блоков, а выбирать ограниченное число релевантных экспертов. Такой подход ближе к практике управления капиталом. В каждый момент работают только те стратегии, которые соответствуют текущему режиму рынка. Архитектура начинает мыслить не линейно, а модульно.

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

Блок MTmixAtt

Продолжаем работу по переносу фреймворка MTmixAtt и здесь важно обратить внимание на то, как его авторы выстраивают композицию модели. По аналогии с классическим Transformer, где базовым строительным элементом выступает повторяющийся блок Self-Attention + FeedForward, в MTmixAtt вводится собственная структурная единица — MTmixAttBlock.

Этот блок объединяет в себе два ключевых механизма: Multi-Mix Attention и Mixture-of-Experts. Которые являются взаимосвязанными элементами единой логики обработки данных. Далее такие блоки выстраиваются в последовательность. Несколько уровней подряд. Глубина позволяет постепенного уточнять представление — от поверхностных связей к более сложным и скрытым зависимостям.

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

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

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

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

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

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

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

Фактически перед нами архитектурный аналог режимной адаптации. Один эксперт может быть более релевантен в фазе направленного движения. Другой — в условиях сжатия диапазона. Третий — при резком расширении волатильности. Модель не пытается применять одну универсальную логику ко всем состояниям рынка. Она выбирает.

Таким образом, в MTmixAttBlock механизм смеси экспертов существенно расширяется по сравнению с классическим MoE. Архитектура становится многоуровневой не только по глубине слоёв, но и по функциональной специализации.

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

В рамках данного проекта мы реализуем предложенный авторами подход в виде объекта CNeuronMTmixAttBlock. Это завершённый структурный блок, который аккумулирует в себе логику MTmixAtt и становится повторяемым элементом глубокой модели. Именно через такие блоки формируется глубина анализа, а значит — и способность модели видеть рынок системно.

class CNeuronMTmixAttBlock :  public CNeuronBaseOCL
  {
protected:
   CNeuronMultiMixAttention   cAttention;
   CLayer                     cSharedExpert;
   CLayer                     cFieldMoE;
   CLayer                     cSceneMoE;
   //---
   virtual bool      feedForward(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      updateInputWeights(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      calcInputGradients(CNeuronBaseOCL *NeuronOCL) override;

public:
                     CNeuronMTmixAttBlock(void) {};
                    ~CNeuronMTmixAttBlock(void) {};
   //---
   virtual bool      Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                          uint dimension, uint units, uint heads,
                          uint embed_size, uint candidates, uint topK,
                          ENUM_OPTIMIZATION optimization_type, uint batch);
   //---
   virtual bool      Save(const int file_handle) override;
   virtual bool      Load(const int file_handle) override;
   //---
   virtual int       Type(void) override const  {  return defNeuronMTmixAttBlock; }
   virtual void      SetOpenCL(COpenCLMy *obj) override;
   virtual void      TrainMode(bool flag) override;
   virtual void      SetActivationFunction(ENUM_ACTIVATION value) override {};
   //---
   virtual bool      WeightsUpdate(CNeuronBaseOCL *source, float tau) override;
  };

Структура нового объекта отражает философию оригинального фреймворка. Внутри блока объединены механизм Multi-Mix Attention, общий эксперт и две разновидности смеси экспертов — по полям и по сценарию. Это не механическое объединение слоёв, а продуманная композиция, в которой каждый элемент выполняет собственную функцию и при этом усиливает другие.

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

bool CNeuronMTmixAttBlock::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                                uint dimension, uint units, uint heads,
                                uint embed_size, uint candidates, uint topK,
                                ENUM_OPTIMIZATION optimization_type, uint batch)
  {
   if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, dimension * units, optimization_type, batch))
      ReturnFalse;
   activation = None;

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

Далее создаётся cAttention. Именно здесь задаются параметры механизма внимания.

   uint index = 0;
   if(!cAttention.Init(0, index, OpenCL, dimension, units, heads, embed_size, candidates, topK, optimization, iBatch))
      ReturnFalse;

Multi-Mix Attention становится первым фильтром внутри блока. Он формирует каркас взаимосвязей. Можно сказать, что на этом этапе рынок приводится в структурированное состояние. Связи между токенами фиксируются и стабилизируются.

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

   cSharedExpert.Clear();
   cFieldMoE.Clear();
   cSceneMoE.Clear();
   cSharedExpert.SetOpenCL(OpenCL);
   cFieldMoE.SetOpenCL(OpenCL);
   cSceneMoE.SetOpenCL(OpenCL);
   uint expert_dimension = dimension / heads;
   uint hidden_dimension = MathMax((expert_dimension + 3) / 4, 8);

Это важно. Мы сразу закладываем промышленную вычислительную дисциплину.

Размерность каждого эксперта определяется как dimension/heads. Это логично — каждая голова внимания передаёт свою часть представления, и эксперты работают уже с локализованным подпространством.

Далее рассчитывается латентная размерность внутри каждого эксперта (hidden_dimension). Она не задаётся произвольно, а определяется как функция входной размерности с нижней границей. Это баланс между выразительностью и устойчивостью. Слишком широкое скрытое пространство на рынке — это риск переобучения. Слишком узкое — потеря нюансов. Здесь выбирается компромисс.

Общий эксперт строится как двухслойная последовательность CNeuronFieldAwareConv. Сначала происходит переход в скрытое пространство с активацией SIGMOID.

//--- Shared Expert
   index++;
   CNeuronFieldAwareConv* conv = new CNeuronFieldAwareConv();
   if(!conv ||
      !conv.Init(0, index, OpenCL, expert_dimension, hidden_dimension, units * heads,
                               embed_size, candidates, topK, optimization, iBatch) ||
      !cSharedExpert.Add(conv))
      DeleteObjAndFalse(conv);
   conv.SetActivationFunction(SIGMOID);

С последующим возвратом к исходной размерности с TANH.

   index++;
   conv = new CNeuronFieldAwareConv();
   if(!conv ||
      !conv.Init(0, index, OpenCL, hidden_dimension, expert_dimension, units * heads,
                               embed_size, candidates, topK, optimization, iBatch) ||
      !cSharedExpert.Add(conv))
      DeleteObjAndFalse(conv);
   conv.SetActivationFunction(TANH);

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

Использование TANH на выходе эксперта — это не декоративное решение, а инженерная настройка, продиктованная структурой данных и логикой всего блока. На выходе Multi-Mix Attention мы получаем уже нормализованное представление. Токены приведены к согласованному масштабу, взаимосвязи структурированы, распределение значений стабилизировано. Это важно. Внимание не генерирует произвольные амплитуды. Оно формирует сбалансированную картину межфакторных зависимостей.

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

Во-первых, происходит естественное подавление нерелевантных сигналов. Если после внутренних преобразований активация близка к нулю, TANH аккуратно сжимает её ещё сильнее. Шум не усиливается. Он гасится.

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

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

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

Индивидуальные эксперты для токенов строится схожим образом, но вместо обычной свёртки используются CNeuronSparseMoEConv.

//--- Field MoE
   index++;
   CNeuronSparseMoEConv* moe = new CNeuronSparseMoEConv();
   if(!moe ||
      !moe.Init(0, index, OpenCL, expert_dimension, hidden_dimension, units * heads,
                                          candidates, topK, optimization, iBatch) ||
      !cFieldMoE.Add(moe))
      DeleteObjAndFalse(moe);
   moe.SetActivationFunction(SIGMOID);
   index++;
   moe = new CNeuronSparseMoEConv();
   if(!moe ||
      !moe.Init(0, index, OpenCL, hidden_dimension, expert_dimension, units * heads,
                                          candidates, topK, optimization, iBatch) ||
      !cFieldMoE.Add(moe))
      DeleteObjAndFalse(moe);
   moe.SetActivationFunction(TANH);

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

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

Это уже не ансамблевая логика, а контекстно-зависимая параметризация. Такой подход даёт два стратегических преимущества. Во-первых, сохраняется компактность вычислений. Во-вторых, модель остаётся гибкой. Параметры не фиксированы раз и навсегда — они адаптируются к структуре текущего входа. Для финансовых данных это критично. Рыночный режим меняется, и модель обязана подстраиваться без радикального усложнения архитектуры.

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

Размер окна может варьироваться. Его задаёт пользователь. Но вне зависимости от длины периода внутри него почти неизбежно присутствует смена локальных сценариев. Устойчивый восходящий импульс может переходить в коррекцию, коррекция — в консолидацию, консолидация — в новый импульс, иногда уже противоположного направления. Попытка описать всё это единым глобальным экспертом приводит к усреднению, а усреднение в трейдинге часто означает потерю чувствительности к структуре.

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

С этой целью на первом этапе используется CNeuronSpikeSuperKernelBlock. И здесь заложена важная идея многомасштабного анализа. Блок формируется с наборами окон {3, 5, 7}. Это не случайный выбор чисел и не декоративная вариация параметров. Три масштаба позволяют одновременно учитывать краткосрочные импульсы, среднесрочные колебания и более сглаженную локальную структуру.

//--- Scene MoE
   index++;
   uint windows[] = {3, 5, 7};
   uint steps[] = {1, 1, 1};
   CNeuronSpikeSuperKernelBlock* scene = new CNeuronSpikeSuperKernelBlock();
   if(!scene ||
      !scene.Init(0, index, OpenCL, expert_dimension, hidden_dimension, windows,
                                   steps, heads, units, optimization, iBatch) ||
      !cSceneMoE.Add(scene))
      DeleteObjAndFalse(scene);

Рынок редко движется в одном масштабе. Импульс внутри трёх баров может полностью противоречить конфигурации семи. Узкое окно фиксирует резкий всплеск. Более широкое — видит, что это лишь колебание внутри более крупной консолидации. Архитектура учитывает эту неоднородность с самого начала.

После этого следуют два уровня разреженной смеси экспертов. Сначала скрытое пространство усиливается через SIGMOID, затем возвращается к размерности эксперта через TANH.

   index++;
   moe = new CNeuronSparseMoEConv();
   if(!moe ||
      !moe.Init(0, index, OpenCL, hidden_dimension, hidden_dimension, units * heads,
                                          candidates, topK, optimization, iBatch) ||
      !cSceneMoE.Add(moe))
      DeleteObjAndFalse(moe);
   moe.SetActivationFunction(SIGMOID);
   index++;
   moe = new CNeuronSparseMoEConv();
   if(!moe ||
      !moe.Init(0, index, OpenCL, hidden_dimension, expert_dimension, units * heads,
                                          candidates, topK, optimization, iBatch) ||
      !cSceneMoE.Add(moe))
      DeleteObjAndFalse(moe);
   moe.SetActivationFunction(TANH);
//---
   return true;
  }

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

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

Архитектурно это выглядит как многоступенчатый анализ торговой ситуации: сначала — общая картина, затем — детализация, далее — специализация и в завершение — режимная корректировка.

Алгоритм метода прямого прохода отражает основную философию работы блока.

bool CNeuronMTmixAttBlock::feedForward(CNeuronBaseOCL *NeuronOCL)
  {
   if(!cAttention.FeedForward(NeuronOCL))
      ReturnFalse;

Сначала активируется модуль Multi-Mix Attention. Здесь формируется первичное структурированное представление токенов, нормализованное и готовое для дальнейшей обработки. Внутри блока внимание выстраивает межфакторные зависимости, превращая сырой сигнал рынка в упорядоченную картину, где каждый токен несёт согласованную информацию о своей локальной и глобальной динамике.

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

   CNeuronBaseOCL* prev = cAttention.AsObject();
   CNeuronBaseOCL* curr = NULL;
//--- Shared Expert
   for(int i = 0; i < cSharedExpert.Total(); i++)
     {
      curr = cSharedExpert[i];
      if(!curr ||
         !curr.FeedForward(prev))
         ReturnFalse;
      prev = curr;
     }

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

После этого результаты модуля внимания передаются индивидуальным экспертам.

//--- Field MoE
   prev = cAttention.AsObject();
   for(int i = 0; i < cFieldMoE.Total(); i++)
     {
      curr = cFieldMoE[i];
      if(!curr ||
         !curr.FeedForward(prev))
         ReturnFalse;
      prev = curr;
     }

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

Следом включается сценарная ветвь.

//--- Scene MoE
   prev = cAttention.AsObject();
   for(int i = 0; i < cSceneMoE.Total(); i++)
     {
      curr = cSceneMoE[i];
      if(!curr ||
         !curr.FeedForward(prev))
         ReturnFalse;
      prev = curr;
     }

Опять же, анализируются результаты модуля внимания. Токены проходят через цепочку экспертов локальных сценариев. Благодаря Spike Super-Kernel Block и разным окнам обработки каждый токен анализируется в контексте ближайших соседей на нескольких масштабах, что позволяет выявлять локальные микро-сценарии — краткосрочные импульсы, коррекции, консолидации и их сочетания. Этот механизм обеспечивает динамическую адаптацию блока к реальному поведению рынка внутри выбранного пользователем окна исторических данных.

В финале результаты всех ветвей аккуратно агрегируются через последовательные вызовы SumAndNormilize.

   uint dimension = cAttention.GetDimension();
   if(!SumAndNormilize(cSharedExpert[-1].getOutput(), cFieldMoE[-1].getOutput(), Output,
                                                                  dimension, false, 0, 0, 0, 1) ||
      !SumAndNormilize(Output, cSceneMoE[-1].getOutput(), Output, dimension, false, 0, 0, 0, 1) ||
      !SumAndNormilize(Output, cAttention.getOutput(), Output, dimension, true, 0, 0, 0, 1))
      ReturnFalse;
//---
   return true;
  }

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

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

Архитектура модели

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

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

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

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

Энкодер формирует основу анализа состояния рынка. Его архитектура начинается с входного слоя, который принимает историю торговых баров, преобразованную в вектор признаков.

bool CreateDescriptions(CArrayObj *&encoder,
                        CArrayObj *&stfs,
                        CArrayObj *&actor,
                        CArrayObj *&critic
                       )
  {
//---
......
......
//--- Encoder
   encoder.Clear();
//--- Input layer
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   uint prev_count = descr.count = (HistoryBars * BarDescr);
   descr.activation = None;
   descr.optimization = ADAM;
   if(!encoder.Add(descr))
     {
      delete descr;
      return false;
     }
   iLatentLayer = 0;

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

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

//--- layer 1
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBatchNormOCL;
   descr.count = prev_count;
   descr.batch = BatchSize;
   descr.activation = None;
   descr.optimization = ADAM;
   if(!encoder.Add(descr))
     {
      delete descr;
      return false;
     }
   iLatentLayer++;

За ним идёт слой транспонирования, позволяющий упорядочить данные в согласованной структуре и подготовить их к последующему вложенному представлению признаков.

//--- layer 2
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronTransposeOCL;
   descr.count = HistoryBars;
   descr.window = BarDescr;
   descr.batch = BatchSize;
   descr.activation = None;
   descr.optimization = ADAM;
   if(!encoder.Add(descr))
     {
      delete descr;
      return false;
     }
   iLatentLayer++;

На следующем этапе включается слой FieldPatternEmbedding, который формирует эмбеддинги не перекрывающихся сегментов из четырёх последовательных элементов анализируемых унитарных последовательностей.

//--- layer 3
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronFieldPatternEmbedding;
   prev_count = descr.count = BarDescr * HistoryBars / 4;
   descr.window = 4;
   uint prev_out = descr.window_out = EmbeddingSize;
   descr.layers = NExperts;
   descr.step = TopK;
   descr.batch = BatchSize;
   descr.activation = SIGMOID;
   descr.optimization = ADAM;
   if(!encoder.Add(descr))
     {
      delete descr;
      return false;
     }
   iLatentLayer++;

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

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

//--- layer 4
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronAutoToken;
   descr.count = BarDescr;
   descr.window = prev_out;                  // Inputs window
   descr.window_out = EmbeddingSize;         // Embedding size
     {
      uint temp[] = {prev_count,             // Units In
                     NForecast               // Groups
                    };
      if(ArrayCopy(descr.units, temp) < (int)temp.Size())
         return false;
     }
   descr.layers = NExperts;                  // Candidates
   descr.step = 6;                           // Embedings in 1 group
   descr.batch = BatchSize;
   descr.activation = SIGMOID;
   descr.optimization = ADAM;
   if(!encoder.Add(descr))
     {
      delete descr;
      return false;
     }
   iLatentLayer++;
   prev_count = descr.units[1];
   prev_out = descr.window_out * descr.step;

Здесь важно подчеркнуть гибкость механизма группировки. Мы можем по-разному оценивать процесс формирования токенов и сами группы. Это могут быть сегменты, релевантные для конкретного элемента прогнозируемой последовательности, или блоки, отражающие один из возможных сценариев развития событий на рынке. Однако на этом этапе мы задаём лишь количество и размер групп. Конкретное наполнение токенов остаётся за моделью. Во время обучения она самостоятельно определяет, какие эмбеддинги сегментов объединять, исходя из поставленных задач и структуры обучающих данных. Такой подход делает модель адаптивной: она не следует жёстким правилам, а учится выявлять наиболее значимые комбинации информации для эффективного анализа динамики рынка.

И наконец, ключевой слой энкодера — MTmixAttBlock.

//--- layer 5
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronMTmixAttBlock;
   descr.window = prev_out;                                          //Dimension
   descr.count = prev_count;                                         //Units
   descr.step = 12;
   descr.window_out = EmbeddingSize;                                 //Hidden dimension
   descr.layers = NExperts;                                          //Candidates
   descr.variables = TopK;
   descr.batch = BatchSize;
   descr.activation = None;
   descr.optimization = ADAM;
   for(int i = 0; i < 3; i++)
     {
      if(!encoder.Add(descr))
        {
         delete descr;
         return false;
        }
      iLatentLayer++;
     }

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

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

Тестирование

И вот мы подошли к финальному этапу проекта. Архитектура модели полностью собрана, все модули согласованы и готовы к совместной работе. Теперь осталось проверить, как система ведёт себя в реальных рыночных условиях. Обучение стартовало на исторических данных по EURUSD на таймфрейме H1 за весь 2025 год. Эта фаза выполняла роль тренировочного полигона. Модель училась выявлять закономерности в поведении цены, различать импульсные движения и периоды консолидации, формировать взаимосвязи между токенами и экспертами, а также корректно интерпретировать сочетание локальных и глобальных зависимостей. Здесь создавалось начальное представление о состоянии рынка, отрабатывались навыки работы блока MTmixAttBlock и механизма адаптивной токенизации. А каждый токен начинал чувствовать контекст своего сегмента.

Следующий этап — онлайн-обучение в тестере стратегий MetaTrader 5 — перевёл систему в режим адаптации в реальном времени. Параметры модели динамически корректировались по мере поступления новых данных. Модель училась различать короткие импульсы и длинные тренды, учитывать периоды коррекции и смену рыночных сценариев, сохраняя при этом накопленный опыт. Такой подход позволял роботу реагировать на мгновенные изменения цены и закреплять устойчивые закономерности, формируя долговременное понимание рыночной динамики.

Финальная проверка проводилась на совершенно новых данных за период Январь–Февраль 2026 года. Это был полноценный out-of-sample тест, где модель не имела возможности подстраиваться под уже изученные события. Здесь проявилась её способность выделять значимые паттерны в динамике цены, различать смену сценариев и принимать адекватные торговые решения.

Результаты тестирования демонстрируют умеренно положительный финансовый результат при контролируемом уровне риска. Начальный депозит в 100 USD вырос до 112.40 USD, что соответствует 12.4% прироста капитала. Profit Factor равен 1.10, что указывает на минимальное стабильное статистическое преимущество. Максимальная просадка по балансу достигла 19.66 USD (≈19%), а по средствам — 21.50 USD (≈21%). Это формирует умеренно агрессивный риск-профиль.

Статистика сделок подчёркивает стратегию реже, но больше. Прибыльных сделок 44.6%, убыточных — 55.4%. Средняя прибыль выше среднего убытка (1.16 против 0.85 USD). Отношение дохода к риску 1.36. Крупнейшая прибыльная сделка — 7.92 USD, убыточная — −4.82 USD. Кривая капитала демонстрирует просадку, последующее восстановление и боковую динамику с локальными колебаниями.

Маржинальная нагрузка остаётся низкой, что обеспечивает безопасность использования капитала.

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

Заключение

В этой работе мы завершили создание и интеграцию ключевых компонентов фреймворка MTmixAtt в архитектуру торговой модели. На этапе энкодера данные исторических баров прошли через адаптивные слои FieldPatternEmbedding и AutoToken, где сформировались информативные токены, отражающие локальные и глобальные паттерны рынка. Блоки MTmixAttBlock обеспечили глубокий анализ взаимозависимостей между токенами, использование общих и индивидуальных экспертов, а также учёт локальных сценариев поведения цены.

Тестирование на исторических данных EURUSD H1 показало, что система способна генерировать положительное математическое ожидание и управляемую доходность. Несмотря на умеренный Profit Factor и относительную глубину просадок, результаты подтверждают работоспособность реализованных подходов и демонстрируют, что интеграция Multi-Mix Attention с MoE и адаптивной токенизацией обеспечивает реальное статистическое преимущество на рынке.

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

Ссылки

• MTmixAtt: Integrating Mixture-of-Experts with Multi-Mix Attention for Large-Scale Recommendation
• Другие статьи серии

Программы, используемые в статье

#	Имя	Тип	Описание
1	Study.mq5	Советник	Советник офлайн обучения моделей
2	StudyOnline.mq5	Советник	Советник онлайн обучения моделей
3	Test.mq5	Советник	Советник для тестирования модели
4	Trajectory.mqh	Библиотека класса	Структура описания состояния системы и архитектуры моделей
5	NeuroNet.mqh	Библиотека класса	Библиотека классов для создания нейронной сети
6	NeuroNet.cl	Библиотека	Библиотека кода OpenCL-программы