Redes neurais no trading: Percepção adaptativa da dinâmica de mercado (STE-FlowNet)

Introdução

Nos últimos anos, os mercados financeiros vêm passando por uma transformação acelerada sob a influência do aprendizado profundo. E torna-se cada vez mais urgente a tarefa de criar modelos capazes não apenas de identificar padrões nos dados, mas também de formar uma representação estável dos aspectos temporais, contextuais e estruturais da dinâmica de mercado. Nesse contexto, destaca-se o framework STE-FlowNet, proposto no trabalho “Spatio-Temporal Recurrent Networks for Event-Based Optical Flow Estimation”, que demonstra uma nova abordagem para o processamento de sequências de eventos. Nele, cada etapa não se limita a refletir os dados atuais, mas reestrutura dinamicamente a representação interna do sistema, adaptando-se às mudanças no fluxo de informações analisado.

O mercado financeiro é um sistema extremamente complexo e não linear, sujeito a rupturas de regime repentinas, reações em cascata e padrões raros, mas significativos. Modelos recorrentes clássicos, como o LSTM e o GRU, costumam apresentar inércia nessas condições. Eles ou fazem uma média do histórico, perdendo eventos importantes de curto prazo, ou reagem de forma exagerada ao ruído. O framework STE-FlowNet resolve esse problema de outra maneira. Ele reestrutura dinamicamente suas representações internas, adaptando os filtros e a sensibilidade temporal a cenários de mercado específicos. Esse comportamento lembra o de um trader experiente, que interpreta os acontecimentos no contexto de condições em constante mudança.

A principal vantagem do STE-FlowNet está em trabalhar com a evolução dos estados de mercado. O framework monitora a dinâmica das estruturas ocultas, o que é especialmente importante na modelagem de mudanças de regime, picos de liquidez e alterações no equilíbrio de forças entre os participantes. Em vez de fazer previsões pontuais sobre a continuação da série temporal, o modelo aprende a perceber o curso dos eventos, adaptando suas representações internas às novas condições. Essa abordagem transforma a previsão em percepção adaptativa, o que é especialmente valioso para a construção de estratégias de trading robustas.

A filosofia arquitetural concentra-se na percepção viva do mercado. O passado é visto como um mapa flexível de trajetórias, que se reestrutura de acordo com novos eventos. Isso permite que o modelo mantenha a relevância em relação às dependências de longo prazo e, ao mesmo tempo, detecte eventos críticos de curto prazo. O método proposto para o processamento de dados é particularmente valioso para os mercados financeiros, onde é importante não apenas registrar o histórico, mas também interpretar as mudanças em sua estrutura.

Hoje, quando os padrões de mercado se tornam menos previsíveis e os períodos de equilíbrio relativo são interrompidos por bruscos deslocamentos de fase, os modelos adaptativos tornam-se uma necessidade. Os métodos clássicos de análise costumam falhar: ou identificam características desatualizadas, ou reagem com atraso, quando a estrutura do mercado já se alterou. É justamente aqui que o framework em questão demonstra sua vantagem, permitindo adaptar-se às novas regras do jogo quase instantaneamente.

O modelo constrói uma percepção do mercado como sistema dinâmico. Cada novo sinal atualiza o estado e reinterpreta o contexto das observações anteriores. Isso aproxima o algoritmo do raciocínio de um trader profissional, que atualiza ativamente suas hipóteses sobre o regime de mercado atual. Como resultado, surge uma ferramenta capaz de reconhecer a tempo uma mudança de contexto e adaptar a estratégia, o que é de importância crucial para aplicações financeiras.

A arquitetura do framework é, desde o início, voltada para a adaptabilidade aplicada: ela avalia a fase atual do mercado e ajusta a lógica interna de percepção em tempo real, garantindo a robustez do modelo diante de mudanças no regime de mercado. Isso a torna especialmente valiosa para a elaboração de estratégias capazes de reagir às mudanças no contexto, e não apenas ao movimento do preço.

Algoritmo STE-FlowNet

