Нейросети в трейдинге: Гибридные модели прогнозирования с управляемой смесью распределений (Окончание)

Введение

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

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

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

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

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

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

Проще говоря, модель умеет сказать: сейчас я уверена. Или наоборот — сейчас лучше не усложнять.

Для финансовых рынков это не косметическое преимущество. Это вопрос выживаемости стратегии. Большинство просадок возникает не в очевидных трендах, а в переходных состояниях. Когда структура уже меняется, но модель ещё не успела адаптироваться. Lattice снижает вероятность агрессивных ошибок именно в этих зонах неопределённости.

Здесь важно подчеркнуть различие с классическими Mixture-of-Experts системами. В традиционной смеси экспертов все компоненты участвуют в прогнозе с определёнными весами. Они всегда активны. В Lattice же возможен отказ от усложнения. Архетип может быть не подключён вовсе. Это принцип управляемой активации.

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

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

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

Во-вторых, появляется количественная метрика доверия. А это уже инструмент управления риском.

Отдельно стоит отметить модульность архитектуры. Базовый блок может быть адаптирован под конкретный инструмент или таймфрейм. Архетипы могут расширяться по мере накопления статистики. Механизм confidence может калиброваться под различный профиль риска — от консервативного до агрессивного. Это делает Lattice развивающимся фреймворком.

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

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

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

Мы усилили концепцию, сделав её ближе к реальной задаче управления капиталом. Гибридная структура Lattice в сочетании с Tail-Aware обучением архетипов формирует фундамент для системы, которая учитывает как среднее поведение рынка, так и его крайние состояния.

Объект верхнего уровня

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

Теперь пришло время собрать конструкцию целиком. До этого момента мы сознательно оставляли за скобками один критически важный компонент — базовую модель. Тот самый backbone, на который опирается вся система. Без него невозможно организовать полный цикл Lattice. Архетипы не существуют в вакууме. Confidence-Gating не может принимать решение без устойчивого базового представления временного ряда. Нужен фундамент. Причём фундамент не теоретический, а инженерно отработанный.

В качестве такого backbone в рамках проекта мы используем фреймворк ResFlow, ранее детально рассмотренный и реализованный средствами MQL5. Это решение не случайно и не продиктовано удобством повторного использования кода. ResFlow изначально разрабатывался как архитектура, способная эффективно моделировать временную динамику потоков с разделением на низкочастотную и высокочастотную составляющие. Именно эта особенность делает его естественным кандидатом на роль базового блока для Lattice.

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

Архетипы в этой структуре становятся надстройкой. Они не дублируют функциональность backbone. Они усиливают его там, где структура данных совпадает с определённым режимом. Confidence-Gating же выполняет роль регулятора между уровнями — он определяет, когда достаточно базовой оценки ResFlow, а когда стоит активировать специализированный корректирующий модуль.

Переход к верхнему уровню архитектуры требует не только концептуального объединения компонентов, но и строгой инженерной формализации. В нашей реализации эту роль берёт на себя новый объект — CNeuronResFlowLattice. По сути, это управляющий слой всей системы. Он наследует CNeuronResFlow, тем самым сохраняя backbone-логику ResFlow, но дополняет её механизмами архетипов, tail-aware обучения и confidence-gating.

