Redes neuronales en el trading: Percepción adaptativa de la dinámica del mercado (Codificador)
Introducción
El comportamiento de los mercados financieros actuales se asemeja cada vez más a un flujo continuo de eventos, en el que son importantes la magnitud de la variación del precio y el momento exacto en que se produce, los intervalos de tiempo entre los impulsos y la estructura interna de los micromovimientos del mercado. Fue precisamente esta idea la que sirvió de base para la transición de un modelo estático a una lógica de procesamiento de datos orientada a los eventos, capaz de captar el pulso del mercado en tiempo real.
A diferencia de los modelos clásicos, que trabajan con velas discretizadas y promedian la dinámica, el enfoque basado en eventos considera el mercado como un sistema reactivo continuo. Cada evento (tick, pico de volumen, liquidez instantánea) tiene su propio peso y significado. Esto permite evitar la pérdida de información, inevitable al cuantizar el tiempo con baja resolución. Y este enfoque se ajusta más a la naturaleza real de la dinámica del mercado. Ayuda a los modelos a aprender no solo a partir de los valores, sino también a partir de la estructura de las relaciones temporales entre ellos.
En el artículo anterior conocimos los aspectos teóricos del framework STE-FlowNet. Sin embargo, el primer paso no fue más que el punto de partida. Ha llegado el momento de seguir adelante: pasar del concepto a la implementación de los enfoques propuestos por los autores del framework, adaptándolos a las tareas de análisis y previsión de series temporales de los mercados financieros.
No solo hemos abandonado la visión tradicional del mercado como una sucesión de barras promediadas, sino que, de hecho, hemos reajustado nuestra perspectiva. En lugar de registrar el resultado, hemos aprendido a escuchar el proceso en sí. No es el cierre de la vela, sino el impulso que la precedió. No una estructura ya formada, sino un tejido en constante formación. Hemos construido una representación del tiempo de mercado basada en eventos. Cada tick no se percibe como un número más, sino como un acto de interacción entre la oferta y la demanda, un instante en el que se toma una decisión en el límite del microequilibrio.
Esto sentó las bases para dar el siguiente paso: modelos capaces de detectar la presencia de un evento y captar la dirección interna del flujo. La capacidad de distinguir cómo ocurre exactamente esto en este preciso momento es una condición clave para crear sistemas capaces de hacer previsiones no a partir de las huellas que deja un evento, sino a partir de la trayectoria de su desarrollo. Y es precisamente aquí donde entra en juego el framework STE-FlowNet: una visión dinámica y basada en eventos del mercado.
Hemos aprendido a detectar la aparición misma del evento en el mercado; ahora es importante que aprendamos a distinguir hacia dónde lleva al mercado dicho evento. No se trata simplemente de registrar el hecho de que se produce un impulso, sino de interpretar la dirección de la corriente oculta de fuerzas, incluso antes de que dicha corriente se haga evidente en el precio. Es precisamente esta capacidad de anticipación lo que distingue el modelado pasivo de la verdadera anticipación del mercado. En los modelos clásicos de aprendizaje automático, esta tarea se resuelve a posteriori: el flujo ya se ha formado, la vela se ha cerrado y el movimiento ya se ha producido. STE-FlowNet propone un enfoque radicalmente diferente: aprender a ver el movimiento dentro del movimiento y reconstruir la dirección de la trayectoria en el momento en que se forma el evento.
El framework STE-FlowNet no se creó inicialmente para el ámbito financiero, sino para el análisis de flujos de eventos en entornos dinámicos —en tareas de seguimiento óptico, en las que lo importante no es lo que ya ha ocurrido en el fotograma, sino cómo evoluciona el cambio de la propia imagen a lo largo del tiempo—. Se trata de una arquitectura híbrida basada en eventos y tiempo, capaz de reconstruir la dirección oculta del flujo a partir de la diferencia entre eventos, de forma similar a como el cerebro humano percibe el movimiento allí donde los ojos solo registran destellos discretos de luz. Así que adaptaremos este mecanismo al mercado, transformando el tiempo financiero en un flujo de microdesplazamientos ópticos, de los que se puede extraer la estructura vectorial de un futuro probable.
Para los mercados financieros, esto reviste una importancia fundamental. El precio no se mueve por sí solo: lo mueven grupos de microimpulsos de liquidez, y la mayoría de ellos pasan desapercibidos en las representaciones clásicas OHLC. Incluso una vela de alta frecuencia solo refleja el resultado de la lucha, pero no revela su dinámica interna. Para nosotros es importante comprender hacia dónde se dirige exactamente el sistema en este preciso momento, antes de que se manifieste toda la fuerza del movimiento potencial. Esto es precisamente lo que distingue a STE-FlowNet de los modelos predictivos estadísticos: no se basa en conjeturas a partir de datos del pasado, sino que recrea la dirección de la acción que se está desarrollando.
Precisamente con este objetivo, trasladamos STE-FlowNet al contexto del análisis de series temporales de mercado, no como una red neuronal más para la predicción de precios, sino como una herramienta para reconstruir el campo interno de movimiento del mercado, oculto en la microestructura de los eventos. De hecho, enseñamos al modelo a interpretar el flujo de ticks del mismo modo que una persona percibe intuitivamente la aceleración de la tensión del mercado antes de que se produzca un movimiento evidente del precio, pero no de forma subjetiva ni probabilística, sino mediante una estructura formalizable y calculable.
Para entender mejor esta idea, imaginemos el mercado como un campo de fuerzas en el que cada evento no supone un punto, sino una perturbación que genera una tensión local. Es precisamente esta tensión —no el cambio de precio en sí, sino la dirección de su potencial— lo que nos interesa captar. Spatio-Temporal Event embedding en STE-FlowNet funciona como un transformador de este campo. No registra el precio como un valor, sino que codifica el vector de variación del estado en el tiempo y en el espacio de los eventos. Cada evento se interpreta no como un hecho, sino como una transferencia de fuerza. Como una micropresión que o bien se disipa, o bien se intensifica en una dirección determinada.
El siguiente paso es la reconstrucción de flujo entrenable. Este es el núcleo de la arquitectura. El modelo no se limita a encadenar los eventos uno tras otro, sino que intenta reconstruir una trayectoria coherente del flujo, como si reconstruyera un viento invisible a partir del movimiento de la hierba. De la sucesión de eventos no extrae una historia, sino precisamente una forma en movimiento: un vector de evolución. Por eso, STE-FlowNet no predice el estado del mercado, sino que aprende a interpretar su tendencia interna en tiempo real, mientras esa tendencia apenas está surgiendo en la microestructura de las operaciones.
Es precisamente aquí donde se hace evidente la diferencia fundamental entre STE-FlowNet y los enfoques clásicos. Este funciona como un sistema que interpreta la intención del mercado incluso antes de que esta se refleje en las fluctuaciones de los precios. No se trata de una previsión estadística ni de la identificación de un patrón, sino de un intento de comprender la arquitectura causal del movimiento del mercado en el momento en que se forma. Y ahí radica el cambio fundamental: pasar del análisis de la consecuencia a la percepción de la causa.
A continuación se muestra una visualización del framework STE-FlowNet elaborada por el autor.