O framework STE-FlowNet baseia-se na ideia do processamento recorrente espaço-temporal de eventos, o que permite analisar sequências complexas de dados com alto grau de precisão. O modelo recebe um fluxo de eventos das câmeras e, gradualmente, constrói uma representação interna do movimento, levando em conta cada novo evento e atualizando constantemente a memória interna.

Cada bloco do modelo processa sequências curtas de eventos, analisando-as minuciosamente do ponto de vista das dependências espaciais e temporais. Isso permite reconhecer o movimento mesmo em alta velocidade e em cenas dinamicamente complexas, nas quais os métodos tradicionais costumam perder detalhes importantes.

Aos poucos, vai se formando uma representação estável da dinâmica, o que permite prever o desenvolvimento dos eventos com alta precisão. O estado interno da rede contém características locais e globais do movimento, o que permite que o modelo perceba estruturas complexas e preveja padrões em diferentes escalas temporais.

A representação dos dados de entrada no STE-FlowNet baseia-se nas características de funcionamento das câmeras de eventos, que reagem a variações no logaritmo da intensidade luminosa que excedem um limiar definido θ. Cada evento registra as coordenadas do pixel, o tempo de registro e a polaridade da variação (aumento ou diminuição do brilho), o que pode ser representado como e = {x, t, p}. No contexto dos mercados financeiros, é possível traçar uma analogia com a realização de uma transação que resulta em uma variação no preço ou no volume. Cada registro contém informações de importância crítica sobre o estado atual do sistema e pode servir como um sinal para a análise da dinâmica de mercado. Isso torna o fluxo de eventos uma fonte rica de dados, capaz de identificar até mesmo tendências pouco perceptíveis e oscilações bruscas.

O fluxo de eventos, no entanto, pode ser parcialmente perdido devido a limitações na largura de banda dos pixels, especialmente em cenas de alta velocidade e textura complexa. No contexto financeiro, isso se assemelha à omissão de transações específicas ou de oscilações instantâneas de preços em mercados ativos. Os métodos tradicionais de soma ou agregação de dados muitas vezes não permitem acompanhar mudanças rápidas e deixam passar padrões de curto prazo. Para resolver esse problema, os autores do framework propuseram uma representação modificada dos dados analisados, que amplifica o sinal e permite identificar eventos críticos que determinam a dinâmica subsequente do sistema.

Todos os eventos são divididos em N partes iguais, com o mesmo número de eventos. A simples soma dos eventos para formar uma imagem não reflete os detalhes reais do movimento ao longo desse período. Se os eventos estiverem concentrados em um curto intervalo de tempo, isso indica alta atividade, seja o movimento rápido de objetos na cena, seja um aumento repentino da atividade de trading no mercado. Para levar em conta essas particularidades, é introduzida uma escala de pesos baseada na distribuição temporal dos eventos. Os eventos de alta densidade recebem maior peso, permitindo que a STE-FlowNet se concentre em momentos significativos e ignore oscilações menos críticas.

Para um conjunto de M eventos (xi, yi, ti, pi), com i ∈ [1:M], aplica-se em um único bloco um modelo gaussiano para aproximar sua distribuição temporal. A cada evento é atribuído um peso correspondente.

Aqui, kg(a) é o núcleo de amostragem pelo modelo gaussiano, µ é o valor médio das marcas temporais, σ é a variância calculada com base em todos os M eventos. λ é o coeficiente de normalização.

Quanto mais concentrados os eventos estiverem no tempo, maior será o seu peso. Isso permite que o modelo identifique períodos de atividade intensa. No contexto financeiro, isso permite identificar períodos de maior volatilidade, picos abruptos de atividade de trading ou anomalias que podem prenunciar pontos-chave do mercado. Todos os valores ponderados são arredondados para cima, a fim de preservar a relevância de cada evento e não perder informações críticas sobre mudanças rápidas.

Dessa forma, o modelo STE-FlowNet torna-se capaz de identificar micromovimentos e padrões que normalmente se perdem na agregação convencional dos dados e de usá-los para elaborar previsões mais precisas, avaliar riscos e desenvolver estratégias altamente adaptáveis.