class CNeuronResFlowLattice :  public CNeuronResFlow
  {
protected:
   CNeuronConfGateTailAwareMoE   cTailAwareMoE;
   CNeuronBaseOCL                cConcat;
   CNeuronSpikeSuperKernelBlock  cAdaptFlow;
   //---
   virtual bool      feedForward(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      updateInputWeights(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      calcInputGradients(CNeuronBaseOCL *NeuronOCL) override;

public:
                     CNeuronResFlowLattice(void) {};
                    ~CNeuronResFlowLattice(void) {};
   //---
   virtual bool      Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                          uint dimension, uint hidden_dimension,
                          uint ltr_forecast, uint htr_points_to_segment,
                          uint ltr_layers, uint ltr_candidates,
                          ENUM_OPTIMIZATION optimization_type, uint batch) override;
   //---
   virtual int       Type(void) override const  {  return defNeuronResFlowLattice;   }
   //--- methods for working with files
   virtual bool      Save(int const file_handle) override;
   virtual bool      Load(int const file_handle) override;
   //---
   virtual void      SetOpenCL(COpenCLMy *obj)   override;
   virtual void      TrainMode(bool flag) override;
   //---
   virtual bool      WeightsUpdate(CNeuronBaseOCL *source, float tau) override;
   virtual bool      Clear(void) override;
  };

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

В защищённой части класса появляются три ключевых компонента. cTailAwareMoE (CNeuronConfGateTailAwareMoE) — это центральный блок гибридной логики. Здесь объединяются архетипы, обученные с учётом хвостов распределения, и механизм confidence-gating. Именно этот модуль принимает решение, усиливать ли базовый прогноз ResFlow специализированной корректировкой. По сути, это стратегический регулятор сложности.

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

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

Мы не ограничиваемся простым взвешенным сложением двух прогнозов. Более того, мы раскладываем на составляющие информацию, поступающую из backbone ResFlow. И только после этого формируем итоговое представление.

ResFlow, как родительский класс, уже содержит две принципиально разные динамики: низкочастотную (LTR) и высокочастотную (HTR). На первом этапе мы просто конкатенируем их с признаками движения и прогнозом архетипов, полученным из cTailAwareMoE. Это операция создания расширенного латентного пространства, в котором каждая магистраль представлена явно. Мы не смешиваем сигналы преждевременно, а позволяем модели видеть их раздельно.

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

И вот здесь вступает в игру cAdaptFlow (CNeuronSpikeSuperKernelBlock). Если в оригинальной архитектуре итоговый прогноз — это линейная комбинация двух ветвей с фиксированным коэффициентом, то у нас итог формируется через обучаемую нелинейную адаптацию объединённого латентного пространства. cAdaptFlow выполняет роль интеллектуального сумматора. Он обучается определять:

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

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

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

В-третьих, сохраняется вычислительная стабильность. Даже при нулевом выходе cTailAwareMoE структура латентного пространства остаётся согласованной. Градиенты проходят корректно. Обучение не фрагментируется.

Непосредственная сборка всей архитектуры объекта осуществляется в методе инициализации. Именно здесь абстрактная схема Lattice превращается в конкретную вычислительную структуру. Без лишней магии. Строго и последовательно.

bool CNeuronResFlowLattice::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                                 uint dimension, uint hidden_dimension, uint ltr_forecast,
                                 uint htr_points_to_segment, uint ltr_layers, uint ltr_candidates,
                                 ENUM_OPTIMIZATION optimization_type, uint batch)
  {
   if(!CNeuronResFlow::Init(numOutputs, myIndex, open_cl, dimension, hidden_dimension,
                            ltr_forecast, htr_points_to_segment, ltr_layers,
                            ltr_candidates, optimization_type, batch))
      ReturnFalse;

Первый шаг — передача управления родительскому классу. Это принципиальный момент. Мы не строим Lattice с нуля, а опираемся на уже инициализированный backbone. ResFlow формирует базовую инфраструктуру: латентное пространство, LTR и HTR ветви, внутренние буферы OpenCL, параметры оптимизации. Если этот этап не завершён корректно, дальнейшая сборка теряет смысл. Поэтому при любом сбое инициализация немедленно прерывается.

Далее начинается надстройка. Сначала инициализируется cTailAwareMoE.

   uint index = 0;
   if(!cTailAwareMoE.Init(0, index, OpenCL, hidden_dimension, ltr_forecast,
                          GetUnits(), ltr_candidates, optimization, iBatch))
      ReturnFalse;

В параметрах передаётся размерность данных (hidden_dimension), количество элементов в анализируемой скрытом состоянии (ltr_forecast), глубина прогноза и число архетипов (ltr_candidates).

Обратите внимание на размерность: архетипы работают в том же латентном пространстве, что и backbone. Мы не создаём отдельную систему координат. Это обеспечивает согласованность признаков и корректную передачу градиентов.

Фактически cTailAwareMoE получает структурированное представление от ResFlow и возвращает либо адаптивный архетипический прогноз, либо нулевой тензор — если gating сочтёт режим недостаточно уверенным. Архитектурно это аккуратный узел, встроенный в общий граф.

Следующий шаг — инициализация cConcat.

   index++;
   if(!cConcat.Init(0, index, OpenCL, 4 * hidden_dimension * GetUnits(), optimization, iBatch))
      ReturnFalse;
   cConcat.SetActivationFunction(None);

Размер слоя должен быть достаточным для объединения признаков движения и прогнозов низкочастотной компоненты, высокочастотной компоненты и архетипов. Четыре магистрали — четыре блока признаков. Мы намеренно отключаем функцию активации. Конкатенация должна быть чистой операцией объединения. Без нелинейности. Без искажений. На этом этапе задача — сохранить структуру данных, а не трансформировать её.

И только после этого в игру вступает cAdaptFlow. Здесь начинается самое интересное.

   index++;
   uint windows[] = {3, 5};
   uint steps[] = {1, 1};
   if(!cAdaptFlow.Init(0, index, OpenCL, 4 * hidden_dimension, hidden_dimension,
                       windows, steps, GetUnits(), 1, optimization, iBatch))
      ReturnFalse;
//---
   return true;
  }

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

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