En la parte práctica del artículo anterior, hemos implementado con éxito la capa CNeuronSpikeConvGRU, sentando así las bases para el trabajo posterior. Hoy continuaremos este camino, profundizando en el desarrollo de los algoritmos del framework STE-FlowNet. El enfoque principal pasa de la comprensión teórica del mercado a la implementación práctica de una arquitectura capaz de interpretar el flujo de eventos y predecir la dirección del movimiento del mercado en tiempo real.
Módulo de correlación
La siguiente etapa de nuestro trabajo consiste en crear un módulo que aprenda la correlación entre estados. Debemos señalar que los autores del framework original analizaron en su trabajo las correlaciones entre el fotograma actual y los desplazamientos del primer fotograma de la secuencia analizada, determinando así el impulso dinámico de toda la secuencia anterior. Este enfoque está plenamente justificado para el análisis de secuencias fijas y limitadas, en las que se puede acceder al contexto histórico.
Nuestra tarea, en cambio, es totalmente diferente: nuestro objetivo es analizar los datos en tiempo real. Esto lleva a analizar secuencias prácticamente infinitas. Es más, la influencia de los eventos se atenúa a medida que aumenta la distancia temporal respecto a ellos, lo que hace que el uso prolongado de un estado estático resulte poco eficaz.
La primera solución lógica es utilizar un punto desplazable como referencia para el análisis. Este enfoque es sencillo, mantiene el resto de la arquitectura sin cambios y permite controlar el tamaño del desplazamiento como hiperparámetro del modelo, lo que garantiza un equilibrio entre la velocidad y la precisión del análisis. Sin embargo, existe también una limitación conceptual: cada estado recibe su propia referencia, lo que hace que las correlaciones entre estados consecutivos no sean comparables, por no hablar de las correlaciones con eventos más alejados.
Por consiguiente, surge la necesidad de encontrar una solución más adecuada. Una posible solución podría ser el uso de una pila de estados. En este caso, renunciamos al aumento de datos referido al estado de referencia y, en su lugar, determinamos las correlaciones de cada nuevo estado con todos los estados almacenados en la pila. Este enfoque permite conservar la estructura histórica de la influencia de los eventos y, al mismo tiempo, garantizar la compatibilidad de las correlaciones, lo cual es importante para el análisis y la previsión de los procesos dinámicos del mercado.
Objeto de pila
La organización de la pila es una tarea universal que requiere un enfoque meticuloso y flexible. Con el fin de garantizar la modularidad y la reutilización, la hemos implementado como una clase independiente que gestiona el almacenamiento dinámico de estados y permite la integración con otros componentes.
class CNeuronAddToStack : public CNeuronBaseOCL { protected: uint iStackSize; uint iDimension; uint iVariables; //--- virtual bool feedForward(CNeuronBaseOCL *NeuronOCL) override; virtual bool updateInputWeights(CNeuronBaseOCL *NeuronOCL) override { return true; } virtual bool calcInputGradients(CNeuronBaseOCL *NeuronOCL) override; public: CNeuronAddToStack(void) : iStackSize(0), iDimension(0), iVariables(0) {}; ~CNeuronAddToStack(void) {}; //--- virtual bool Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint stack_size, uint dimension, uint variables, ENUM_OPTIMIZATION optimization_type, uint batch); //--- virtual int Type(void) override const { return defNeuronAddToStack; } //--- methods for working with files virtual bool Save(int const file_handle) override; virtual bool Load(int const file_handle) override; //--- virtual void SetActivationFunction(ENUM_ACTIVATION value) override { }; //--- virtual uint GetStackSize(void) const { return iStackSize; } virtual uint GetDimension(void) const { return iDimension; } virtual uint GetVariables(void) const { return iVariables; } };
En la estructura de la clase vemos que solo se declaran tres variables que definen los parámetros de la pila:
- iStackSize: almacena el número de estados en la pila;
- iVariables: número de secuencias unitarias en cada estado;
- iDimension: determina la dimensión de la descripción de una secuencia unitaria de cada estado.
Para el almacenamiento directo de datos se utilizan los búferes heredados de la clase padre.
La inicialización directa de una nueva instancia de la clase se lleva a cabo en el método Init, que configura cuidadosamente todos los parámetros.
bool CNeuronAddToStack::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint stack_size, uint dimension, uint variables, ENUM_OPTIMIZATION optimization_type, uint batch) { if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, stack_size * dimension * variables, optimization_type, batch)) return false; //--- activation = None; iStackSize = stack_size; iDimension = dimension; iVariables = variables; //--- return true; }
El algoritmo del método está estructurado de forma bastante sencilla y clara. En primer lugar, pasamos el control al método homónimo de la clase padre, inicializando todas las interfaces heredadas. Al hacerlo, indicamos un tamaño del búfer de resultados suficiente para almacenar toda la pila. Una vez completada correctamente la operación, guardamos los parámetros de la pila en variables internas. Al finalizar, el método devuelve true, lo que confirma que la configuración se ha realizado correctamente.
Una vez inicializado correctamente el objeto, el siguiente paso consiste en organizar el algoritmo de pasada directa. Al igual que en nuestros otros módulos, todo el proceso de cálculo se ha trasladado al contexto de OpenCL para acelerar el procesamiento y permitir el tratamiento paralelo de los datos. Para ello, se ha añadido un nuevo kernel, AddToStack, al programa OpenCL. Este kernel realiza un desplazamiento secuencial de los elementos de la pila, lo que permite añadir un nuevo estado y conservar correctamente los datos históricos.
__kernel void AddToStack(__global const float* inputs, __global float* stack, const int stack_size) { const size_t id = get_global_id(0); const size_t loc_id = get_local_id(1); const size_t var = get_global_id(2); const size_t dimension = get_global_size(0); const size_t total_loc = get_local_size(1); const size_t variables = get_global_size(2);
El kernel recibe como parámetros punteros a dos búferes de datos: el de los nuevos estados (inputs) y el de la pila actual (stack). Además, el usuario especifica el tamaño de la pila (stack_size).
En el cuerpo del kernel, primero inicializamos los identificadores y los tamaños del espacio de tareas:
- id: índice global del elemento en el vector de descripción del estado de una secuencia unitaria;
- loc_id: índice local en el grupo de trabajo,
- var: índice de una secuencia unitaria.
Luego determinamos el número de iteraciones del bucle interno necesarias para que los elementos del grupo de trabajo procesen toda la secuencia de la pila, con el fin de distribuir correctamente los cálculos y gestionar el paralelismo.
const int total = (stack_size - 1) / total_loc;
En general, esperamos que nos baste con una sola iteración del bucle. Sin embargo, la incorporación de un bucle hace que el algoritmo sea de uso general, sin que el tamaño de la pila quede limitado por las características del dispositivo utilizado.
A continuación, ejecutamos el bucle principal desde el final hacia el principio para desplazar sucesivamente los elementos de la pila, empezando por el más alejado y terminando por el más cercano al estado actual.
for(int i = total; i >= 0; i--) { int inp = 0; if(i == 0 && loc_id == 0) inp = IsNaNOrInf(inputs[RCtoFlat(var, id, variables, dimension, 1)], 0); else if((i * total_loc + loc_id) < stack_size) { int shift = RCtoFlat(i * total_loc + loc_id - 1, id, stack_size, dimension, var); inp = IsNaNOrInf(stack[shift], 0); } BarrierLoc
En el cuerpo del bucle, primero leemos los datos de los búferes globales. Para el primer estado, tomamos los datos del búfer de datos nuevos. El resto de elementos leen los valores guardados previamente en la pila, desplazados un estado. En este proceso, comprobamos obligatoriamente la validez de los valores obtenidos y sincronizamos los hilos del grupo de trabajo para que todos los cálculos de desplazamiento finalicen antes de escribir los nuevos valores. Esto evita que se produzca un conflicto al actualizar la pila simultáneamente.
Como último paso, guardamos el valor preparado en la posición actual de la pila.
if((i * total_loc + loc_id) < stack_size) { int shift = RCtoFlat(i * total_loc + loc_id, id, stack_size, dimension, var); stack[shift] = inp; } } }
De este modo, se añade un nuevo elemento y los anteriores se desplazan correctamente, conservando la secuencia de estados históricos.
Este algoritmo garantiza una actualización dinámica de la pila con procesamiento paralelo, lo que permite a STE-FlowNet analizar la secuencia de estados en tiempo real sin comprometer el rendimiento ni la exactitud de los datos.
El uso de identificadores globales y locales en el procesamiento paralelo permite procesar eficazmente arrays de datos y gestionar las dimensiones de la pila. De este modo, la implementación en OpenCL garantiza un alto rendimiento y escalabilidad al trabajar con series temporales dinámicas del mercado financiero.
En nuestra clase, crearemos un método que encapsule este kernel siguiendo el esquema que ya conocemos.
bool CNeuronAddToStack::feedForward(CNeuronBaseOCL *NeuronOCL) { if(!NeuronOCL || !OpenCL) return false; //--- if(NeuronOCL.Neurons() < int(iDimension * iVariables)) return false; //--- uint global_work_offset[3] = {0}; uint global_work_size[3] = { iDimension, MathMin((uint)OpenCL.GetMaxLocalSize(1), iStackSize), iVariables }; uint local_work_size[3] = { 1, global_work_size[1], 1 }; uint kernel = def_k_AddToStack; setBuffer(kernel, def_k_ats_inputs, NeuronOCL.getOutputIndex()) setBuffer(kernel, def_k_ats_stack, getOutputIndex()) setArgument(kernel, def_k_ats_stack_size, (int)iStackSize) kernelExecuteLoc(kernel, global_work_offset, global_work_size, local_work_size) //--- return true; }
Cabe señalar que, para especificar el tamaño del grupo de trabajo, indicamos el menor de dos valores: el tamaño de la pila establecido por el usuario y el tamaño máximo posible del grupo de trabajo para el dispositivo utilizado. Esto permite optimizar el uso de la memoria y el paralelismo.
La incorporación de datos a la pila solo resuelve el problema de la pasada directa. Sin embargo, esto no basta para que el modelo sea plenamente entrenable: es necesario transmitir correctamente los gradientes de error a los datos originales. En nuestro caso, la clase de la pila en sí no contiene parámetros entrenables: se limita a almacenar y desplazar estados. No obstante, es importante que la señal de error llegue al elemento que ha generado el estado actual.
En la práctica, lo llevamos a cabo de la siguiente manera. Durante el entrenamiento, los gradientes se transmiten únicamente al elemento actual (superior) de la pila. Para ello, no es necesario escribir un nuevo kernel de OpenCL. Basta con utilizar la operación de desconcatenación ya existente en el búfer común de errores de salida del objeto. Seleccionamos el segmento de gradientes correspondiente a la posición del estado actual y lo enviamos a la fuente de datos originales.
bool CNeuronAddToStack::calcInputGradients(CNeuronBaseOCL *NeuronOCL) { if(!NeuronOCL || !OpenCL) return false; if(NeuronOCL.Neurons() < int(iDimension * iVariables)) return false; if(!DeConcat(NeuronOCL.getGradient(), PrevOutput, Gradient, iDimension, iDimension * (iStackSize - 1), iVariables)) return false; Deactivation(NeuronOCL) //--- return true; }
Después solo queda ajustar los valores obtenidos en función de la derivada de la función de activación del objeto de datos de origen.
Este enfoque es sencillo, determinista y eficiente en cuanto al uso de recursos. No se necesitan kernels de cálculo adicionales, y la lógica de la retropropagación del error sigue siendo local y comprensible.
Objeto de correlación
Ahora que disponemos de un objeto fiable para organizar la pila de estados, lo lógico es pasar a la siguiente fase: la creación del módulo de correlación. Siguiendo el espíritu del trabajo original de los autores, evaluaremos la similitud entre los estados mediante el producto escalar (dot-product) de los vectores correspondientes que los describen. Sin embargo, es importante aclarar el contexto. En lugar de trabajar con fotogramas fijos, aplicamos esta medida en el contexto de secuencias unitarias: bloques de eventos breves y coherentes en cuanto a su significado, que resultan fáciles de procesar en tiempo real.
El enfoque basado en el producto escalar es sencillo, rápido e interpretable. Para dos vectores, el producto escalar ofrece una estimación directa de la orientación de sus proyecciones en el espacio de características, lo que, según nuestra interpretación, equivale a una estimación de la coherencia de las direcciones de las fuerzas en el campo. El trabajo con secuencias unitarias ofrece una ventaja adicional: conservamos la coherencia local del contexto y, al mismo tiempo, limitamos el volumen de cálculos, lo cual es fundamental para el análisis en línea de flujos de datos infinitos.
Implementamos el enfoque propuesto en el marco de la nueva clase CNeuronStackCorrelation.
class CNeuronStackCorrelation : public CNeuronBaseOCL { protected: CNeuronAddToStack cStack; //--- virtual bool feedForward(CNeuronBaseOCL *NeuronOCL) override; virtual bool updateInputWeights(CNeuronBaseOCL *NeuronOCL) override { return true; } virtual bool calcInputGradients(CNeuronBaseOCL *NeuronOCL) override; public: CNeuronStackCorrelation(void); ~CNeuronStackCorrelation(void); //--- virtual bool Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint stack_size, uint dimension, uint variables, ENUM_OPTIMIZATION optimization_type, uint batch); //--- virtual int Type(void) override const { return defNeuronStackCorrelation; } //--- 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 Clear(void) override; };
En la estructura presentada de la nueva clase, el elemento clave es el objeto interno cStack, encargado de gestionar el historial de estados. Se crea de forma estática, por lo que el constructor y el destructor de la clase pueden dejarse vacíos. Aquí no es necesario asignar ni liberar recursos manualmente. El proceso de inicialización de un nuevo objeto se ha trasladado íntegramente al método Init.
bool CNeuronStackCorrelation::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint stack_size, uint dimension, uint variables, ENUM_OPTIMIZATION optimization_type, uint batch) { if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, variables * stack_size, optimization_type, batch)) return false;
Como es habitual, las operaciones comienzan con la llamada al método homónimo de la clase padre, en el que ya está configurado el algoritmo de inicialización de las interfaces heredadas.
Cabe señalar aquí que la operación de multiplicación de dos vectores devuelve un valor escalar. Por lo tanto, el tamaño del búfer de resultados lo expresamos como el producto del número de secuencias unitarias por la profundidad de la pila.
Si esta etapa se completa con éxito, inicializamos inmediatamente el objeto interno cStack, pasándole una referencia al contexto OpenCL actual y los parámetros que definen la estructura de la pila.
if(!cStack.Init(0, 0, OpenCL, stack_size, dimension, variables, optimization, iBatch)) return false; //--- return true; }
De esta manera, ambos componentes se conectan de forma sincronizada a un mismo entorno informático, y la pila está lista para recibir los primeros datos en el momento mismo en que finaliza el método de inicialización, sin llamadas adicionales ni operaciones diferidas ocultas. De hecho, todo se inicializa de inmediato y de forma transparente, sin recurrir a lógica de inicialización diferida y sin efectos secundarios, lo cual es fundamental para la reproducibilidad del comportamiento durante el entrenamiento y la depuración.
La siguiente etapa de nuestro trabajo consiste en desarrollar un algoritmo de pasada directa, que en este módulo resulta sumamente lógico y sigue estrictamente el principio del análisis en flujo.
bool CNeuronStackCorrelation::feedForward(CNeuronBaseOCL *NeuronOCL) { if(!cStack.FeedForward(NeuronOCL)) return false;
En primer lugar, actualizamos la pila de estados pasando a ella el estado obtenido del objeto de datos de origen. Si, por cualquier motivo, no es posible actualizar la pila, la ejecución se interrumpe inmediatamente: la pasada directa no admite estados intermedios ambiguos.
A continuación comienza una etapa clave: el cálculo de la correlación entre el estado actual y el historial. Para ello se utiliza la operación de multiplicación matricial MatMul. Como array izquierdo se toma la pila formada y, como array derecho, el estado actual. El resultado se guarda en el búfer de resultados Output.
if(!MatMul(cStack.getOutput(), NeuronOCL.getOutput(), Output, cStack.GetStackSize(), cStack.GetDimension(), 1, cStack.GetVariables(), true)) return false;
Cabe señalar aquí que, en el contexto del análisis de secuencias unitarias, multiplicamos el array del historial registrado por el vector del estado actual. Y, como resultado, obtenemos un vector de similitud entre la observación actual y cada elemento de la pila, lo que conforma un mapa completo del contexto causal-temporal local.
Si es necesario, se puede aplicar directamente una función de activación a los valores obtenidos.
if(activation != None) if(!Activation(Output, Output, activation)) return false; //--- return true; }
De este modo, la pasada directa se basa en el principio Memoria → Comparación → Interpretación. Luego se actualiza la pila. Y se calculan las correlaciones. El resultado se convierte opcionalmente al formato requerido. Todo es conciso, estrictamente secuencial y totalmente compatible con el procesamiento de datos en flujo en tiempo real.
A pesar de que este algoritmo no contiene parámetros entrenables propios, forma parte de pleno derecho de la cadena de cálculo general y, por lo tanto, debe gestionar correctamente la retropropagación del error. De lo contrario, el modelo pierde su capacidad de adaptación y todo el proceso de aprendizaje se convierte en un esquema estático sin retroalimentación. Precisamente por eso, en el método calcInputGradients se lleva a cabo la distribución y el procesamiento de los gradientes entre todos los elementos de la estructura.
bool CNeuronStackCorrelation::calcInputGradients(CNeuronBaseOCL *NeuronOCL) { if(!NeuronOCL) return false;
En la primera fase se comprueba la validez del puntero recibido al objeto de datos de origen. Sin un puntero válido, las operaciones posteriores carecen de sentido.
A continuación, se invoca la función de distribución de gradientes mediante una operación de multiplicación matricial, que calcula los gradientes a partir de los resultados de la pasada directa anterior.
if(!MatMulGrad(cStack.getOutput(), cStack.getGradient(), NeuronOCL.getOutput(), cStack.getPrevOutput(), Gradient, cStack.GetStackSize(), cStack.GetDimension(), 1, cStack.GetVariables(), true)) return false;
Aquí se recalcula la sensibilidad de cada estado de la pila al error acumulado en la salida. En esencia, este paso nos permite determinar cuáles de los estados anteriores han tenido mayor influencia en el resultado actual.
Si en el objeto de datos de origen se ha definido una función de activación, ajustamos la distribución de los gradientes teniendo en cuenta las transformaciones no lineales.
if(NeuronOCL.Activation() != None) if(!DeActivation(NeuronOCL.getOutput(), cStack.getPrevOutput(), cStack.getPrevOutput(), NeuronOCL.Activation())) return false;
Luego transmitimos los gradientes de error del estado actual a través del canal de nuestra pila.
if(!NeuronOCL.CalcHiddenGradients(cStack.AsObject())) return false;
El paso final consiste en acumular, en el objeto de datos de origen, los gradientes transmitidos a través de los dos flujos de información.
if(!SumAndNormilize(NeuronOCL.getGradient(), cStack.getPrevOutput(), NeuronOCL.getGradient(), cStack.GetDimension(), false, 0, 0, 0, 1)) return false; //--- return true; }
De este modo, el método implementa un soporte completo para la pasada inversa, lo que convierte al módulo de correlación de una simple herramienta analítica en un elemento activo de la arquitectura entrenable. Recopila y redistribuye minuciosamente la información sobre los errores, sentando así las bases para un autoaprendizaje eficaz de todo el sistema.
Codificador
Hemos llegado a una de las etapas clave. Todos los componentes básicos del codificador STE-FlowNet ya están listos, y ha llegado el momento de integrarlos en una arquitectura coherente. En esta fase, crearemos la clase de nivel superior CNeuronSTEFlowNetEncoder, que asume el papel de «director de orquesta» y conecta entre sí la línea recurrente, el módulo de dinámica de flujo y el mecanismo de correlación.
class CNeuronSTEFlowNetEncoder : public CNeuronSpikeConvGRU { protected: CLayer cRecurrentLine; CLayer cFlow; CLayer cCorrelation; //--- virtual bool feedForward(CNeuronBaseOCL *NeuronOCL) override; virtual bool updateInputWeights(CNeuronBaseOCL *NeuronOCL) override; virtual bool calcInputGradients(CNeuronBaseOCL *NeuronOCL) override; public: CNeuronSTEFlowNetEncoder(void); ~CNeuronSTEFlowNetEncoder(void); //--- virtual bool Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint &chanels[], uint &units[], uint group_size, uint groups, uint heads, uint dimension_k, uint stack_size, ENUM_OPTIMIZATION optimization_type, uint batch); //--- virtual CNeuronBaseOCL* GetLayer(uint layer); virtual uint Layers(void) const { return (cRecurrentLine.Total() + 1) / 3; } //-- virtual int Type(void) override const { return defNeuronSTEFlowNetEncoder; } //--- 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 void TrainMode(bool flag) override; virtual bool Clear(void) override; };
Dentro de la clase se declaran tres componentes internos: cRecurrentLin, cFlow y cCorrelation. Se trata de arrays dinámicos de punteros a objetos que se encargan, respectivamente, del procesamiento de la secuencia temporal, la extracción de información de flujo y la evaluación de las dependencias locales entre estados.
La inicialización de un nuevo objeto se lleva a cabo en el método Init, que desempeña un papel fundamental en la construcción de toda la línea de cálculo del codificador. Su función consiste en ensamblar una cascada de bloques recurrentes, de correlación y residuales que, en conjunto, permiten procesar los datos en flujo.
bool CNeuronSTEFlowNetEncoder::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint &chanels[], uint &units[], uint group_size, uint groups, uint heads, uint dimension_k, uint stack_size, ENUM_OPTIMIZATION optimization_type, uint batch) { if(chanels.Size() != units.Size()) return false;
Todo comienza con la comprobación de la coherencia de los parámetros de entrada. El tamaño del array de cantidades de canales debe coincidir con el del array de elementos analizados en la secuencia e indicar el número de bloques internos del codificador. De lo contrario, no será posible continuar con el montaje.
A continuación, se invoca el método homónimo de la clase padre, que establece los parámetros fundamentales de la última capa y se convierte en el punto de referencia de toda la arquitectura.
const uint layers = chanels.Size() - 1; if(!CNeuronSpikeConvGRU::Init(numOutputs, myIndex, open_cl, units[layers], chanels[layers] + stack_size, chanels[layers], optimization_type, batch)) return false;
Luego se limpian y preparan tres contenedores: uno para la línea recurrente, otro para la parte de flujo y otro para los módulos de correlación. Serán precisamente ellos quienes almacenen los bloques que se creen.
CNeuronSSAMResNeXtBlock* conv_res = NULL; CNeuronStackCorrelation* correl = NULL; CNeuronSpikeConvGRU* gru = NULL; CNeuronBaseOCL* neuron = NULL; //--- cRecurrentLine.Clear(); cFlow.Clear(); cCorrelation.Clear(); cRecurrentLine.SetOpenCL(OpenCL); cFlow.SetOpenCL(OpenCL); cCorrelation.SetOpenCL(OpenCL);
A continuación, se inicia el ciclo principal, en el que se va formando, paso a paso, la estructura del codificador. En cada iteración, se añade en primer lugar el bloque residual SSAM-ResNeXt, que refuerza las dependencias locales y permite que el mecanismo de atención identifique patrones significativos.
uint index = 0; for(uint i = 0; i <= layers; i++) { conv_res = new CNeuronSSAMResNeXtBlock(); if(!conv_res || !conv_res.Init(0, index, OpenCL, chanels[i], chanels[i + 1], units[i], units[i + 1], group_size, groups, heads, dimension_k, optimization, iBatch) || !cRecurrentLine.Add(conv_res)) { DeleteObj(conv_res) return false; }
Después viene una neurona básica, que se utiliza para concatenar los valores del flujo principal con los coeficientes de correlación entre los estados analizados.
index++; neuron = new CNeuronBaseOCL(); if(!neuron || !neuron.Init(0, index, OpenCL, units[i + 1] * (chanels[i + 1]*stack_size), optimization, iBatch) || !cRecurrentLine.Add(neuron)) { DeleteObj(neuron) return false; }
Si la capa no es la última, se inserta en la cadena un módulo GRU recurrente que integra las dependencias temporales y permite tener en cuenta la dinámica de las señales.
if(i == layers) break; //--- if(i < layers - 1) { index++; gru = new CNeuronSpikeConvGRU(); if(!gru || !gru.Init(0, index, OpenCL, units[i + 1], chanels[i + 1] + stack_size, chanels[i + 1], optimization, iBatch) || !cRecurrentLine.Add(gru)) { DeleteObj(gru) return false; } }
A continuación, se añade un bloque de correlación encargado de analizar las relaciones entre canales y las representaciones en pila.
index++; correl = new CNeuronStackCorrelation(); if(!correl || !correl.Init(0, index, OpenCL, stack_size, chanels[i + 1], units[i + 1], optimization, iBatch) || !cCorrelation.Add(correl)) { DeleteObj(correl) return false; }
Cada iteración concluye con otro SSAM-ResNeXt, pero esta vez en el contexto de la vía principal del flujo, lo que crea una ruta de procesamiento paralela y refuerza las conexiones multicanal.
index++; conv_res = new CNeuronSSAMResNeXtBlock(); if(!conv_res || !conv_res.Init(0, index, OpenCL, chanels[i + 1], chanels[i + 2], units[i + 1], units[i + 2], group_size, groups, heads, dimension_k, optimization, iBatch) || !cFlow.Add(conv_res)) { DeleteObj(conv_res) return false; } } //--- return true; }
De este modo, el método va construyendo poco a poco una arquitectura ramificada:
- una secuencia recurrente formada por bloques ResNeXt, neuronas básicas y GRU;
- una línea de correlación para analizar las relaciones entre canales;
- una rama de flujo que refuerza las dependencias espaciales.
Como resultado, el codificador es capaz de tener en cuenta simultáneamente la dinámica temporal, identificar patrones locales y analizar interrelaciones multidimensionales, lo que lo convierte en una herramienta robusta y flexible para el procesamiento de datos complejos.
El método feedForward se encarga de organizar la pasada directa y, de hecho, da vida a toda la arquitectura creada durante la fase de inicialización. Los datos de entrada se proporcionan como estado inicial, tras lo cual comienzan a recorrer la línea recurrente.
bool CNeuronSTEFlowNetEncoder::feedForward(CNeuronBaseOCL *NeuronOCL) { CNeuronBaseOCL *recur = NeuronOCL; CNeuronBaseOCL *flow = cRecurrentLine[0]; CNeuronStackCorrelation *correl = NULL; CNeuronSSAMResNeXtBlock* resnext = NULL; int layers = (cRecurrentLine.Total() + 1) / 3; //--- for(int i = 0; i < layers; i++) { //--- ResNeXt if(!cRecurrentLine[i * 3] || !cRecurrentLine[i * 3].FeedForward(recur)) return false; recur = cRecurrentLine[i * 3];
El primer paso de cada iteración del ciclo consiste en activar el bloque ResNeXt, que procesa el estado actual y pasa su puntero a la variable local recur. Al mismo tiempo, se inicia el módulo de correlación, que trabaja con el flujo y extrae las dependencias temporales entre los estados.
//--- Correlation correl = cCorrelation[i]; if(!correl || !correl.FeedForward(flow)) return false;
Luego se combinan los resultados de estas dos ramas. La salida de ResNeXt y la del bloque de correlación se concatenan y se envían a la siguiente neurona. Esto permite combinar las características espaciales locales con la información sobre las relaciones entre los estados.
//--- Concatenate resnext = recur; recur = cRecurrentLine[i * 3 + 1]; if(!recur || !Concat(resnext.getOutput(), correl.getOutput(), recur.getOutput(), resnext.GetChannelsOut(), correl.GetStackSize(), resnext.GetUnitsOut())) return false;
Si la capa actual no es la última, entra en juego la celda GRU, que añade una dinámica temporal global y garantiza el procesamiento recurrente.
if((i * 3 + 2) == cRecurrentLine.Total()) break; //--- GRU if(!cRecurrentLine[i * 3 + 1] || !cRecurrentLine[i * 3 + 2].FeedForward(recur)) return false; recur = cRecurrentLine[i * 3 + 1];
A continuación, se actualiza la rama de flujo cFlow, que refuerza las dependencias espaciales y crea una vía paralela de transmisión de la información.
if(!cFlow[i] || !cFlow[i].FeedForward(flow)) return false; flow = cFlow[i]; } //--- return CNeuronSpikeConvGRU::feedforward(recur); }
De este modo, en cada iteración del ciclo, los datos pasan por la secuencia ResNeXt → Correlation → Concat → GRU → Flow, en la que cada elemento aporta su contribución.
Cuando se han procesado todas las capas, el control pasa al método del mismo nombre de la clase padre, que finaliza la pasada directa. En definitiva, este método garantiza un flujo coordinado de datos a través de las ramas paralelas de la arquitectura, manteniendo el equilibrio entre la dinámica temporal, los patrones espaciales y las correlaciones entre canales.
Hoy hemos trabajado mucho y nos hemos ganado un breve descanso. En el próximo artículo retomaremos el tema con nuevas energías y llevaremos lo que hemos empezado hasta su conclusión lógica.
Conclusión
En este artículo hemos explicado paso a paso cómo se crea y cómo funciona el codificador STE‑FlowNet. Hemos visto cómo, a partir de módulos individuales, se forma una arquitectura completa. Y al analizar el método de pasada directa, quedó claro cómo interactúan estos elementos. El resultado ha sido una arquitectura capaz de extraer patrones espaciotemporales teniendo en cuenta la dinámica causal oculta, conservando la memoria temporal mediante la pila y evaluando instantáneamente las correlaciones entre los estados.
En la siguiente parte continuaremos el trabajo y pasaremos a la validación práctica: probaremos el modelo con datos históricos reales y evaluaremos la velocidad de convergencia, la robustez frente al ruido del mercado y la viabilidad práctica del enfoque. Es precisamente en esta fase cuando quedará claro lo más importante: si el diseño propuesto ofrece resultados satisfactorios en condiciones reales de mercado.
Enlaces
- Spatio-Temporal Recurrent Networks for Event-Based Optical Flow Estimation
- Otros artículos de la serie
Programas utilizados en el artículo
| # | Nombre | Tipo | Descripción |
|---|---|---|---|
| 1 | Study.mq5 | Asesor experto | Asesor experto para el entrenamiento de modelos offline |
| 2 | StudyOnline.mq5 | Asesor experto | Asesor experto para el entrenamiento de modelos en línea |
| 3 | Test.mq5 | Asesor experto | Asesor experto para probar el modelo |
| 4 | Trajectory.mqh | Biblioteca de clases | Estructura para describir el estado del sistema y la arquitectura de los modelos |
| 5 | NeuroNet.mqh | Biblioteca de clases | Biblioteca de clases para crear una red neuronal |
| 6 | NeuroNet.cl | Biblioteca | Biblioteca de código del programa OpenCL |
Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/20039
Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.
Este artículo ha sido escrito por un usuario del sitio web y refleja su punto de vista personal. MetaQuotes Ltd. no se responsabiliza de la exactitud de la información ofrecida, ni de las posibles consecuencias del uso de las soluciones, estrategias o recomendaciones descritas.