Нейросети в трейдинге: Асинхронная обработка событий в потоковых моделях (EVA-Flow)

Введение

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

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

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

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

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

Работа "Towards Anytime Optical Flow Estimation with Event Cameras" принадлежит именно к этой парадигме. Её авторы предлагают фреймворк EVA-Flow, разработанный для обработки асинхронных потоков событий в задачах компьютерного зрения. Формально речь идёт об event-камерах, но по сути — о куда более универсальной идее. Модель не ждёт, когда данные будут собраны, а обновляет своё представление каждый раз, когда приходит новое событие. Это принцип Anytime-вычислений — результат существует всегда, даже если поток данных внезапно оборвался. Модель не работает пакетами, она живёт в потоке.

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

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

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

Таким образом, EVA-Flow интересен для нас как носитель архитектурной идеи, которая давно назрела в алгоритмическом трейдинге. Асинхронная обработка событий, anytime-вычисления, потоковые модели без фиксированных таймфреймов — всё это звучит как эксперимент, но по сути является возвращением к здравому смыслу. Рынок всегда был потоком.

Архитектура EVA-Flow

В основе EVA-Flow лежит идея непрерывного, потокового обновления оценки движения. Модель реагирует на каждое новое событие так же естественно, как рынок реагирует на появление нового ордера. Архитектура выстроена таким образом, чтобы работать строго в моменте, обновляя состояние системы сразу после поступления очередного бина событий. Это принципиально меняет логику обработки — вместо дискретных пересчётов возникает живой процесс, синхронизированный со временем самой среды.

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

Классический Voxel Grid строится на идее дискретизации пространственно-разреженного и временно-непрерывного потока событий. Для этого весь временной интервал наблюдения усредняется и разбивается на несколько временных бинов. Далее для каждого события выполняется билинейная интерполяция одновременно в пространственном и временном измерениях. В результате формируется трёхмерный тензор размерности B×H×W. Здесь B — количество временных срезов, а H и W соответствуют пространственному разрешению. Каждый временной канал можно рассматривать как представление событий в определённый момент времени, а плотность разбиения по оси B определяет точность временного квантования.

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

Однако у этого подхода есть фундаментальное ограничение, которое становится критичным при переходе к задачам непрерывного, высокочастотного анализа. Чтобы сформировать полный Voxel Grid, необходимо дождаться поступления всех событий за весь временной интервал T. Только после этого можно построить тензор и передать его в модель. Архитектурно это делает представление пакетным, а значит, добавляет неизбежную задержку. Модель физически не может начать обработку, пока интервал не закрыт. Для задач с высокой динамикой, где важны миллисекунды, такое ожидание становится неприемлемым.

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

Именно для устранения этих ограничений авторы EVA-FLow вводят Unified Voxel Grid — представление, в котором изменена сама логика работы со временем. В отличие от классического Voxel Grid, Unified Voxel Grid не требует ожидания завершения полного интервала. Он формируется последовательно, вокруг текущего момента времени, используя только локальное окно событий. Каждому временному каналу соответствует фиксированная временная поддержка 2τ, центрированная относительно его временной метки. В результате каждая временная ячейка строится одинаковым образом и имеет одинаковую информационную плотность.

Это означает, что модель может получить актуальное представление событий в любой момент, не дожидаясь накопления всего временного диапазона. Как только проходит очередной интервал τ, появляется новое входное представление, которое сразу же может быть передано в сеть. В экспериментальных настройках авторов это позволяет получать обновление каждые 5 миллисекунд, тогда как классический Voxel Grid требовал ожидания порядка 100 миллисекунд для формирования полного тензора.

С архитектурной точки зрения это принципиальный сдвиг. Представление перестаёт быть кадром и становится потоком. Вход в модель больше не синхронизирован с временными окнами. Он синхронизирован с событиями. Это делает Unified Voxel Grid естественным спутником Anytime-архитектур, в которых результат должен быть доступен всегда, а не только в моменты завершения интервала.