Таким образом, cAdaptFlow становится нелинейным агрегатором магистралей. Он извлекает из объединённого тензора устойчивые комбинации признаков, усиливая релевантные и подавляя второстепенные.

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

В результате метод инициализации формирует иерархическую архитектуру из трёх уровней. Причём вся структура инициализируется в едином OpenCL-контексте. Это гарантирует согласованность буферов и эффективное распределение вычислений на GPU. Для финансовых временных рядов с большим объёмом данных это не второстепенная деталь. Это фактор практической применимости.

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

bool CNeuronResFlowLattice::feedForward(CNeuronBaseOCL *NeuronOCL)
  {
   if(!cPrepare.FeedForward(NeuronOCL))
      ReturnFalse;

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

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

   CNeuronBaseOCL* prev = cPrepare.AsObject();
   CNeuronBaseOCL*curr = NULL;
   for(int i = 0; i < cContext.Total(); i++)
     {
      curr = cContext[i];
      if(!curr ||
         !curr.FeedForward(prev))
         ReturnFalse;
      prev = curr;
     }

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

   if(!cLTR.FeedForward(prev))
      ReturnFalse;

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

Однако архитектура ResFlow требует сопоставления низкочастотного прогноза с более детализированным представлением. Для этого используется операция LinearUpsample. Здесь прогноз LTR масштабируется к разрешению, соответствующему высокочастотному сегменту.

   uint hidden_dimension = cLTR.GetWindow();
   uint ltr_forecat = cLTR.GetUnits();
   uint htr_points_to_segment = cUpsampleLTR.Neurons() / cLTR.Neurons();
   if(!LinearUpsample(cLTR.AsObject(), cUpsampleLTR.AsObject(), htr_points_to_segment,
                      ltr_forecat, hidden_dimension))
      ReturnFalse;

Это критически важный шаг. Он обеспечивает согласованность пространств, позволяя объединять LTR и HTR без потери структурной целостности.

После этого поток направляется в блоки извлечения признаков движения.

   prev = cUpsampleLTR.AsObject();
   for(int i = 0; i < cMFE.Total(); i++)
     {
      curr = cMFE[i];
      if(!curr ||
         !curr.FeedForward(prev))
         ReturnFalse;
      prev = curr;
     }

Эти модули извлекают дополнительные признаки движения, усиливая представление локальной динамики.

Затем выполняется первая операция объединения.

   if(!Concat(prev.getOutput(), cUpsampleLTR.getOutput(), cMFEvsUpLTR.getOutput(), hidden_dimension,
              hidden_dimension, GetUnits()))
      ReturnFalse;

На этом этапе объединяются признаки движения и масштабированный прогноз LTR. Это формирует основу для работы высокочастотной ветви.

Далее управление передается cHTR. Это высокочастотный анализатор. Его задача — выявить локальные отклонения от базового тренда.

   if(!cHTR.FeedForward(cMFEvsUpLTR.AsObject(), cContext[-1].getOutput()))
      ReturnFalse;

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

И вот здесь начинается принципиальное отличие от классического ResFlow. В работу вступает cTailAwareMoE.

   if(!cTailAwareMoE.FeedForward(cLTR.AsObject()))
      ReturnFalse;

Архетипы получают на вход латентное представление LTR и оценивают, соответствует ли текущая структура одному из известных режимов. Если confidence недостаточен, на выходе формируется нулевой тензор. Это не аварийная ситуация, а корректное состояние архитектуры. Оно означает, что backbone способен самостоятельно описать текущую динамику.

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

После этого выполняется ключевая операция объединения.

   if(!Concat(cMFEvsUpLTR.getOutput(), cHTR.getOutput(), cTailAwareMoE.getOutput(),
              cConcat.getOutput(), 2 * hidden_dimension, hidden_dimension, hidden_dimension, GetUnits()))
      ReturnFalse;

Теперь в едином латентном пространстве сосуществуют 4 магистрали: базовые признаки движения, LTR-прогноз, уточнение высокочастотной ветви HTR и архетипический прогноз TailAwareMoE. Это момент архитектурной конвергенции. Но в отличие от оригинальной реализации Lattice, мы не используем фиксированное взвешивание. Управление объединением передаётся в cAdaptFlow.

   if(!cAdaptFlow.FeedForward(cConcat.AsObject()))
      ReturnFalse;

Он анализирует структуру объединённого латентного пространства и формирует итоговую корректировку. Это уже не статическая формула. Это обучаемая функция интеграции магистралей.

Далее происходит резидуальное объединение. Базовое представление, сформированное на этапе подготовки, усиливается адаптивной корректировкой.

   if(!SumVecMatrix(cPrepare.getOutput(), cAdaptFlow.getOutput(), cUpdatedFlow.getOutput(),
                    hidden_dimension, 1, 0, 0, 0, 1))
      ReturnFalse;

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

И наконец, финальный этап — формирование выходного представления.

   if(!CNeuronSpikeSuperKernelBlock::feedForward(cUpdatedFlow.AsObject()))
      ReturnFalse;
//---
   return true;
  }