A arquitetura geral do STE-FlowNet é uma variante de modelo do tipo Encoder-Decoder. Cada imagem de eventos passa por quatro módulos de encoder, cada um dos quais duplica o número de canais de saída e reduz a resolução dos dados pela metade. Em seguida, os mapas de características obtidos dos encoders passam por dois blocos residuais, o que permite reforçar a representação das características e manter a estabilidade dos gradientes.

Além disso, entre cada nível do encoder e o decoder correspondente, existe uma conexão skip, que garante um fluxo direto de informações, preservando características locais e globais importantes. Ao passar pelo módulo do decoder, os dados são submetidos a uma convolução transposta para dobrar a resolução. Após passar por todos os quatro módulos do decoder, a imagem é restaurada ao seu tamanho original. Essa estrutura permite que o modelo reproduza com precisão os detalhes espaciais e preserve características críticas da dinâmica dos eventos.

O STE-FlowNet também gera mapas de fluxo intermediário (intermediate flow) em cada resolução, que são então utilizados como parte dos dados de entrada para o decoder seguinte. Durante o treinamento, a função de perda é aplicada a todos os mapas intermediários, o que melhora o treinamento e aumenta a precisão das previsões. Essa arquitetura é particularmente útil para fluxos financeiros, nos quais é importante acompanhar simultaneamente padrões de curto e longo prazo: os fluxos intermediários ajudam a identificar micromovimentos dos preços, picos bruscos de volume e outros eventos significativos, criando um modelo de análise mais confiável e adaptável.

Um componente essencial da extração de características no STE-FlowNet é o ConvGRU, que desempenha um papel central no processamento de informação espaço-temporal. Embora o ConvGRU já tenha sido utilizado em alguns estudos com dados baseados em quadros, anteriormente sua funcionalidade se limitava ao uso de mapas de características de alto nível provenientes das camadas superiores da ConvNet. Com isso, perde-se grande parte da informação local, e as variações temporais entre os quadros são frequentemente atenuadas. Isso dificulta a detecção precisa de movimentos sutis e mudanças rápidas.

No contexto dos fluxos financeiros, isso é comparável à perda de informações sobre oscilações de preços de curto prazo ou microtransações, que podem ser de importância crítica para a tomada de decisões de trading e a avaliação dos riscos de mercado. Para resolver esse problema, os autores do framework STE-FlowNet propuseram módulos de encoder que utilizam o ConvGRU para a extração sequencial de características espaço-temporais em diferentes níveis de resolução, preservando padrões locais de movimento e detalhes da dinâmica. Isso permite monitorar até mesmo as menores variações no fluxo de dados.

A imagem de eventos em análise passa por duas arquiteturas paralelas que se assemelham a uma pirâmide. O primeiro caminho passa pela ConvNet, que gera mapas de características espaciais em diferentes níveis de resolução, fornecendo um contexto global e capturando a estrutura geral do evento. O segundo caminho passa pelos encoders espaço-temporais em cada nível. Cada encoder inclui um ConvGRU e uma convolução com stride. Essa abordagem fornece ao modelo informações sobre oscilações locais rápidas e, ao mesmo tempo, sobre tendências globais mais lentas. Na análise financeira, isso pode ser interpretado como o acompanhamento simultâneo de picos momentâneos de atividade de trading e de tendências de longo prazo do mercado, o que aumenta a precisão das previsões e permite identificar pontos críticos para a tomada de decisões estratégicas.

Em cada passo temporal t, a entrada do ConvGRU inclui três componentes principais:

• mapas de características Fst,t do encoder espaço-temporal do nível inferior,
• estado oculto ht-1 do passo anterior,
• saída da camada de correlação Ct no mesmo nível de resolução.

O ConvGRU é definido pelas seguintes equações:

A camada de correlação calcula a correspondência entre os mapas de características espaciais do evento atual Fst,t e do primeiro evento Fs,1, utilizando o fluxo predito f* da iteração anterior.

A construção passo a passo da previsão do fluxo, com base nas informações dos passos anteriores, é semelhante ao trabalho analítico de um trader, que avalia cada nova operação no contexto dos eventos anteriores. Isso permite modelar com maior precisão a evolução dos processos de mercado, identificar possíveis pontos de entrada e saída, bem como desenvolver estratégias adaptativas capazes de reagir rapidamente às mudanças no ambiente de mercado.