Если перенести эту идею в финансовый контекст, различие становится ещё нагляднее. Классический Voxel Grid эквивалентен свечному бару. Данные собираются, усредняются, а затем передаются в модель. Unified Voxel Grid ближе к тиковому потоку, где каждое новое событие сразу же обновляет состояние системы. Модель перестаёт ждать закрытия бара и начинает жить в рынке, реагируя на изменения по мере их появления. Именно это делает возможной асинхронную обработку событий и минимальную задержку, столь критичную для высокочастотного анализа.

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

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

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

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

Центральным элементом всей архитектуры остаётся модуль Spatiotemporal Motion Recurrent (SMR). Его внутренняя организация сочетает два принципа, проверенных временем: иерархическое уточнение от грубого к точному и рекуррентное накопление временного контекста. На грубых уровнях формируется первичная оценка движения, устойчивая и стабильная. А более детальные уровни аккуратно корректируют её, не нарушая общей структуры. Такой подход резко снижает риск ошибок, связанных с шумом и локальными выбросами, что особенно важно при работе с асинхронными данными.

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

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

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

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

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

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

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

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

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

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

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

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

Авторская визуализация фреймворка EVA-Flow представлена ниже.

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

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

Второе ограничение связано с разреженным временным надзором. Хотя EVA-Flow формирует плотную по времени последовательность оценок, обучается она в основном на разреженной разметке, предоставляемой датасетами с низкой частотой Ground Truth. Метрика RFWL позволяет косвенно контролировать качество промежуточных состояний, но сеть всё же не получает прямого сигнала ошибки для каждого временного шага. Это означает, что промежуточные оценки формируются скорее архитектурой, чем обучающей выборкой.

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

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

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

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

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

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

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

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

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

Из EEMFlow мы берём Adaptive Density Module — модуль адаптации плотности. Его роль заключается в динамическом управлении насыщенностью представления в зависимости от текущей активности среды. Вместо фиксированного объёма событий, ADM позволяет регулировать плотность входного потока, усиливая представление в периоды низкой активности и сжимая его при всплесках событий. Таким образом, модель перестаёт быть заложником выбранного окна и начинает подстраивать входные данные под реальную динамику рынка.

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

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

class CNeuronSpikeUSR   :  public CNeuronSpikeADM
  {
protected:
   CNeuronCreateICEFlow    cFlow;
   //---
   virtual bool      feedForward(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      updateInputWeights(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      calcInputGradients(CNeuronBaseOCL *NeuronOCL) override;

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

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

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

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

bool CNeuronSpikeUSR::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                           uint stack_size, uint dimension,
                           uint patch_dimension, uint variables,
                           ENUM_OPTIMIZATION optimization_type, uint batch)
  {
   if(!CNeuronSpikeADM::Init(numOutputs, myIndex, open_cl, patch_dimension,
                             stack_size, variables, optimization_type, batch))
      ReturnFalse;

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

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

   if(!cFlow.Init(0, 0, OpenCL, stack_size, dimension, patch_dimension,
                                       variables, optimization, iBatch))
      ReturnFalse;
//---
   return true;
  }

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

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

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

bool CNeuronSpikeUSR::feedForward(CNeuronBaseOCL *NeuronOCL)
  {
   if(!cFlow.FeedForward(NeuronOCL))
     ReturnFalse;
   if(!CNeuronSpikeADM::feedForward(cFlow.AsObject()))
     ReturnFalse;
//---
   return true;
  }

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

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

В результате CNeuronSpikeUSR становится не просто реализацией одной идеи, а точкой сборки сразу нескольких концепций. Он объединяет адаптивную плотность, совместное представление и потоковую обработку в едином узле.

Заключение

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

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

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

Ссылки

• Towards Anytime Optical Flow Estimation with Event Cameras
• Другие статьи серии

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

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