Если посмотреть на весь алгоритм целиком, становится очевидна его стратегическая логика.

1. Сначала формируется устойчивое базовое представление.
2. Затем извлекаются признаки низко- и высокочастотной динамики.
3. После этого архетипы анализируют режим и при необходимости добавляют специализированную корректировку.
4. Далее адаптивный агрегатор обучаемо объединяет все магистрали.
5. И наконец, формируется финальный прогноз.

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

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

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

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

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

bool CNeuronResFlowLattice::calcInputGradients(CNeuronBaseOCL *NeuronOCL)
  {
   if(!NeuronOCL)
      ReturnFalse;
//---
   if(!CNeuronSpikeSuperKernelBlock::calcInputGradients(cUpdatedFlow.AsObject()))
      ReturnFalse;

Процесс начинается с финального сверточного блока, который аккумулировал всю ошибку выхода. Отсюда градиент спускается внутрь адаптивного агрегатора cAdaptFlow. Сначала снимается производная активации AdaptFlow. И только после этого градиент передаётся в cConcat, где 4 магистрали (MFE, Upsample LTR, HTR и TailAwareMoE) сходятся в едином латентном пространстве.

   if(!DeActivation(cAdaptFlow.getOutput(), cAdaptFlow.getGradient(),
                     cUpdatedFlow.getGradient(), cAdaptFlow.Activation()))
      ReturnFalse;
   if(!cConcat.CalcHiddenGradients(cAdaptFlow.AsObject()))
     ReturnFalse;

Далее мы работаем в духе родительского ResFlow, уделяя особое внимание изоляции влияния ошибки разных магистралей друг на друга. Здесь важно понять ключевую логику. Хотя cAdaptFlow в прямом проходе применяет нелинейности и взвешенную агрегацию, в процессе обучения мы не распределяем ошибку через блок конкатенации, как это обычно делается. Вместо этого каждая из трёх магистралей (LTR, HTR и архетипов) получает градиент ошибки в полном объёме напрямую с выхода адаптивного объединения. Это означает, что ни одна ветвь не ограничена частью сигнала. Каждая получает всю информацию о корректировке, которую система считает необходимой.

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

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

//---Tail-Aware
   if(!DeActivation(cTailAwareMoE.getOutput(), cTailAwareMoE.getGradient(),
                     cUpdatedFlow.getGradient(), cTailAwareMoE.Activation()))
      ReturnFalse;
   if(!cLTR.CalcHiddenGradients(cTailAwareMoE.AsObject()))
     ReturnFalse;

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

//--- HTR
   if(!DeActivation(cHTR.getOutput(), cHTR.getGradient(), cUpdatedFlow.getGradient(), cHTR.Activation()))
      ReturnFalse;
   if(!cContext[-1] ||
      !cMFEvsUpLTR.CalcHiddenGradients(cHTR.AsObject(), cContext[-1].getOutput(),
                                       cContext[-1].getGradient(),
                                       (ENUM_ACTIVATION)cContext[-1].Activation()))
      ReturnFalse;

Затем аккуратно выделяются градиенты MFE блока и распределяются по цепочке через все его компоненты.

//--- MFE
   uint hidden_dimension = cLTR.GetWindow();
   uint ltr_forecat = cLTR.GetUnits();
   uint htr_points_to_segment = cUpsampleLTR.Neurons() / cLTR.Neurons();
//---
   if(!cMFE[-1] ||
      !DeConcat(cMFE[-1].getGradient(), cUpsampleLTR.getGradient(), cMFEvsUpLTR.getGradient(),
                hidden_dimension, hidden_dimension, ltr_forecat * htr_points_to_segment))
      ReturnFalse;
   for(int i = cMFE.Total() - 2; i >= 0; i--)
     {
      if(!cMFE[i] ||
         !cMFE[i].CalcHiddenGradients(cMFE[i + 1]))
         ReturnFalse;
     }
   if(!cUpsampleLTR.CalcHiddenGradients(cMFE[0]))
      ReturnFalse;

Аналогичный путь проходят градиенты низкочастотной магистрали.

//--- LTR
   if(!DeActivation(cUpsampleLTR.getOutput(), cUpsampleLTR.getGradient(),
                     cUpdatedFlow.getGradient(), cUpsampleLTR.Activation()))
      ReturnFalse;
   if(!LinearUpsampleGrad(cLTR.AsObject(), cUpsampleLTR.AsObject(), htr_points_to_segment,
                          ltr_forecat, hidden_dimension))
      ReturnFalse;
   Deactivation(cLTR);
   CNeuronBaseOCL* next = cLTR.AsObject();

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

   for(int i = cContext.Total() - 1; i >= 0; i--)
     {
      if(!cContext[i] ||
         !cContext[i].CalcHiddenGradients(next))
         ReturnFalse;
      next = cContext[i];
     }
//---
   if(!cPrepare.CalcHiddenGradients(next))
      ReturnFalse;

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

   if(!NeuronOCL.CalcHiddenGradients(cPrepare.AsObject()))
      ReturnFalse;
//---
   return true;
  }

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

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

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