Além disso, essa arquitetura aumenta a robustez do modelo a oscilações ruidosas, anomalias e eventos raros, criando uma ferramenta confiável para a análise abrangente de fluxos financeiros e para o apoio à tomada de decisões em mercados altamente competitivos.

Para aumentar a precisão e a confiabilidade das previsões, o STE-FlowNet utiliza um esquema de refinamento iterativo. Cada iteração gera um fluxo residual ∆fk, que é acumulado com a estimativa anterior fk-1, formando uma previsão atualizada fk = fk-1 + ∆fk, a partir de f0 = 0.

A reutilização do mesmo bloco com pesos compartilhados garante a consistência das iterações, a economia de recursos e a estabilidade do treinamento. As previsões intermediárias têm dois objetivos. Em primeiro lugar, elas são utilizadas como parte dos dados de entrada para a próxima iteração, garantindo uma correção precisa com base nas estimativas anteriores. Em segundo lugar, como uma conexão skip, que adiciona o fluxo predito à saída atual do modelo, permitindo refinar a previsão com alto nível de detalhamento. Essa estratégia em várias etapas é semelhante à análise por etapas das previsões financeiras, na qual cada nova estimativa de preço, volume ou indicador é refinada levando em conta todos os dados anteriores, criando um modelo adaptativo e preciso do movimento do mercado.

O processo iterativo permite levar em conta não apenas a sequência de eventos, mas também possíveis ruídos, eventos raros e oscilações bruscas, aumentando a robustez do modelo à instabilidade dos mercados financeiros. Isso garante a elaboração de previsões com alto nível de detalhamento e confiabilidade. A STE-FlowNet é capaz de processar grandes fluxos de eventos, registrando cada movimento significativo, integrando-o ao panorama geral e criando uma representação completa do estado atual do mercado.

A arquitetura recorrente e iterativa da STE-FlowNet permite processar eventos quadro a quadro, levando em conta toda a sequência de alterações anteriores. No contexto financeiro, isso significa a capacidade de registrar com precisão as oscilações instantâneas dos preços e os picos repentinos de atividade de trading, bem como identificar eventos raros e anômalos, levando em conta, ao mesmo tempo, as tendências globais do mercado. O refinamento iterativo garante a adaptação dinâmica do modelo a novos dados e permite elaborar previsões com alta confiabilidade, nível de detalhe e previsibilidade, o que é crítico para a análise abrangente de riscos, a gestão adaptativa de capital e o planejamento estratégico em mercados instáveis e em rápida mudança, nos quais cada milissegundo pode influenciar significativamente o resultado da tomada de decisões.

Para treinar a STE-FlowNet, os autores do framework utilizam fluxos sincronizados de eventos e imagens em tons de cinza, o que permite implementar o aprendizado auto-supervisionado. O fluxo de eventos entre duas imagens consecutivas (It, It+dt) é transformado em uma série de imagens de eventos, que são fornecidas sequencialmente à rede. Ao mesmo tempo, o fluxo predito f = (f¹, f²) é aplicado à segunda imagem para gerar uma distorção, o que permite calcular o erro e treinar o modelo sem anotações explícitas. Essa abordagem permite que a STE-FlowNet aprenda a estimar com precisão o movimento dos eventos, mesmo em condições de dinâmica complexa.

A função de perda inclui dois componentes-chave: a reconstrução fotométrica Lphoto e a suavidade do fluxo Lsmooth, e é expressa como:

onde λ regula o peso da suavidade em relação à precisão fotométrica. A perda fotométrica avalia a discrepância entre a primeira imagem e a segunda imagem transformada, levando em consideração o fluxo predito:

onde ρ é a Charbonnier Loss: ρ(x) = (x² + η²)^r, com r = 0,45 e η = 1e-3. Quanto mais preciso for o fluxo, menor será a discrepância, o que permite que o modelo detecte as mudanças e os detalhes mais sutis, essenciais para a análise de eventos rápidos.

