preview
Нейросети в трейдинге: Сеточная аппроксимация событийного потока как инструмент анализа ценовых паттернов (EEMFlow)

Нейросети в трейдинге: Сеточная аппроксимация событийного потока как инструмент анализа ценовых паттернов (EEMFlow)

MetaTrader 5Торговые системы |
466 0
Dmitriy Gizlyk
Dmitriy Gizlyk

Введение

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

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

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

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

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

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

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

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


Архитектура EEMFlow

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

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

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

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

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

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

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

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

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

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

Каждый уровень модели уточняет движение предыдущего, подобно опытному аналитику, который сначала оценивает общий фон рынка. А затем шаг за шагом докапывается до структуры отдельных свечей, переходов крупных игроков и скрытых микроротаций. На каждом этапе используется единая формула уточнения: корреляция признаков → выравнивание (warping) → небольшая резидуальная добавка. В итоге поток становится чище, устойчивее и точнее.

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

С целью избавиться от этих артефактов, авторы фреймворка добавляют новый компонент — модуль доверительной детализации (Confidence-induced Detail Completion ModuleCDC). Это что-то вроде процедуры очистки данных после выгрузки котировок с биржевого шлюза. Сначала грубая интерполяция создаёт первичный слой F̄ᵢ, а дальше два параллельных механизма доводят результат до рабочей кондиции.

Первый канал — плотная сверточная сеть — работает локально, как внимательный трейдер, который изучает ближайшее окружение цены: поддержка, сопротивление, всплеск объёма рядом, тень предыдущей свечи. Этот канал выдает локальную корректировку ΔFᵢ и карту уверенности Wᵢ, показывающую, где модель сомневается в интерполяции и где движение, скорее всего, нарушено шумом.

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

Когда оба сигнала готовы, модель собирает уточнённый поток F̃ᵢ. Далее карта уверенности Wᵢ распределяет веса между первоначальной интерполяцией и детализированной версией. Почти как риск-менеджер выбирает баланс между консервативной оценкой и более агрессивным сценарием. В итоге формируется аккуратный Fᵢ↑. Он не растекается по краям, не размывает структуру. А подчеркивает именно то, что важно.

На этапе обучения всё работает на простой L1-регрессии, без усложнений. Это напоминает строгое тестирование торговых стратегий. Если модель ошиблась — она видит это напрямую, без маскировки и сглаживаний. И EEMFlow для MeshFlow, и EEMFlow+ для Optical Flow выдают результаты в том же разрешении, что и их эталоны. Так что процесс обучения остаётся честным и прозрачным.

Таким образом, EEMFlow+ демонстрирует крайне продуманный подход. Крупные структуры выстраиваются быстро, но критические детали восстанавливаются осторожно и с высокой точностью. Здесь можно провести аналогию с финансовыми рынками. Грубая картина задаёт направление. Но именно детали определяют, кто работает с ценой, а кто — с иллюзией.

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

Этот модуль, названный Adaptive Density Module (ADM), действует словно опытный риск-менеджер. Он не вмешивается в саму торговую модель, а лишь подготавливает рыночную информацию, обеспечивая ей здоровый баланс между волатильностью и структурностью. На вход модуль получает два анализируемых представления V1 и V2, которые на выходе превращаются их в выверенные версии Vad1 и Vad2. При этом они избавляются от чрезмерного шума, но не разрушаются важные детали. Внутри ADM работают два взаимодополняющих механизма: первый глобально перенастраивает плотность событий на разных масштабах, а второй выбирает подходящий уровень плотности в каждой точке изображения. Вместе они ведут себя аналогично алгоритмам, которые одновременно регулируют общий уровень риска портфеля и подстраивают вес отдельных активов. Один отвечает за стратегическую картину, другой за тактическую точность.

Глобальный компонент, Multi-Density Changer, построен как компактный энкодер–декодер из трёх уровней. Каждый уровень вычленяет свои признаки и затем восстанавливает их в различных масштабах. Минимализм архитектуры здесь продуман. Каждый блок содержит лишь одну свёртку, за которой следуют нормализация и активация. Это делает модуль быстрым, прозрачным и устойчивым — прямо как классические торговые системы, которые предпочитают простоту сложным моделям, легко впадающим в переобучение. На выходе MDC формирует несколько масштабных представлений, готовых к дальнейшему сопоставлению.