Мы полностью переосмыслили принципы Lattice и превратили их в целостный механизм, способный анализировать динамику цены в реальном времени. Теперь каждое движение рынка имеет значение, и система должна справляться без права на ошибку. В этом проявляются сильные стороны Lattice. Новый объект верхнего уровня CNeuronResFlowLattice аккуратно связывает архетипы с прогнозами низко- и высокочастотных модулей, сохраняя стабильность всей системы и одновременно обеспечивая возможность реагировать на резкие колебания цены.

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

Обучение модели началось на исторических данных EURUSD H1 с Января 2024 по Июнь 2025 года. Этот этап можно сравнить с тренировкой трейдера на демо-счёте. Рынок спокоен, ошибки не приводят к потерям, но именно здесь закладываются базовые навыки. Модель постепенно выявляла повторяющиеся паттерны, формируя внутреннее представление о движении цены в разных условиях. Особое внимание уделялось устойчивым закономерностям: моменты начала и конца тренда, повторяющиеся сценарии, поведение цены при локальных всплесках. Lattice связывает прошлое, настоящее и будущее, позволяя строить прогнозы на основе структуры рынка.

Затем последовало онлайн-обучение в тестере стратегий MetaTrader 5. Модель адаптировалась на лету, корректируя локальные оценки, но при этом сохраняла накопленный опыт. Lattice сохранял целостность прогнозов, плавно перестраивая внутренние представления даже при резких колебаниях цены, демонстрируя устойчивость всей архитектуры.

Финальная проверка на новых данных с Июля по Декабрь 2025 года показала, что система работает как единое целое. Без подстройки под прошлые события модель выявляет тенденции, отделяет шум от значимых движений и формирует прогноз. Lattice доказал, что сочетание стабильности и адаптивности позволяет принимать решения даже в условиях высокой неопределённости.

Результаты тестирования показывают, что реализованная модель Lattice формирует системный, статистически устойчивый торговый инструмент с умеренным риском и высоким качеством исполнения. За период тестирования модель совершила 63 сделки. Начальный депозит в 100USD вырос до итогового капитала 270,55USD, обеспечив прирост 170,55%.

Структура прибыли также подтверждает стабильность модели. Валовая прибыль составила 301,34USD, а убытки — 130,79USD, что даёт Profit Factor 2.30. Это явный сигнал качественной системы с положительным математическим ожиданием. На каждую сделку приходится ожидаемое значение 2.71USD, что указывает на устойчивое и прогнозируемое формирование прибыли.

Рисковые показатели находятся на умеренном уровне. Максимальная просадка по Equity достигла 16.36%, что контролируемо для такой доходности. Recovery Factor 4.33 показывает высокую способность модели восстанавливаться после локальных потерь. Низкая плавающая просадка указывает на то, что система плавно адаптируется к резким рыночным движениям, не разрушая общий прогноз.

Статистика сделок подтверждает эффективность. Общий Win Rate 63,49%, причём лонговые позиции показывают 68,75%, а шорты — 58,06%. Средний выигрыш превышает средний убыток в 1.32 раза. Это свидетельствует о низкой кластеризации потерь и устойчивой логике модели.

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

Заключение

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

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

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

Ссылки

• Lattice: A Confidence-Gated Hybrid System for Uncertainty-Aware Sequential Prediction with Behavioral Archetypes
• Tail-Aware Density Forecasting of Locally Explosive Time Series: A Neural Network Approach
• Другие статьи серии

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

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