A suavidade do fluxo Lsmooth minimiza as diferenças entre pixels vizinhos, reforçando a coerência espacial do fluxo e reduzindo erros de caráter local. No contexto financeiro, isso é semelhante à suavização de ruídos aleatórios e picos nos volumes de trading, preservando mudanças significativas de curto prazo nos preços e na atividade. Esse mecanismo permite que o modelo monitore simultaneamente anomalias locais — mudanças bruscas nas cotações e picos de atividade de trading — e tendências globais.

A aplicação das perdas fotométrica e de suavidade cria uma estratégia de aprendizado equilibrada. O modelo identifica movimentos instantâneos e tendências, evitando o sobreajuste a eventos ruidosos ou raros. Nos fluxos financeiros, isso permite elaborar previsões capazes de reagir com precisão às oscilações do mercado, identificar anomalias e oferecer suporte à tomada de decisões em tempo real, garantindo a confiabilidade e a adaptabilidade das estratégias de trading em mercados dinâmicos. Graças a essa integração entre a análise espaço-temporal e o aprendizado auto-supervisionado, o STE-FlowNet torna-se uma ferramenta capaz de identificar padrões na escala de microssegundos e, ao mesmo tempo, levar em conta tendências de longo prazo, o que o torna valioso para o planejamento estratégico e a gestão de risco.

A visualização criada pelo autor do framework STE-FlowNet é apresentada a seguir.

Implementação por meio de MQL5

Após uma análise detalhada dos aspectos teóricos do framework STE-FlowNet, passamos à parte prática do nosso trabalho, na qual nos concentraremos em uma das opções de implementação das abordagens propostas por meio de MQL5. É importante ressaltar que nossa implementação não é uma cópia exata da versão original do framework. Adaptamos as ideias principais e os princípios-chave do modelo para trabalhar com dados de mercado. Mais especificamente, aplicamos o conceito de processamento espaço-temporal e de refinamento iterativo de fluxos à estrutura de análise de preços, volumes e outros indicadores de trading.

Essa abordagem permite aproveitar as vantagens do STE-FlowNet no contexto da análise dos mercados financeiros: identificar picos de curto prazo na atividade de trading, oscilações anômalas nos preços e mudanças bruscas no volume, ao mesmo tempo em que leva em conta as tendências de longo prazo. A implementação por meio de MQL5 permite integrar o modelo diretamente em estratégias de trading e sistemas algorítmicos, o que possibilita tanto testes offline com dados históricos quanto a previsão adaptativa em tempo real. Além disso, o uso de MQL5 permite otimizar os processos computacionais, garantindo o processamento eficiente de grandes fluxos de dados de mercado e a aplicação sequencial de filtros espaço-temporais, o que é fundamental para o trading de alta frequência e a análise de risco.

Dessa forma, nosso trabalho prático não se limita a aplicar a arquitetura STE-FlowNet aos dados financeiros, mas também amplia suas funcionalidades, criando uma ferramenta flexível para a análise da dinâmica de mercado, a previsão de mudanças de curto e longo prazo e a construção de estratégias de trading confiáveis, levando em conta as condições reais de mercado.

No entanto, é importante ressaltar que a arquitetura do framework STE-FlowNet é bastante complexa. Os autores utilizam diversos módulos, distribuídos entre vários fluxos de informação, o que permite que o modelo processe dados em diferentes níveis de abstração e leve em conta tanto as mudanças locais quanto as globais. É natural que a implementação completa dessa arquitetura seja feita de forma gradual, passo a passo, adaptando os elementos-chave à análise de dados financeiros. Essa abordagem gradual nos permitirá analisar as características de cada componente, ajustar os algoritmos de acordo com as especificidades do mercado e garantir a estabilidade do funcionamento do modelo ao integrá-lo a estratégias de trading.

E iniciaremos nosso trabalho com a construção de um dos módulos básicos do framework — o ConvGRU. Para simplificar, supomos que o módulo receba como entrada um tensor já concatenado de características e correlações. Isso nos permitirá concentrar-nos na identificação de dependências espaço-temporais e no processamento de informações sobre a dinâmica dos eventos de mercado, antes de integrar estruturas multifluxo mais complexas. Além disso, essa abordagem nos permite criar um objeto mais versátil, não vinculado a uma solução arquitetônica específica.