Затем в дело вступает Multi-Density Selector. Он сравнивает преобразованную версию потока с исходной. Объединяет их и вычисляет карту весов, определяя, какой из двух вариантов ближе к оптимальной плотности. SoftMax здесь выступает в роли тонкого балансировочного механизма, который динамически смешивает два варианта данных. В результате формируются представления Vad1 и Vad2, которые выглядят так, будто поток событий очистили от рыночного шума, сохранив локальные микропаттерны движения. Благодаря этому вся последующая сеть получает уже структурированную и хорошо сбалансированную картину.

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

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

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


Реализация средствами MQL5

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

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

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

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

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

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

class CNeuronSpikeSCM   :  public CNeuronSpikeConvBlock
  {
protected:
   CLayer            cScale;
   CNeuronBaseOCL    cConcat;
   //---
   virtual bool      feedForward(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      updateInputWeights(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      calcInputGradients(CNeuronBaseOCL *NeuronOCL) override;

public:
                     CNeuronSpikeSCM(void);
                    ~CNeuronSpikeSCM(void);
   //---
   virtual bool      Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                          uint window, uint window_out, uint units_count, uint variables,
                          ENUM_OPTIMIZATION optimization_type, uint batch);
   //---
   virtual int       Type(void) override const  {  return defNeuronSpikeSCM;   }
   //--- 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 bool      WeightsUpdate(CNeuronBaseOCL *source, float tau) override;
   virtual uint      GetWindow(void) const { return (!cScale[0] ? 0 :
                          ((CNeuronSpikeConvBlock*)cScale[0]).GetWindow());   }
   //---
   virtual void      SetActivationFunction(ENUM_ACTIVATION value) override { };
   virtual void      TrainMode(bool flag) override;
   virtual bool      Clear(void) override;
  };

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

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

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

bool CNeuronSpikeSCM::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                           uint window, uint window_out, uint units_count, uint variables,
                           ENUM_OPTIMIZATION optimization_type, uint batch)
  {
   if(!CNeuronSpikeConvBlock::Init(numOutputs, myIndex, open_cl, window + window_out,
                                   window + window_out, window_out, units_count,
                                   variables, optimization_type, batch))
      return false;

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

   uint index = 0;
   uint windows[1] = {window * 3};
   CNeuronSpikeConvBlock*           conv = NULL;
   CNeuronMultiWindowsConvWPadOCL*  pad = NULL;
   cScale.Clear();
   cScale.SetOpenCL(OpenCL);
//---
   pad = new CNeuronMultiWindowsConvWPadOCL();
   if(!pad ||
      !pad.Init(0, index, OpenCL, windows, window, (window_out + 3) / 4,
                        units_count, variables, optimization, iBatch) ||
      !cScale.Add(pad))
     {
      DeleteObj(pad)
      return false;
     }
   pad.SetActivationFunction(None);

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

   index++;
   conv = new CNeuronSpikeConvBlock();
   if(!conv ||
      !conv.Init(0, index, OpenCL, pad.GetFilters(), pad.GetFilters(), (window_out + 1) / 2,
                                            units_count, variables, optimization, iBatch) ||
      !cScale.Add(conv))
     {
      DeleteObj(conv)
      return false;
     }

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

   index++;
   windows[0] = conv.GetFilters() * 3;
   pad = new CNeuronMultiWindowsConvWPadOCL();
   if(!pad ||
      !pad.Init(0, index, OpenCL, windows, conv.GetFilters(), conv.GetFilters(),
                                units_count, variables, optimization, iBatch) ||
      !cScale.Add(pad))
     {
      DeleteObj(pad)
      return false;
     }
   pad.SetActivationFunction(None);
   index++;
   conv = new CNeuronSpikeConvBlock();
   if(!conv ||
      !conv.Init(0, index, OpenCL, pad.GetFilters(), pad.GetFilters(), window_out,
                                  units_count, variables, optimization, iBatch) ||
      !cScale.Add(conv))
     {
      DeleteObj(conv)
      return false;
     }
   index++;

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

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

   if(!cConcat.Init(0, index, OpenCL, (window + window_out)*units_count * variables, optimization, iBatch))
      return false;
//---
   return true;
  }

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

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

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

