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

MetaTrader 5 — Торговые системы | 2 марта 2026, 13:08

Введение

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

Однако токенизация — это только первый уровень архитектуры.

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

Именно здесь начинается второй этап развития проекта.

В данной статье мы переходим к реализации более глубоких компонентов MTmixAtt — механизма Learnable Mixing Matrix и элементов Mixture-of-Experts. Если AutoToken отвечал за структурирование факторов, то теперь задача состоит в управляемом моделировании зависимостей между сформированными группами и построении адаптивной системы экспертной специализации.

Мы будем двигаться последовательно:

добавим обучаемое смешивание токенов;
реализуем межтокенное взаимодействие;
интегрируем механизм экспертной маршрутизации;
проверим инженерную реализуемость в среде MetaTrader 5.

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

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

Multi-Mix Attention

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

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

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

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

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

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

В традиционном Self-Attention взаимодействие строится через Q–K–V-проекции. Вычисляются скалярные произведения запросов и ключей, которые нормализуются SoftMax для получения взвешенной сумму значений. Это мощный механизм, но он ориентирован на сравнение токенов по признаковому пространству внутри каждой головы внимания. Проще говоря, он отвечает на вопрос: насколько один токен похож на другой.

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

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

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

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

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

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

Именно поэтому практическую реализацию Multi-Mix Attention мы оформляем в виде нового специализированного объекта — CNeuronMultiMixAttention, унаследованного от CNeuronBaseOCL.

class CNeuronMultiMixAttention   :  public CNeuronBaseOCL
  {
protected:
   CFieldAwareParams    cParams;
   //---
   virtual bool      feedForward(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      updateInputWeights(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      calcInputGradients(CNeuronBaseOCL *NeuronOCL) override;

public:
                     CNeuronMultiMixAttention(void) {};
                    ~CNeuronMultiMixAttention(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 defNeuronMultiMixAttention; }
   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;
   //---
   virtual uint      GetHeads(void) { return cParams.GetFiedls(); }
   virtual uint      GetUnits(void) { return uint(MathSqrt(cParams.Neurons() / GetHeads())); }
   virtual uint      GetDimension(void) { return Neurons() / GetUnits(); }
  };

Класс содержит защищённый блок параметров CFieldAwareParams. Это принципиально важный момент. Мы работаем с полями — структурированными подпространствами признаков. Для рынка это критично: цена, объём, производные индикаторы, лаговые признаки — это не просто столбцы таблицы, это разные семейства, и смешивание между ними должно быть управляемым.

В методе инициализации геометрия объекта задаётся не декларативно, а через жёсткие структурные ограничения.

bool CNeuronMultiMixAttention::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(dimension < heads || dimension % heads > 0)
      ReturnFalse;

Сначала фиксируется фундаментальный инвариант: размерность пространства признаков должна быть кратна количеству голов внимания. Иначе мы физически не сможем корректно разложить общее представление на параллельные attention-потоки.

Другими словами, каждая голова получает одинаковый фрагмент. Это классическая идея Multi-Head Attention, но в нашем случае она играет более глубокую роль. Мы создаем независимые поля внимания, которые позже будут участвовать в конкурентном смешивании.

Далее идёт вызов базовой инициализации средствами родительского класса.

   if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, units * dimension, optimization_type, batch))
      ReturnFalse;
   activation = None;

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

Теперь ключевая строка.

   if(!cParams.Init(0, 0, OpenCL, units * units, heads, embed_size,
                           candidates, topK, optimization, iBatch))
      ReturnFalse;
//---
   return true;
  }

И вот здесь становится понятно, что Multi-Mix Attention у нас устроен не как стандартный Transformer.

Обратите внимание: в cParams передаётся units * units. Это означает, что смешивание происходит по внутренней структуре units. Фактически мы организуем локальную матрицу взаимосвязей.

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

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