O algoritmo do módulo foi implementado na nova classe CNeuronSpikeConvGR, que herda a funcionalidade básica do objeto CNeuronSpikeActivation. Esse objeto da classe pai nos indica a natureza baseada em spikes do objeto que está sendo criado.

class CNeuronSpikeConvGRU  :  public CNeuronSpikeActivation
  {
protected:
   CNeuronBaseOCL       cConcatenated[2];
   CNeuronConvOCL       cZR;
   CNeuronBaseOCL       cZ;
   CNeuronBaseOCL       cR;
   CNeuronConvOCL       cHt;
   CNeuronBaseOCL       cH;
   CNeuronBatchNormOCL  cNorm;
   //---
   virtual bool      feedForward(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      updateInputWeights(CNeuronBaseOCL *NeuronOCL) override;
   virtual bool      calcInputGradients(CNeuronBaseOCL *NeuronOCL) override;
   
public:
                     CNeuronSpikeConvGRU(void) {};
                    ~CNeuronSpikeConvGRU(void) {};
   //---
   virtual bool      Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                          uint units, uint chanels_in, uint chanels_out,
                          ENUM_OPTIMIZATION optimization_type, uint batch);
   //---
   virtual int       Type(void)   override const   {  return defNeuronSTFS;   }
   //--- 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      SetActivationFunction(ENUM_ACTIVATION value) override;
   //---
   virtual bool      WeightsUpdate(CNeuronBaseOCL *source, float tau) override;
  };

Na estrutura apresentada da nova classe, vemos uma série de objetos internos:

• cConcatenated — armazena o tensor concatenado dos dados analisados, incluindo mapas de características, correlações e o estado oculto;
• cZR — módulo de convolução responsável pelo cálculo das portas Z (atualização) e R (reinicialização), que controlam o estado da camada oculta;
• cZ e cR — estruturas separadas para armazenar os valores das portas de atualização e de reinicialização no passo atual;
• cHt — armazena o estado oculto intermediário após a aplicação das portas e das convoluções;
• cH — estado oculto do neurônio, que é atualizado a cada passo e utilizado nas iterações seguintes;
• cNorm — módulo de normalização em lote para estabilizar e acelerar o treinamento; prepara os dados antes da ativação por spikes realizada por meio da classe pai.

Todos os componentes internos do objeto são declarados estaticamente, o que permite deixar o construtor e o destruidor da classe vazios. Já a inicialização do objeto é realizada no método Init, que reúne todos os submódulos internos em uma cadeia de trabalho. Isso é importante. Afinal, no nosso caso, ConvGRU não é uma “caixa preta” isolada, mas sim parte do processamento espaço-temporal geral do STE-FlowNet. Assim, cada etapa da inicialização foi planejada levando em conta o fluxo de dados e a eficiência computacional.