bool CNeuronSpikeSCM::feedForward(CNeuronBaseOCL *NeuronOCL)
  {
   CNeuronBaseOCL* prev = NeuronOCL;
   CNeuronBaseOCL* curr = NULL;
   for(int i = 0; i < cScale.Total(); i++)
     {
      curr = cScale[i];
      if(!curr ||
         !curr.FeedForward(prev))
         return false;
      prev = curr;
     }

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

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

   uint units = GetUnits() * GetVariables();
   uint window_in = NeuronOCL.Neurons() / units;
   uint window_prev = prev.Neurons() / units;
   if(!Concat(NeuronOCL.getOutput(), prev.getOutput(), cConcat.getOutput(), window_in, window_prev, units))
      return false;
   if(!CNeuronSpikeConvBlock::feedForward(cConcat.AsObject()))
      return false;
//---
   return true;
  }

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

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

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

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


Заключение

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


Ссылки


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

# Имя Тип Описание
1 Study.mq5 Советник Советник офлайн обучения моделей
2 StudyOnline.mq5 Советник Советник онлайн обучения моделей
3 Test.mq5 Советник Советник для тестирования модели
4 Trajectory.mqh Библиотека класса Структура описания состояния системы и архитектуры моделей
5 NeuroNet.mqh Библиотека класса Библиотека классов для создания нейронной сети
6 NeuroNet.cl Библиотека Библиотека кода OpenCL-программы
Прикрепленные файлы |
MQL5.zip (3425.93 KB)
Разработка инструментария для анализа движения цен (Часть 15): Введение в теорию четвертей (II) — советник Intrusion Detector Разработка инструментария для анализа движения цен (Часть 15): Введение в теорию четвертей (II) — советник Intrusion Detector
В нашей предыдущей статье мы представили простой скрипт Quarters Drawer. Продолжая тему, создадим советник для отслеживания четвертей и предоставления информации о потенциальной реакции рынка на этих уровнях. В статье описана разработка инструмента для обнаружения необходимых зон.
Возможности Мастера MQL5, которые вам нужно знать (Часть 56): Фракталы Билла Вильямса Возможности Мастера MQL5, которые вам нужно знать (Часть 56): Фракталы Билла Вильямса
Фракталы Билла Вильямса — это мощный индикатор, который легко упустить из виду, когда впервые замечаешь его на ценовом графике. Он кажется слишком перегруженным и, вероятно, недостаточно точным. Моя цель - приоткрыть завесу тайны над этим индикатором, рассмотрев различные его паттерны на форвард-тестах применительно к советникам, собранным в Мастере.
Разработка инструментария для анализа движения цен (Часть 17): Советник TrendLoom Разработка инструментария для анализа движения цен (Часть 17): Советник TrendLoom
Как ценовой аналитик и трейдер, я заметил, что когда тренд подтверждается на нескольких таймфреймах, он обычно продолжается в этом направлении. Продолжительность тренда может варьироваться в зависимости от стратегии трейдера: держит ли он позиции на долгосрочную перспективу или занимается скальпингом. Выбранные вами таймфреймы играют решающую роль. Статья знакомит с быстрой автоматизированной системой, которая помогает увидеть общий тренд сквозь разные тймфреймы всего одним нажатием кнопки или с помощью регулярных обновлений.
Знакомство с языком MQL5 (Часть 20): Введение в гармонические паттерны Знакомство с языком MQL5 (Часть 20): Введение в гармонические паттерны
В этой статье мы исследуем основы гармонических паттернов, их структуру и то, как они применяются в торговле. Вы узнаете о коррекциях и расширениях Фибоначчи, а также о том, как реализовать обнаружение гармонических паттернов на языке MQL5, тем самым закладывая основу для создания продвинутых торговых инструментов и советников.