bool CNeuronMultiMixAttention::feedForward(CNeuronBaseOCL *NeuronOCL)
  {
   if(!NeuronOCL ||
      NeuronOCL.Neurons() < Neurons())
      ReturnFalse;

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

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

   if(bTrain)
      if(!cParams.FeedForward())
         ReturnFalse;

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

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

После этого начинается геометрическое разложение пространства. Количество голов берётся из cParams. Затем вычисляется число units как корень из отношения числа внутренних нейронов к количеству голов. Это не случайная формула. Она отражает тот факт, что внутри каждой головы существует двумерная структура взаимодействий. Мы работаем не с плоским вектором, а с решёткой связей между структурными компонентами. В результате формируется пространство вида units × dimension. Dimension делится между головами. А каждая голова получает собственный фрагмент — head_dimension.

   uint heads = cParams.GetFiedls();
   uint units = uint(MathSqrt(cParams.Neurons() / heads));
   uint dimension =  Neurons() / units;
   uint head_dimension = dimension / heads;

Здесь и проявляется ключевое отличие от классического Multi-Head Self-Attention. В стандартном Transformer внимание сопоставляет токены между собой. В нашей реализации смешивание происходит на уровне структурных единиц представления — units. Это ближе к тому, как трейдер оценивает не отдельные тики, а паттерны, группы признаков, блоки рыночного поведения.

Далее следует центральная операция — матричное умножение MatMul. На этом шаге матрица смешивания, подготовленная cParams, применяется к анализируемому представлению.

   if(!MatMul(cParams.getOutput(), NeuronOCL.getOutput(), Output, units,
                                   units, head_dimension, heads, true))
      ReturnFalse;

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

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

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

После применения Mixing-матриц к входу вызывается процедура суммирования и нормализации. Этот этап аккуратно объединяет результаты всех голов, добавляя остаточное соединение.

   if(!SumAndNormilize(NeuronOCL.getOutput(), Output, Output, dimension, true, 0, 0, 0, 1))
      ReturnFalse;
//---
   return true;
  }

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

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

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

Таким образом, CNeuronMultiMixAttention — это центральный элемент второго этапа развития MTmixAtt. И здесь есть стратегический момент. Традиционный подход к временным рядам рассматривает последовательность как поток, который нужно прокрутить через RNN или Transformer, мы же постепенно переходим к пространственному взгляду. График — это не линия, это структура, множество конкурирующих паттернов. Multi-Mix Attention позволяет этим паттернам конкурировать между собой и выживать сильнейшим.

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

Объект разреженного выбора эксперта

После того как Multi-Mix Attention научился переорганизовывать пространство признаков и формировать конкурентное поле структур, естественным следующим шагом становится вопрос: кто именно будет принимать окончательное решение? Если внимание — это механизм перераспределения влияния, то выбор эксперта — это механизм концентрации капитала. А в финансовом контексте это уже философия управления риском.

Именно здесь появляется объект разреженного выбора эксперта. По сути, это реализация принципа Mixture of Experts, но адаптированная под требования MTmixAtt и рыночной специфики. В классической архитектуре MoE существует набор экспертов и gating-сеть, которая распределяет веса между ними. В большинстве реализаций gating является мягким — веса нормализуются через SoftMax, и каждый эксперт получает свою долю влияния. Однако в финансовых задачах такой демократический подход часто приводит к размыванию сигнала. Рынок редко награждает усреднение. Чаще выигрывает чёткий выбор.

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

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

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

Если Multi-Mix Attention занимался структурной переорганизацией признаков, то SparseMoEConv решает другую задачу — выбор сценария обработки. И делает это до выполнения тяжёлых вычислений. Именно здесь принцип сначала выбираем, потом считаем реализуется буквально.