bool CNeuronSpikeConvGRU::Init(uint numOutputs,uint myIndex,COpenCLMy *open_cl,
                               uint units,uint chanels_in,uint chanels_out,
                               ENUM_OPTIMIZATION optimization_type,uint batch)
  {
   if(!CNeuronSpikeActivation::Init(numOutputs,myIndex,open_cl,units*chanels_out,optimization_type,batch))
     return false;

A primeira linha de código dentro do método realiza a inicialização básica do objeto da classe pai. Aqui, reservamos memória, associamos o objeto ao contexto OpenCL e definimos o tamanho do tensor de resultados.

Em seguida, ocorre a inicialização dos componentes internos. O primeiro é o cConcatenated. Sua tarefa é reunir os dados de entrada com o estado oculto.

   uint index = 0;
   for(uint i = 0; i < cConcatenated.Size(); i++)
     {
      if(!cConcatenated[i].Init(0, index, OpenCL, units * (chanels_in + chanels_out), optimization, iBatch))
         return false;
      cConcatenated[i].SetActivationFunction(None);
      index++;
     }

Para este objeto, desativamos explicitamente a função de ativação. E isso faz sentido. Afinal, estamos diante de um simples buffer que une os tensores de dois fluxos de informação, os quais podem ter passado por diferentes transformações não lineares.

O próximo cZR é um módulo de convolução para calcular Z e R.

   if(!cZR.Init(0,index,OpenCL,chanels_in+chanels_out,chanels_in+chanels_out,
				2*chanels_out,units,1,optimization, iBatch))
      return false;
   cZR.SetActivationFunction(SIGMOID);

Aqui, criamos um bloco de convolução que gera simultaneamente valores para duas portas: Z controla a atualização da memória, e R controla o grau de reinicialização do estado anterior. Ou seja, em uma única passagem, obtemos dois conjuntos de mapas, um para cada porta. A função de ativação SIGMOID é o padrão para as portas: saída no intervalo (0,1).

Para facilitar os cálculos, dividimos o tensor agregado de portas em duas componentes.

   index++;
   if(!cZ.Init(0,index,OpenCL,cZR.Neurons()/2,optimization,iBatch))
      return false;
   cZ.SetActivationFunction((ENUM_ACTIVATION)cZR.Activation());
   index++;
   if(!cR.Init(0,index,OpenCL,cZR.Neurons()/2,optimization,iBatch))
      return false;
   cR.SetActivationFunction((ENUM_ACTIVATION)cZR.Activation());

Do ponto de vista arquitetônico, isso proporciona flexibilidade: em versões futuras, será possível substituir o cZR por um módulo mais complexo, enquanto o cZ e o cR continuarão sendo interfaces.

A seguir, inicializamos o cHt — o módulo para calcular o candidato ao estado oculto.

   index++;
   if(!cHt.Init(0,index,OpenCL,chanels_in+chanels_out,chanels_in+chanels_out,
                                   chanels_out,units,1,optimization, iBatch))
      return false;
   cHt.SetActivationFunction(TANH);

Aqui, utilizamos um bloco de convolução separado. As entradas são as mesmas — uma combinação de características e do estado anterior (em nossa representação concatenada). A saída é a dimensionalidade das características na saída do módulo. A ativação TANH é o padrão para o candidato ao estado oculto: centraliza o sinal e fornece o intervalo (−1,1). No contexto de trading, isso ajuda a manter a resposta dentro de limites razoáveis e a evitar explosões de valores.

E o estado oculto propriamente dito, cH.

   index++;
   if(!cH.Init(0,index,OpenCL,Neurons(),optimization,iBatch))
      return false;

Esse objeto armazena o estado oculto final h. É importante ressaltar que separamos a parte computacional cHt e o armazenamento do estado cH. Esse design facilita o controle de versões dos estados durante o refinamento iterativo.

A inicialização do objeto de normalização em lote cNorm encerra a execução do método.

   index++;
   if(!cNorm.Init(0,index,OpenCL,Neurons(),iBatch,optimization))
      return false;
      cNorm.SetActivationFunction(None);
//---
   return true;
  }

O BatchNorm corrige a distribuição das respostas de pré-ativação.

O método feedForward realiza um forward pass completo pelo módulo ConvGRU, atualizando sequencialmente o estado oculto com base na entrada atual e na memória armazenada.