class CNeuronSparseMoEConv  :  public CNeuronBaseOCL
  {
protected:
   CNeuronFieldPatternEmbedding  cParams;
   //---
   virtual bool      feedForward(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      updateInputWeights(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      calcInputGradients(CNeuronBaseOCL *NeuronOCL) override;

public:
                     CNeuronSparseMoEConv(void) {};
                    ~CNeuronSparseMoEConv(void) {};
   //---
   virtual bool      Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                          uint window, uint filters, uint units,
                          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 defNeuronSparseMoEConv; }
   virtual void      SetOpenCL(COpenCLMy *obj) override;
   virtual void      TrainMode(bool flag) override;
   //---
   virtual bool      WeightsUpdate(CNeuronBaseOCL *source, float tau) override;
   virtual uint      GetWindow(void) const { return cParams.Neurons() / Neurons(); }
   virtual uint      GetFiedls(void) const { return cParams.GetFiedls(); }
   virtual uint      GetFilters(void) const { return Neurons() / GetFiedls(); }
  };

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

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

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

В стандартной Mixture of Experts gating-сеть вычисляет веса, после чего эксперты обрабатывают вход независимо, а их выходы агрегируются. В нашей архитектуре логика разворачивается иначе. Мы не запускаем всех экспертов. Мы сначала формируем разреженную SoftMax-матрицу на основании текущего анализируемого окна. Затем с её помощью генерируем взвешенный набор параметров свёрточного фильтра. И только после этого выполняется сама свёртка.

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

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

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

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

bool CNeuronSparseMoEConv::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                                uint window, uint filters, uint units,
                                uint candidates, uint topK,
                                ENUM_OPTIMIZATION optimization_type, uint batch)
  {
   if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, filters * units, optimization_type, batch))
      ReturnFalse;

Следующий шаг — инициализация cParams. Здесь уже проявляется вся магия динамической генерации экспертов.

   if(!cParams.Init(0, 0, OpenCL, window, units, window * filters, candidates,
                                                  topK, optimization, iBatch))
      ReturnFalse;
   cParams.SetActivationFunction(None);
//---
   return true;
  }

Параметр window задаёт локальное временное окно — фрагмент рынка, который анализируется текущим набором кандидатов. Units остаются внутренней размерностью выхода, а выражение window * filters формирует размер взвешенного набора параметров.

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

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

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

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

bool CNeuronSparseMoEConv::feedForward(CNeuronBaseOCL *NeuronOCL)
  {
   if(!cParams.FeedForward(NeuronOCL))
      ReturnFalse;

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

Дальше вычисляется базовая геометрия слоя.

   uint units = cParams.GetFiedls();
   uint filters = Neurons() / units;
   uint window = cParams.Neurons() / (filters * units);

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

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

   if(!MatMul(NeuronOCL.getOutput(), cParams.getOutput(), Output, 1, window, filters, units, true))
      ReturnFalse;
   dActivation(this);
//---
   return true;
  }

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

После матричного умножения вызывается заданная пользователем функция активации.

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

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

Если смотреть на архитектуру MTmixAtt в целом, получается последовательная логика. Сначала Multi-Mix Attention организует конкуренцию структур внутри представления. Затем SparseMoEConv организует конкуренцию сценариев обработки. Первый слой отвечает за переоценку факторов, второй — за выбор стратегии реакции. Это уже напоминает работу профессионального трейдера: сначала анализ ситуации, затем выбор конкретного действия.

Заключение

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

Практическая реализация этих подходов в виде объектов CNeuronMultiMixAttention и CNeuronSparseMoEConv заложила архитектурный фундамент для будущих торговых моделей.

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

Ссылки

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

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

Прикрепленные файлы |

Загрузить ZIP

MQL5.zip (3720.25 KB)

Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.

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

Другие статьи автора

Перейти к обсуждению на форуме трейдеров

Торговые инструменты на MQL5 (Часть 5): Создание бегущей тикерной строки для мониторинга символов в реальном времени

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

Возможности Мастера MQL5, которые вам нужно знать (Часть 66): Использование паттернов FrAMA и индекса силы с ядром скалярного произведения

Индикатор FrAMA и осциллятор индекса силы (Force Index) — инструменты анализа тренда и объема, которые можно использовать в паре при разработке советника. В продолжение нашей предыдущей статьи, в которой мы представили эту пару, рассмотрим применимость к ней машинного обучения. Мы используем сверточную нейронную сеть (convolution neural network), которая применяет ядро скалярного произведения (dot-product kernel) для построения прогнозов на основе входных данных этих индикаторов. Это делается в пользовательском файле класса сигналов (signal class), который взаимодействует с Мастером MQL5 для создания советника.

Трейдинг с экономическим календарем MQL5 (Часть 9): Расширение интерактивности с новостями через динамический скроллбар и улучшенное отображение

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

Торговые инструменты MQL5 (Часть 4): Улучшаем панель мультитаймфреймового сканера — динамическое позиционирование и сворачивание/разворачивание

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