bool CNeuronSpikeConvGRU::feedForward(CNeuronBaseOCL *NeuronOCL)
  {
   if(!NeuronOCL)
      return false;
//---
   uint units = cHt.GetUnits();
   uint hidden = cHt.GetFilters();
   uint inputs = cHt.GetWindow() - hidden;

Primeiramente, calculamos os parâmetros-chave do módulo:

• units reflete a divisão espacial da entrada,
• hidden determina o número de canais de saída do estado,
• inputs — número de canais de entrada do tensor de características original.

Em seguida, é executado o método SwapOutputs, que prepara o buffer cH para atualização, salvando o estado anterior para o cálculo do componente recorrente.

   if(!cH.SwapOutputs())
      return false;

Em seguida, as características de entrada analisadas são concatenadas com o estado oculto anterior, formando a primeira entrada para o cálculo das portas Z e R.

   if(!Concat(NeuronOCL.getOutput(), cH.getPrevOutput(), cConcatenated[0].getOutput(), inputs, hidden, units))
      return false;

O bloco cZR realiza um forward pass convolucional, gerando mapas de portas combinados, que em seguida são distribuídos separadamente em cZ e cR.

   if(!cZR.FeedForward(cConcatenated[0].AsObject()))
      return false;
   if(!DeConcat(cZ.getOutput(), cR.getOutput(), cZR.getOutput(), hidden, hidden, units))
      return false;

Em seguida, a porta R mascara o estado anterior por meio de uma multiplicação elemento a elemento, o que implementa o mecanismo de reinicialização parcial da memória.

   if(!ElementMult(cR.getOutput(), cH.getPrevOutput(), cR.getPrevOutput()))
      return false;

A concatenação das entradas atuais com o estado modificado é fornecida ao segundo bloco convolucional cHt, que calcula o estado oculto candidato.

   if(!Concat(NeuronOCL.getOutput(), cR.getPrevOutput(), cConcatenated[1].getOutput(), inputs, hidden, units))
      return false;
   if(!cHt.FeedForward(cConcatenated[1].AsObject()))
      return false;

Em seguida, a função GateElementMult combina o estado antigo e o novo por meio da porta Z, regulando suavemente o grau de atualização da memória.

   if(!GateElementMult(cHt.getOutput(), cH.getPrevOutput(), cZ.getOutput(), cH.getOutput()))
      return false;

O resultado obtido passa pela camada de normalização cNorm e, em seguida, é ativado pela classe pai, concluindo a fase do forward pass.

   if(!cNorm.FeedForward(cH.AsObject()))
      return false;
   if(!CNeuronSpikeActivation::feedForward(cNorm.AsObject()))
      return false;
//---
   return true;
  }

Esse mecanismo etapa a etapa permite que o módulo encontre um equilíbrio preciso entre a preservação do contexto de longo prazo e a reação imediata a novos sinais de mercado.

Dessa forma, CNeuronSpikeConvGRU implementa toda a lógica de funcionamento do módulo ConvGRU, permitindo integrá-lo gradualmente à análise de eventos de mercado, registrar oscilações de curto prazo e aprender com dados históricos para construir estratégias de trading adaptativas.

Trabalhamos bem hoje, e é hora de fazer uma pequena pausa. Que os pensamentos se acalmem e se organizem, e, no próximo artigo, voltaremos ao desenvolvimento com novas energias e continuaremos avançando.

Conclusão

Neste artigo, conhecemos o framework STE-FlowNet, que oferece uma visão fundamentalmente diferente do processamento de dados dinâmicos graças ao modelo de percepção baseado em eventos. Sua arquitetura demonstra como é possível extrair dependências espaço-temporais não com base em intervalos de tempo rígidos, mas sim com base em mudanças reais na estrutura do sinal. É exatamente o que tanto falta às abordagens clássicas nos mercados financeiros. Ele é capaz de identificar dependências locais e temporais sem perder detalhes, preservando as microvariações da estrutura do fluxo onde os modelos clássicos simplesmente as calculam pela média. Essa abordagem preserva a dinâmica, não se prende a timeframes fixos e permite refinar a previsão passo a passo, como se observasse a evolução do impulso de mercado em tempo real.

Referências

• Redes recorrentes espaço-temporais para estimação de fluxo óptico baseado em eventos
• Outros artigos da série

Programas utilizados neste artigo

#	Nome	Tipo	Descrição
1	Study.mq5	Expert Advisor	Expert Advisor para treinamento offline de modelos
2	StudyOnline.mq5	Expert Advisor	Expert Advisor para treinamento online de modelos
3	Test.mq5	Expert Advisor	Expert Advisor para testar o modelo
4	Trajectory.mqh	Biblioteca de classe	Estrutura de descrição do estado do sistema e da arquitetura dos modelos
5	NeuroNet.mqh	Biblioteca de classe	Biblioteca de classes para a criação de redes neurais
6	NeuroNet.cl	Biblioteca	Biblioteca de código do programa OpenCL