Redes neuronales en el trading: Percepción adaptativa de la dinámica del mercado (Final)
Introducción
El mercado financiero no es una tabla fácil de interpretar. Es un flujo. Continuo, disperso, a ratos explosivo. Los eventos del mercado no se producen según un calendario fijo. Surgen allí donde cambia la liquidez, se fragmentan las órdenes y aparecen fugaces picos de volumen. Comprender este flujo es una condición fundamental para crear un sistema de predicción fiable, sensible y adaptativo. STE-FlowNet surgió precisamente de esta observación: considerar el mercado como un flujo de eventos y enseñar al modelo a percibir su movimiento.
Esa perspectiva lo cambia todo. Los modelos básicos, que se basan únicamente en la secuencia de velas o en características agregadas, pierden a priori parte de la información sobre la estructura del movimiento: dónde y cuándo se produjo el desequilibrio entre la oferta y la demanda. El análisis basado en eventos permite detectar señales de gran relevancia en el momento en que aparecen. Esto se traduce en una baja latencia de respuesta. Esto aumenta la resistencia a los efectos del promediado, en los que la información importante se diluye en la agregación. Y otra cosa más. El flujo de eventos combina de forma natural la sensibilidad local y la estabilidad global. El modelo detecta tanto el pico instantáneo como la tendencia de fondo. Y todo ello sin una distinción artificial entre el corto y el largo plazo.
STE-FlowNet ha trasladado al ámbito financiero la idea de la percepción espaciotemporal, validada en otros campos como método para extraer la dinámica a partir de datos de eventos. No se basa en la magia, sino en rigurosa ingeniería. Se ha concebido como una herramienta para la modelización precisa e interpretable de la dinámica de mercado a corto plazo, que permite extraer directamente los micromovimientos de los precios y sus interrelaciones locales en el tiempo.
El framework STE-FlowNet puede compararse con un equipo de analistas expertos en el mercado financiero, cada uno de los cuales desempeña su función en el procesamiento del flujo de eventos. El codificador es el estratega principal, que registra cada operación, cada variación de precio y volumen, y acumula conocimientos sobre la dinámica actual y pasada del mercado. Su memoria ConvGRU funciona como un operador experimentado, que recuerda todo el historial de los últimos movimientos y evalúa al instante la importancia de las nuevas señales.
Los mapas de movimiento intermedios y las conexiones de salto constituyen una red analítica de asistentes que conservan los detalles y transmiten al instante la información de vital importancia. Estos permiten al modelo detectar tanto los picos de actividad repentinos como las tendencias lentas, pero importantes, de forma similar a un equipo que supervisa al mismo tiempo las fluctuaciones microscópicas de las cotizaciones y las tendencias globales del mercado.
La capa de correlación y el ajuste iterativo actúan como un grupo de expertos que corrigen las previsiones basándose en estimaciones anteriores. Cada nuevo paso tiene en cuenta tanto los datos actuales como todo el historial acumulado, lo que da lugar a una estrategia dinámica y adaptativa para predecir la evolución del mercado.
El decodificador final con Projection Head es un gestor de carteras que transforma todas las valoraciones y previsiones internas en acciones concretas: una señal de entrada o salida, una trayectoria probabilística del movimiento y una evaluación del riesgo y de la fuerza del impulso del mercado. Une a todos los miembros del equipo y elabora una solución práctica, lista para aplicarse en tiempo real.
El aprendizaje autosupervisado y el equilibrio entre la detección de anomalías locales y la suavidad global del flujo hacen que STE-FlowNet sea resistente al ruido, a los picos y a los eventos poco frecuentes. En el ámbito financiero, esto permite registrar con precisión las fluctuaciones bruscas de los precios y el volumen, identificar los puntos críticos y facilitar la toma de decisiones en condiciones de alta volatilidad.
A continuación mostramos una representación propia del framework STE-FlowNet.

En artículos anteriores, hemos completado la implementación de la estructura básica del codificador y hemos sentado las bases para el procesamiento de datos en flujo continuo. Hoy continuaremos con el desarrollo del framework: añadiremos los bloques residuales, implementaremos un decodificador de flujo completo y crearemos un objeto de nivel superior encargado del procesamiento integral de la señal de mercado.
El bloque residual
Hoy empezaremos a trabajar en la construcción del bloque residual, una especie de miniestructura dentro del modelo. Antes de tomar las herramientas, es decir, de escribir código, veremos el plano propuesto por los autores del framework. En el interior del bloque vemos dos pares consecutivos de bloques convolucionales con conexiones residuales, cuyos resultados se concatenan después cuidadosamente con los datos de entrada originales.
Conviene prestar especial atención a las conexiones residuales. Al estudiar SEW-ResNet, ya analizamos los problemas que plantea el uso de estructuras similares en las redes neuronales de impulsos. Lo primero que viene a la mente es el bloque Spike-Element-Wise, un componente de probada eficacia que permite mantener la estructura de las señales incluso con cargas complejas.
¿Para qué reinventar la rueda si ya existe una solución lista para usar y fiable? Propongo construir nuestro bloque residual utilizando enfoques SEW, del mismo modo que un arquitecto experimentado recurre a elementos probados para crear un edificio sólido. Este enfoque garantizará la estabilidad, conservará la forma de las características locales y acelerará el proceso de desarrollo, convirtiendo nuestro bloque en una parte sólida y funcional de todo el modelo.
Implementaremos la solución propuesta en la nueva clase CNeuronSTEFlowNetResidualBlock, que hereda la funcionalidad de la clase base CNeuronBaseOCL. El nuevo objeto encapsula por completo toda la lógica del bloque residual y la interacción con OpenCL.
class CNeuronSTEFlowNetResidualBlock : public CNeuronBaseOCL { protected: CLayer cBlock; //--- virtual bool feedForward(CNeuronBaseOCL *NeuronOCL) override; virtual bool updateInputWeights(CNeuronBaseOCL *NeuronOCL) override; virtual bool calcInputGradients(CNeuronBaseOCL *NeuronOCL) override; public: CNeuronSTEFlowNetResidualBlock(void) {}; ~CNeuronSTEFlowNetResidualBlock(void) {}; //--- virtual bool Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint chanels, uint units, uint group_size, uint groups, ENUM_OPTIMIZATION optimization_type, uint batch); //-- virtual int Type(void) override const { return defNeuronSTEFlowNetResidualBlock; } //--- 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 SetActivationFunction(ENUM_ACTIVATION value) override { }; virtual void TrainMode(bool flag) override; virtual bool Clear(void) override; };
En la estructura presentada solo se declara un componente interno, cBlock: un array dinámico de objetos que rellenamos durante la inicialización.
El método Init puede imaginarse como la formación de un equipo completo de especialistas para el análisis del mercado.
bool CNeuronSTEFlowNetResidualBlock::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint chanels, uint units, uint group_size, uint groups, ENUM_OPTIMIZATION optimization_type, uint batch) { if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, 2 * chanels * units, optimization_type, batch)) return false; activation = None;
En primer lugar, comprobamos si la clase padre está lista para funcionar. Es como asegurarse de que la oficina y la infraestructura estén preparadas para recibir a los empleados. Si la configuración básica no se ha realizado correctamente, el bloque no se pone en marcha.
A continuación, despejamos los escritorios y conectamos el superordenador OpenCL para que todo el equipo pueda procesar la información de forma eficaz.
CNeuronSpikeResNeXtBottleneck* conv = NULL; CNeuronSpikeResNeXtBlock* residual = NULL; //--- cBlock.Clear(); cBlock.SetOpenCL(OpenCL);
El primero en incorporarse al equipo es Bottleneck, el analista jefe, que filtra y comprime los datos que se analizan, destacando las características clave. Recibe sus herramientas —canales, grupos y lotes— y queda listo para realizar el análisis. Si, por cualquier motivo, no está preparado, se interrumpe la puesta en marcha del equipo; no tiene sentido continuar sin el analista principal.
uint index = 0; conv = new CNeuronSpikeResNeXtBottleneck(); if(!conv || !conv.Init(0, index, OpenCL, chanels, chanels, units, units, group_size, groups, optimization, iBatch) || !cBlock.Add(conv)) { DeleteObj(conv) return false; }
Luego se añaden al equipo dos bloques con conexiones residuales (bloques residuales). Su función consiste en verificar y precisar el análisis, respaldar la estrategia y conservar la información relevante. Cada nuevo analista pasa por un proceso de inicialización, obtiene acceso a los recursos y se integra en el flujo de trabajo general. Si alguno de los bloques no se crea, el equipo se detiene para evitar que se ejecute una estrategia incompleta.
for(int i = 0; i < 2; i++) { index++; residual = new CNeuronSpikeResNeXtBlock(); if(!residual || !residual.Init(0, index, OpenCL, chanels, chanels, units, units, group_size, groups, optimization, iBatch) || !cBlock.Add(residual)) { DeleteObj(residual) return false; } } //--- return true; }
Una vez añadidos correctamente todos los componentes internos, el equipo está totalmente listo para ponerse a trabajar. El bloque puede recibir señales, procesar datos y transmitir los resultados a las siguientes etapas. En definitiva, cBlock se convierte en un equipo cohesionado, en el que cada empleado conoce su función, colabora con sus compañeros y garantiza la precisión de las previsiones incluso en condiciones de gran dinamismo del mercado.
El algoritmo de pasada directa se ha implementado en el método feedForward, que puede compararse con el trabajo de un equipo bien coordinado de analistas. Cada uno de ellos procesa el flujo de información por turnos.
bool CNeuronSTEFlowNetResidualBlock::feedForward(CNeuronBaseOCL *NeuronOCL) { if(cBlock.Total() <= 0) return false;
Primero comprobamos si hay miembros en nuestro equipo. Sin ellos, no se puede hacer nada. Después los datos se envían al primer analista del array interno cBlock.
CNeuronBaseOCL* prev = NeuronOCL; CNeuronBaseOCL* current = NULL; for(int i = 0; i < cBlock.Total(); i++) { current = cBlock[i]; if(!current || !current.FeedForward(prev)) return false; prev = current; }
Cada miembro sucesivo del equipo recibe los resultados del anterior, los procesa según sus propias reglas y los transmite al siguiente, como si una cadena de especialistas fuera refinando el pronóstico y filtrando el ruido del mercado. Si algún miembro del equipo no logra realizar su tarea, todo el proceso se detiene para evitar distorsionar los resultados.
Cuando la señal pasa por todos los analistas, el resultado de su trabajo conjunto se integra con los datos originales del bloque. Es como si el analista jefe recopilara todos los informes, les añadiera la información de partida y elaborara una visión completa y equilibrada de la situación actual.
if(!Concat(prev.getOutput(), NeuronOCL.getOutput(), Output, 1, 1, Neurons() / 2)) return false; //--- return true; }
A continuación, el bloque residual devuelve el resultado, listo para su uso posterior en la ruta de cálculo del modelo.
La estructura lineal de la pasada directa hace que la propagación de los gradientes de error resulte bastante sencilla y transparente. Por ello, los métodos de pasada inversa se dejan para que el lector los estudie por su cuenta. El código fuente completo de la clase y de todos sus métodos se incluye en el archivo adjunto al artículo, lo que permitirá conocer en detalle la implementación del bloque residual y su lógica interna.
El decodificador
La siguiente etapa de nuestro trabajo consiste en construir el decodificador, un componente clave de la cadena de procesamiento que transforma las representaciones ocultas del codificador en información útil para el análisis. En este sentido, conviene prestar especial atención a dos flujos de información internos que permiten reconstruir de forma más detallada y precisa la dinámica de los datos originales. Además, el uso de los estados latentes del codificador permite al decodificador no solo reconstruir los datos, sino también formar una visión global de la dinámica del sistema, integrando las fluctuaciones a corto plazo y las tendencias a largo plazo. En el contexto financiero, esto puede interpretarse como la capacidad del modelo para tener en cuenta los impulsos instantáneos del mercado, las operaciones concretas y las tendencias generales, lo cual es fundamental para elaborar previsiones y estrategias.
La arquitectura del decodificador prevé el procesamiento secuencial de cada nivel de características, teniendo en cuenta de forma paralela el estado latente, lo que mejora la precisión de la predicción y la resistencia del modelo al ruido y a las anomalías poco frecuentes. Cada etapa de decodificación incluye convoluciones transpuestas y conexiones de salto, lo que permite reconstruir las características espaciales y temporales con gran detalle. Este enfoque garantiza la conservación de información de vital importancia sobre los micromovimientos locales y las fases globales, lo que constituye una base sólida para el análisis posterior y la toma de decisiones.
En definitiva, el decodificador actúa como puente entre las representaciones internas del codificador y las aplicaciones prácticas del modelo, transformando la dinámica oculta en una estructura predictiva formalizable que puede utilizarse para evaluar riesgos, identificar puntos clave del mercado y diseñar estrategias adaptativas.
Crearemos el decodificador como una nueva clase independiente, CNeuronSTEFlowNetDecoder, que desempeña un papel clave en la conversión de los estados ocultos del codificador en mapas predictivos de flujo. El decodificador se estructura en torno a dos componentes internos —cMainLine y cFlow—, que procesan las características principales y los flujos intermedios, respectivamente. Además, almacena un puntero al codificador cEncoder, lo que permite utilizar estados latentes para reproducir con precisión la dinámica.
class CNeuronSTEFlowNetDecoder : public CNeuronSpikeActivation { protected: CLayer cMainLine; CLayer cFlow; CNeuronSTEFlowNetEncoder* cEncoder; //--- virtual bool feedForward(CNeuronBaseOCL *NeuronOCL) override; virtual bool updateInputWeights(CNeuronBaseOCL *NeuronOCL) override; virtual bool calcInputGradients(CNeuronBaseOCL *NeuronOCL) override; public: CNeuronSTEFlowNetDecoder(void) {}; ~CNeuronSTEFlowNetDecoder(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, CNeuronSTEFlowNetEncoder* encoder, ENUM_OPTIMIZATION optimization_type, uint batch); //-- virtual int Type(void) override const { return defNeuronSTEFlowNetDecoder; } //--- 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 SetEncoder(CNeuronSTEFlowNetEncoder* encoder) { cEncoder = encoder; } //--- virtual bool WeightsUpdate(CNeuronBaseOCL *source, float tau) override; virtual void TrainMode(bool flag) override; virtual bool Clear(void) override; };
La inicialización del objeto del decodificador es un proceso minucioso y por etapas, en el que cada elemento del decodificador se crea, se configura y se añade a los flujos de información correspondientes: cMainLine y cFlow.
bool CNeuronSTEFlowNetDecoder::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint &chanels[], uint &units[], uint group_size, uint groups, uint heads, uint dimension_k, CNeuronSTEFlowNetEncoder *encoder, ENUM_OPTIMIZATION optimization_type, uint batch) { if(chanels.Size() != units.Size()) return false; //--- const uint layers = chanels.Size() - 1; if(layers < 1) return false;
En primer lugar, el método comprueba que los parámetros recibidos sean correctos: el número de elementos del array de descripción de canales debe coincidir con el tamaño del array que contiene el número de elementos de las secuencias analizadas, y el número total de capas debe ser al menos uno.
A continuación, se invoca la inicialización de la clase padre, cuyo objetivo es preparar el bloque para su funcionamiento, especificando las dimensiones del tensor de resultados y el método de optimización de los parámetros.
if(!CNeuronSpikeActivation::Init(numOutputs, myIndex, open_cl, units[layers]*chanels[layers], optimization_type, batch)) return false; cEncoder = encoder; uint enc_layers = (!cEncoder ? 0 : cEncoder.Layers());
Después se guarda un puntero al codificador para que el decodificador pueda acceder a los estados latentes, y se determina el número de capas del codificador para garantizar una interacción correcta.
Los arrays internos cMainLine y cFlow se vacían y se vinculan al contexto de OpenCL, tras lo cual comienza la construcción de los bloques por etapas.
CNeuronSSAMResNeXtBlock* conv_res = NULL; CNeuronConvOCL* conv = NULL; CNeuronBatchNormOCL* norm = NULL; CNeuronSpikeActivation* sa = NULL; CNeuronSpikeConvGRU* gru = NULL; CNeuronBaseOCL* concat = NULL; //--- cMainLine.Clear(); cFlow.Clear(); cMainLine.SetOpenCL(OpenCL); cFlow.SetOpenCL(OpenCL);
En el primer paso se crea el bloque residual principal CNeuronSSAMResNeXtBlock, que inicia el flujo principal de procesamiento de características.
uint index = 0; //--- Main Line conv_res = new CNeuronSSAMResNeXtBlock(); if(!conv_res || !conv_res.Init(0, index, OpenCL, chanels[0], chanels[1], units[0], units[1], group_size, groups, heads, dimension_k, optimization, iBatch) || !cMainLine.Add(conv_res)) { DeleteObj(conv_res) return false; }
A continuación, se añade una capa convolucional estándar CNeuronConvOCL, activada mediante la función SoftPlus, y una capa de normalización por lotes CNeuronBatchNormOCL, que garantiza la estabilidad y la coherencia de los datos.
index++; conv = new CNeuronConvOCL(); if(!conv || !conv.Init(0, index, OpenCL, chanels[1], chanels[1], chanels[1], units[1], 1, optimization, iBatch) || !cMainLine.Add(conv)) { DeleteObj(conv) return false; } conv.SetActivationFunction(SoftPlus); index++; norm = new CNeuronBatchNormOCL(); if(!norm || !norm.Init(0, index, OpenCL, conv.Neurons(), iBatch, optimization) || !cMainLine.Add(norm)) { DeleteObj(norm) return false; } norm.SetActivationFunction(None);
Las capas posteriores forman bloques alternos: uno de activación por impulsos en el flujo principal para la activación no lineal y SSAM ResNeXt en el flujo Flow, que procesa características locales y globales combinadas utilizando los estados latentes del codificador.
uint ch_in = chanels[0]; //--- for(uint i = 1; i < layers; i++) { //--- Main Line index++; sa = new CNeuronSpikeActivation(); if(!sa || !sa.Init(0, index, OpenCL, norm.Neurons(), optimization, iBatch) || !cMainLine.Add(sa)) { DeleteObj(sa) return false; } //--- Flow index++; conv_res = new CNeuronSSAMResNeXtBlock(); if(!conv_res || !conv_res.Init(0, index, OpenCL, ch_in, chanels[i], units[i - 1], units[i], group_size, groups, heads, dimension_k, optimization, iBatch) || !cFlow.Add(conv_res)) { DeleteObj(conv_res) return false; }
Cada bloque se comprueba minuciosamente para verificar su corrección y solo tras una inicialización satisfactoria se añade al canal de información correspondiente. En cada etapa se crean objetos intermedios para concatenar las características y armonizar las dimensiones de los canales, lo que garantiza la correcta integración de los datos del codificador y del objeto actual.
index++; ch_in = 2 * chanels[i]; if(enc_layers - i - 1 >= 0) { gru = cEncoder.GetLayer(enc_layers - i - 1); if(!gru) return false; if(gru.GetUnits() != units[i]) return false; ch_in += gru.GetChanels(); } concat = new CNeuronBaseOCL(); if(!concat || !concat.Init(0, index, OpenCL, ch_in * units[i], optimization, iBatch) || !cFlow.Add(concat)) { DeleteObj(concat) return false; } concat.SetActivationFunction(None);
Al final de cada ciclo se añaden bloques residuales adicionales y capas de convolución con la función SoftPlus y normalización, lo que completa la formación de la estructura Main Line en ese nivel.
//--- Main Line conv_res = new CNeuronSSAMResNeXtBlock(); if(!conv_res || !conv_res.Init(0, index, OpenCL, ch_in, ch_in, units[i], units[i + 1], group_size, groups, heads, dimension_k, optimization, iBatch) || !cMainLine.Add(conv_res)) { DeleteObj(conv_res) return false; } index++; conv = new CNeuronConvOCL(); if(!conv || !conv.Init(0, index, OpenCL, chanels[i + 1], chanels[i + 1], chanels[i + 1], units[i + 1], 1, optimization, iBatch) || !cMainLine.Add(conv)) { DeleteObj(conv) return false; } conv.SetActivationFunction(SoftPlus); index++; norm = new CNeuronBatchNormOCL(); if(!norm || !norm.Init(0, index, OpenCL, conv.Neurons(), iBatch, optimization) || !cMainLine.Add(norm)) { DeleteObj(norm) return false; } norm.SetActivationFunction(None); } //--- return true; }
Todo el proceso se repite en todas las capas internas, creando un mecanismo de procesamiento complejo, pero coherente. Permite al decodificador reconstruir con precisión las características espaciales y temporales de los datos, integrar los estados latentes y prepararlos para su posterior interpretación o predicción.
El método devuelve true solo después de que todos los componentes internos se hayan inicializado y añadido correctamente, lo que garantiza que el decodificador se encuentre en un estado correcto y listo para funcionar.
El algoritmo de pasada directa de nuestro decodificador está organizado como una secuencia minuciosamente coordinada de procesamiento de datos a través de dos flujos paralelos (Main Line y Flow), con la integración de los estados latentes del codificador.
bool CNeuronSTEFlowNetDecoder::feedForward(CNeuronBaseOCL *NeuronOCL) { //--- Main Line CNeuronSSAMResNeXtBlock* conv_res = NULL; CNeuronConvOCL* conv = NULL; CNeuronBatchNormOCL* norm = NULL; CNeuronSpikeActivation* sa = NULL; CNeuronSpikeConvGRU* gru = NULL; //--- Flow CNeuronSSAMResNeXtBlock* flow = NULL; CNeuronBaseOCL* concat = NULL; //--- CNeuronBaseOCL* prev = NeuronOCL; int layers = (cMainLine.Total() + 1) / 4; int enc_layers = int(!cEncoder ? 0 : cEncoder.Layers()); int enc_dim = 0;
En primer lugar, el método prepara las referencias a todos los bloques internos: bloques residuales, capas de convolución, normalización, activaciones por impulsos y ConvGRU para el flujo principal, así como los bloques SSAM ResNeXt y los objetos para la concatenación en el flujo Flow. La variable prev almacena un puntero al objeto que contiene los datos del paso anterior, con el fin de garantizar un procesamiento secuencial. Las variables layers y enc_layers contienen el número de niveles del decodificador y del codificador, respectivamente, y determinan el orden de integración de los estados latentes.
La decodificación se lleva a cabo por etapas. En primer lugar, el flujo principal pasa por el bloque residual, la capa de convolución y la normalización.
for(int i = 0; i < layers; i++) { conv_res = cMainLine[i * 4]; conv = cMainLine[i * 4 + 1]; norm = cMainLine[i * 4 + 2]; sa = cMainLine[i * 4 + 3]; if(enc_layers - i - 2 >= 0) { gru = cEncoder.GetLayer(uint(enc_layers - i - 2)); if(!gru) return false; enc_dim = (int)gru.GetChanels(); } else { gru = NULL; enc_dim = 0; } flow = cFlow[i * 2]; concat = cFlow[i * 2 + 1]; //--- Main Line if(!conv_res || !conv_res.FeedForward(prev)) return false; if(!conv || !conv.FeedForward(conv_res)) return false; if(!norm || !norm.FeedForward(conv)) return false; if(i == (layers - 1)) break;
Después, si no se trata de la última capa, se activa la capa de impulsos para realizar una transformación no lineal.
if(!sa || !sa.FeedForward(norm)) return false;
Al mismo tiempo, el flujo Flow procesa los datos de entrada y añade representaciones intermedias obtenidas del codificador a través de ConvGRU. En cada nivel, las salidas de estos dos flujos se combinan en un objeto concat, que une de forma precisa las características locales de Main Line, los mapas intermedios de Flow y, si los hay, los estados latentes del codificador, creando una representación coherente para el siguiente nivel.
//--- Flow if(!flow || !flow.FeedForward(prev)) return false; if(!concat) return false; if(!gru) { if(!Concat(sa.getOutput(), flow.getOutput(), concat.getOutput(), conv.GetFilters(), flow.GetChannelsOut(), conv.GetUnits())) return false; } else { if(conv.GetUnits() != gru.GetUnits()) return false; if(!Concat(sa.getOutput(), flow.getOutput(), gru.getOutput(), concat.getOutput(), conv.GetFilters(), flow.GetChannelsOut(), enc_dim, conv.GetUnits())) return false; } prev = concat; }
Además, el algoritmo tiene en cuenta la correspondencia de las dimensiones de los canales y del número de unidades entre las capas del decodificador y del codificador, lo que garantiza una combinación correcta de la información sin pérdida de detalles significativos.
Una vez recorridas todas las capas del decodificador, se invoca la activación por impulsos final mediante el objeto padre para generar el resultado definitivo del decodificador.
if(!CNeuronSpikeActivation::feedforward(norm)) return false; //--- return true; }
Gracias a esta estructura, el decodificador es capaz de acumular características locales y globales, integrar los estados latentes del codificador y transformarlos en una representación predictiva completa y lista para su uso. Esto es especialmente importante en el caso de los flujos financieros, en los que es necesario tener en cuenta tanto las microvariaciones de los precios como las tendencias a largo plazo al mismo tiempo.
Sin embargo, la pasada directa solo genera una previsión preliminar basada en los parámetros actuales del modelo, que, sin entrenamiento, resulta poco informativa. Para que el modelo aprenda realmente a identificar patrones y a predecir adecuadamente la dinámica, es necesario implementar algoritmos de pasada inversa que permitan ajustar los pesos en función del error entre la predicción y el valor objetivo.
Se debe prestar especial atención a la arquitectura de múltiples flujos del decodificador. Los flujos paralelos Main Line y Flow, así como la integración de los estados latentes del codificador, crean una compleja red de dependencias en la que un error en un flujo afecta a los demás. Esto requiere un enfoque minucioso de la propagación de los gradientes para tener en cuenta correctamente la contribución de cada bloque y evitar la distorsión de la información al actualizar los pesos.
Por lo tanto, la pasada inversa en CNeuronSTEFlowNetDecoder no debe limitarse a propagar el error hacia atrás, sino que debe agregarlo cuidadosamente a través de todas las ramas, combinando adecuadamente las características locales, globales y latentes. Solo con este enfoque el entrenamiento resulta eficaz, lo que permite al modelo adaptarse a las complejas regularidades espaciotemporales y detectar micromovimientos y tendencias globales, algo esencial para analizar la dinámica de los flujos financieros y elaborar estrategias de predicción fiables.
El algoritmo de distribución de los gradientes del error está implementado en el método calcInputGradients y constituye un elemento clave del proceso de entrenamiento del modelo. Garantiza la propagación correcta del error a través de la compleja arquitectura de múltiples flujos del decodificador, acumulando la contribución de cada bloque.
bool CNeuronSTEFlowNetDecoder::calcInputGradients(CNeuronBaseOCL *NeuronOCL) { //--- Main Line CNeuronSSAMResNeXtBlock* conv_res = cMainLine[-3]; CNeuronConvOCL* conv = cMainLine[-2]; CNeuronBatchNormOCL* norm = cMainLine[-1]; CNeuronSpikeActivation* sa = cMainLine[-4]; CNeuronSpikeConvGRU* gru = NULL; //--- Flow CNeuronSSAMResNeXtBlock* flow = cFlow[-2]; //--- int layers = cMainLine.Total() / 4; CNeuronBaseOCL* prev = (layers > 1 ? cFlow[-1] : NeuronOCL); int enc_layers = int(!cEncoder ? 0 : cEncoder.Layers()); int enc_dim = 0;
Al inicio del método se crean variables locales para almacenar punteros a los componentes internos del flujo principal: bloques residuales (conv_res), capas de convolución (conv), normalización (norm) y activaciones por impulsos (sa). Para el flujo Flow se definen los objetos flow. Por su parte, la variable prev apunta a la capa anterior, que participará en la propagación hacia atrás.
Asimismo, se calcula el número de capas en el decodificador y el codificador, lo que permite integrar correctamente los estados latentes para la pasada inversa.
En primer lugar, se calculan los gradientes de la capa final de normalización.
if(!CNeuronSpikeActivation::calcInputGradients(norm)) return false;
A continuación, se calculan sucesivamente los gradientes de las capas de convolución y los bloques residuales del flujo principal.
if(!conv || !conv.CalcHiddenGradients(norm)) return false; if(!conv_res || !conv_res.CalcHiddenGradients(conv)) return false;
Esta etapa garantiza una propagación precisa del error a través de transformaciones lineales y no lineales, lo que sienta las bases para una corrección adecuada de los pesos del modelo.
Luego se lleva a cabo un ciclo que va de las capas superiores a las inferiores.
if(!prev || !prev.CalcHiddenGradients(conv_res)) return false; //--- for(int i = layers - 1; i >= 0; i--) { if(enc_layers - i - 2 >= 0) { gru = cEncoder.GetLayer(uint(enc_layers - i - 1)); if(!gru) return false; enc_dim = (int)gru.GetChanels(); } else { gru = NULL; enc_dim = 0; } if(!sa || !flow) return false;
Para cada nivel, se comprueba si existe la capa ConvGRU correspondiente en el codificador. Si está presente, se incluye en el flujo general para la distribución de gradientes, lo que garantiza la correcta integración de los estados latentes.
Dentro del ciclo se realiza la división de los gradientes entre Main Line y Flow mediante el método DeConcat, que distribuye con precisión el error entre las características locales, los mapas intermedios y los vectores latentes del codificador. Esto garantiza que cada componente reciba una señal adecuada para el aprendizaje.
if(!gru) { if(!DeConcat(sa.getGradient(), flow.getGradient(), prev.getGradient(), conv.GetFilters(), flow.GetChannelsOut(), conv.GetUnits())) return false; } else if(!DeConcat(sa.getGradient(), flow.getGradient(), gru.getGradient(), prev.getGradient(), conv.GetFilters(), flow.GetChannelsOut(), enc_dim, conv.GetUnits())) return false;
Tras distribuir el error en Flow, se lleva a cabo la propagación hacia atrás en Main Line: primero a través de la activación por impulsos y después a través de la normalización y las capas de convolución hasta el bloque residual.
//--- Flow prev = (i > 0 ? cFlow[i * 2 - 1] : NeuronOCL); if(!prev || !prev.CalcHiddenGradients(flow)) return false; //--- Main Line conv_res = cMainLine[i * 4]; conv = cMainLine[i * 4 + 1]; norm = cMainLine[i * 4 + 2]; if(!norm.CalcHiddenGradients(sa)) return false; if(!conv || !conv.CalcHiddenGradients(norm)) return false; if(!conv_res || !conv_res.CalcHiddenGradients(conv)) return false;
Para sumar correctamente los gradientes de los dos flujos de información, utilizamos un método de probada eficacia que consiste en sustituir los punteros a los búferes de datos, lo que permite acumular la contribución minimizando las distorsiones en la propagación del error.
CBufferFloat* temp = prev.getGradient(); if(!prev.SetGradient(prev.getPrevOutput(), false) || !prev.CalcHiddenGradients(conv_res) || !SumAndNormilize(temp, prev.getGradient(), temp, 1, false, 0, 0, 0, 1) || !prev.SetGradient(temp, false)) return false; if(i==0) continue; sa = cMainLine[i * 4 - 1]; //--- Flow flow = cFlow[(i-1) * 2]; } //--- return true; }
El método también tiene en cuenta las características de la última capa, finaliza correctamente el ciclo y actualiza los gradientes de todos los objetos intermedios. Como resultado, el algoritmo garantiza una propagación estable y precisa del error a lo largo de toda la estructura del decodificador, lo que permite a la red adaptarse eficazmente a las complejas dependencias espaciotemporales y detectar micromovimientos y tendencias globales, algo especialmente importante para los flujos financieros y las estrategias de predicción.
De este modo, calcInputGradients implementa un mecanismo completo de propagación del error hacia atrás a través de múltiples flujos. Este garantiza que cada bloque y cada canal reciban la información correcta para actualizar los pesos, lo que asegura un entrenamiento fiable y detallado del modelo.
El ajuste de los parámetros del decodificador con el fin de minimizar el error se lleva a cabo mediante el método updateInputWeights, que actualiza directamente los pesos de todos los componentes internos del módulo basándose en los gradientes calculados previamente. Dicho proceso constituye la etapa final del ciclo de aprendizaje: tras la pasada directa, la elaboración de la predicción y la propagación inversa de los errores, el modelo obtiene información sobre cómo ha influido cada parámetro en el resultado y, en consecuencia, los ajusta para reducir el valor de la función de pérdida.
bool CNeuronSTEFlowNetDecoder::updateInputWeights(CNeuronBaseOCL *NeuronOCL) { //--- Main Line CNeuronSSAMResNeXtBlock* conv_res = NULL; CNeuronConvOCL* conv = NULL; CNeuronBatchNormOCL* norm = NULL; CNeuronSpikeActivation* sa = NULL; CNeuronSpikeConvGRU* gru = NULL; //--- Flow CNeuronSSAMResNeXtBlock* flow = NULL; CNeuronBaseOCL* concat = NULL; //--- CNeuronBaseOCL* prev = NeuronOCL; int layers = (cMainLine.Total() + 1) / 4; int enc_layers = int(!cEncoder ? 0 : cEncoder.Layers()); int enc_dim = 0;
El método comienza con la inicialización de los punteros a los componentes clave. Además, se determina el número de capas del decodificador y del codificador para integrar correctamente los estados latentes al actualizar los pesos.
Dentro del ciclo, se lleva a cabo un ajuste por etapas de los parámetros para cada capa del decodificador. En primer lugar, se actualizan los pesos del bloque residual utilizando la salida de la capa anterior como señal de entrada.
for(int i = 0; i < layers; i++) { conv_res = cMainLine[i * 4]; conv = cMainLine[i * 4 + 1]; norm = cMainLine[i * 4 + 2]; sa = cMainLine[i * 4 + 3]; if(enc_layers - i >= 0) { gru = cEncoder.GetLayer(uint(enc_layers - i - 1)); if(!gru) return false; enc_dim = (int)gru.GetChanels(); } else { gru = NULL; enc_dim = 0; } flow = cFlow[i * 2]; concat = cFlow[i * 2 + 1]; //--- Main Line if(!conv_res || !conv_res.UpdateInputWeights(prev)) return false;
A continuación, se actualizan sucesivamente los parámetros de la capa de convolución, la normalización y la activación por impulsos, lo que garantiza la coherencia de toda la Main Line y evita la pérdida de información sobre los gradientes en las etapas intermedias.
if(!conv || !conv.UpdateInputWeights(conv_res)) return false; if(!norm || !norm.UpdateInputWeights(conv)) return false; if(i == (layers - 1)) break; if(!sa || !sa.UpdateInputWeights(norm)) return false;
Se presta especial atención a la integración de la información procedente del codificador. Si existe la capa ConvGRU correspondiente, sus canales y vectores latentes se tienen en cuenta a la hora de actualizar los pesos, lo que permite al decodificador considerar correctamente las dependencias a largo plazo y las características globales conservadas en las etapas de codificación de la señal.
El flujo «Flow» se actualiza en paralelo con «Main Line», lo que garantiza la sincronización de la información local y global durante el aprendizaje y contribuye a una reconstrucción precisa del estado de fase de los datos.
//--- Flow if(!flow || !flow.UpdateInputWeights(prev)) return false; prev = concat; }
Una vez recorridas todas las capas, se actualizan los pesos de la clase padre, con lo que finaliza el proceso de ajuste.
if(!CNeuronSpikeActivation::updateInputWeights(norm)) return false; //--- return true; }
Esta organización garantiza que todos los parámetros internos del decodificador reciban señales correctas para el aprendizaje, teniendo en cuenta las fluctuaciones locales del flujo de entrada y las tendencias globales, integradas a través del codificador.
En general, el método updateInputWeights implementa un mecanismo jerárquico de actualización de parámetros con múltiples flujos. Cada bloque recibe una señal precisa para la corrección; los gradientes se acumulan y se distribuyen entre los componentes.
El código completo de CNeuronSTEFlowNetDecoder y de todos sus métodos se incluye en el archivo adjunto.
El objeto de nivel superior
En la siguiente etapa, pasaremos a la creación de un objeto integrado de nivel superior que agrupa todos los componentes clave del modelo en una arquitectura única. Tras el desarrollo minucioso de los distintos módulos (codificador, decodificador y bloque residual), surge la necesidad de crear una estructura capaz no solo de procesar secuencialmente el flujo de eventos, sino también de sincronizar el funcionamiento de todos los componentes internos. Este objeto permite combinar la codificación espaciotemporal, la extracción precisa de características locales y la predicción de la dinámica de los datos en un único mecanismo coordinado.
El objeto de nivel superior CNeuronSTEFlowNet actúa como integrador de todos los componentes clave del modelo. Hereda la funcionalidad básica de CNeuronSTEFlowNetDecoder, lo que permite prescindir de la creación de un componente interno de decodificador. Y permite implementar su funcionalidad mediante la clase padre.
class CNeuronSTEFlowNet : public CNeuronSTEFlowNetDecoder { //--- protected: CNeuronSTEFlowNetEncoder cSTEEncoder; CNeuronSTEFlowNetResidualBlock cSTEResidualBlock; //--- virtual bool feedForward(CNeuronBaseOCL *NeuronOCL) override; virtual bool updateInputWeights(CNeuronBaseOCL *NeuronOCL) override; virtual bool calcInputGradients(CNeuronBaseOCL *NeuronOCL) override; public: CNeuronSTEFlowNet(void) {}; ~CNeuronSTEFlowNet(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 int Type(void) override const { return defNeuronSTEFlowNet; } //--- 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 del objeto se declaran cSTEEncoder, que se encarga de la codificación espaciotemporal del flujo de eventos de entrada, y cSTEResidualBlock, que permite la extracción estable y precisa de características locales y micromovimientos. Este enfoque permite identificar al mismo tiempo las regularidades detalladas en intervalos de tiempo cortos y las tendencias globales acumuladas por el codificador.
La inicialización del objeto de nivel superior STE-FlowNet comienza con una comprobación de la coincidencia de los tamaños de los arrays de canales y secuencias, con el fin de descartar discrepancias en la configuración.
bool CNeuronSTEFlowNet::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;
Para que el decodificador funcione correctamente, se crean arrays de canales y de tamaños de secuencia en orden inverso, invirtiendo el orden de los elementos de los arrays originales. Al mismo tiempo, el primer elemento del array de canales se duplica para tener en cuenta las salidas concatenadas del bloque residual y garantizar una conexión coherente con el decodificador.
uint rev_chanels[], rev_units[]; if(ArrayResize(rev_chanels, chanels.Size()) < 0 || ArrayResize(rev_units, units. Size()) < 0) return false; uint total = chanels.Size(); for(uint i = 0; i < total; i++) rev_chanels[total - i - 1] = chanels[i]; rev_chanels[0] *= 2; //--- for(uint i = 0; i < total; i++) rev_units[total - i - 1] = units[i];
A continuación, se realiza la inicialización de cada componente clave. El codificador se crea utilizando los arrays originales de canales y de tamaños de secuencia, con los parámetros especificados de agrupación, cabezas de atención y dimensionalidad del espacio latente.
if(!cSTEEncoder.Init(0, 0, open_cl, chanels, units, group_size, groups, heads, dimension_k, stack_size, optimization_type, batch)) return false;
Tras el inicio correcto del codificador, se inicializa el bloque residual, que procesa los resultados del codificador y genera una representación estable de la dinámica.
if(!cSTEResidualBlock.Init(0, 1, open_cl, chanels[total - 1], units[total - 1], group_size, groups, optimization, iBatch)) return false;
En el último paso se inicializa el decodificador utilizando los arrays de canales y de tamaños de secuencia en orden inverso. Este obtiene un puntero al objeto del codificador, lo que le permite utilizar estados latentes para construir representaciones intermedias precisas del flujo de eventos.
rev_chanels[0] = cSTEResidualBlock.Neurons() / rev_units[0]; if(!CNeuronSTEFlowNetDecoder::Init(numOutputs, myIndex, open_cl, rev_chanels, rev_units, group_size, groups, heads, dimension_k, cSTEEncoder.AsObject(), optimization_type, batch)) return false; //--- return true; }
Una vez completados con éxito todos los pasos, el objeto está listo para funcionar, integrando el codificador, el decodificador y el bloque residual en un único modelo coordinado de procesamiento de datos espaciotemporales.
La pasada directa de STE-FlowNet se organiza como una transmisión secuencial de datos a través de todos los componentes clave del modelo. En primer lugar, la señal de entrada se envía al codificador, que genera una representación latente de los eventos analizados, acumulando información espaciotemporal y extrayendo características significativas.
bool CNeuronSTEFlowNet::feedForward(CNeuronBaseOCL *NeuronOCL) { if(!cSTEEncoder.FeedForward(NeuronOCL)) return false;
A continuación, el resultado del codificador se transmite al bloque residual, que potencia las características identificadas y conserva los detalles locales críticos. Este bloque garantiza la robustez del modelo frente al ruido y mejora la precisión de los cálculos posteriores, sentando las bases para una decodificación correcta.
if(!cSTEResidualBlock.FeedForward(cSTEEncoder.AsObject())) return false;
Por último, los datos actualizados se envían al decodificador, que, basándose en el estado latente del codificador y en las salidas del bloque residual, elabora una predicción del flujo de eventos.
return CNeuronSTEFlowNetDecoder::feedForward(cSTEResidualBlock.AsObject());
}
Este enfoque por etapas garantiza un procesamiento fiable de cada evento. Tiene en cuenta los micromovimientos locales y las tendencias globales, creando una representación coherente e informativa de la dinámica del sistema. En el contexto financiero, esto equivale al procesamiento secuencial de las operaciones analizadas y de las variaciones de precios para elaborar una previsión de la evolución del mercado con un alto nivel de detalle y adaptabilidad.
En definitiva, CNeuronSTEFlowNet es un objeto totalmente integrado, capaz de analizar de forma secuencial el flujo de eventos, detectar micromovimientos críticos, tener en cuenta las regularidades globales y ajustar dinámicamente sus parámetros para elaborar previsiones fiables. En el contexto de los mercados financieros, esto supone la posibilidad de realizar un seguimiento simultáneo de las fluctuaciones instantáneas de los precios y de las tendencias a largo plazo, creando así un modelo de análisis adaptable y de alta precisión para la toma de decisiones estratégicas y la gestión de riesgos.
El código completo de la clase y de todos sus métodos se incluye en el archivo adjunto al artículo.
La creación de un objeto de nivel superior abre nuevas posibilidades. Ahora, todos los módulos desarrollados anteriormente se agrupan en una estructura única y pueden integrarse en los modelos, literalmente, como una sola capa. Este enfoque simplifica considerablemente la creación de arquitecturas complejas de redes neuronales y hace que su integración en las estrategias de trading resulte lo más cómoda y clara posible.
Hoy no vamos a profundizar en la descripción detallada de la arquitectura de cada modelo entrenable, ya que esto no forma parte del enfoque principal. Todos los detalles sobre la implementación y la estructura se pueden consultar en el archivo adjunto al artículo.
Pruebas
Hemos llegado a la fase final del trabajo con el framework STE-FlowNet: la evaluación de la eficacia de los enfoques aplicados. Pero antes hay que entrenar a nuestro operador.
Primera fase: entrenamiento offline con datos históricos del par de divisas EURUSD en el marco temporal H1, correspondientes al periodo comprendido entre enero de 2024 y junio de 2025. Este periodo de tiempo se convirtió en un auténtico campo de entrenamiento. El modelo aprendió a reconocer patrones históricos, analizar la dinámica de los precios y los volúmenes de las operaciones, e identificar las relaciones entre las características clave. STE-FlowNet desarrolló su propia intuición de operador, combinándola con una evaluación estratégica precisa, y adquirió gradualmente la capacidad de predecir el comportamiento del mercado y evaluar el riesgo de cada operación potencial.
La siguiente etapa —el ajuste fino en línea en el probador de estrategias de MetaTrader 5— traslada el entrenamiento a unas condiciones más realistas. El modelo procesa los flujos de datos, una vela tras otra. En este contexto, STE-FlowNet aprende a desenvolverse en la dinámica del mercado, a mantener la estabilidad ante las fluctuaciones de ruido, a ajustar sus acciones en situaciones de baja liquidez y a reaccionar de forma inmediata ante los picos de precio bruscos. La estructura básica, formada a partir de datos históricos, permanece inalterada, pero el modelo aprende a reaccionar con flexibilidad ante la situación actual del mercado, minimizando el riesgo de sobreajuste y aumentando la precisión de las previsiones incluso en un entorno inestable.
La verificación final se realizó con datos totalmente nuevos correspondientes al periodo comprendido entre julio y septiembre de 2025. Todos los parámetros obtenidos en las etapas anteriores se cargaron sin modificaciones, lo que garantizó una evaluación imparcial de la capacidad de generalización de STE-FlowNet.

Los resultados de las pruebas realizadas con datos históricos son convincentes y demuestran la estabilidad de la estrategia. Empezaremos por los indicadores financieros. Con un depósito inicial de 100 dólares, el beneficio neto ascendió a 54,02 dólares, lo que supone un crecimiento total del patrimonio de más del 50 % durante el periodo analizado. El beneficio bruto alcanzó los 119,57 dólares, mientras que las pérdidas brutas ascendieron a 65,55 dólares, lo que da un factor de beneficio (Profit Factor) de 1,82. Este indicador refleja que la estrategia genera casi el doble de beneficios que de pérdidas, lo que se considera un resultado satisfactorio para los algoritmos de trading. El factor de recuperación de 1,31 pone de manifiesto la capacidad de la estrategia para recuperarse de los drawdowns.
Los drawdowns de patrimonio se sitúan en un nivel aceptable. El drawdown máximo de patrimonio fue del 28,57 %, lo cual es razonable para un enfoque algorítmico activo en el mercado de divisas. Por su parte, el drawdown absoluto del saldo fue del 25,13 %, lo que demuestra la capacidad de la estrategia para mantener eficazmente las posiciones y evitar una caída brusca del patrimonio.
Los resultados de las operaciones también ponen de manifiesto el carácter equilibrado de la estrategia. En total se realizaron 50 operaciones, de las cuales el 62 % resultó rentable. El porcentaje de posiciones cortas ganadoras fue del 63,16 %, y el de posiciones largas, del 61,29 %, lo que demuestra que el algoritmo funciona correctamente tanto en tendencias bajistas como alcistas. El beneficio medio por operación es de 3,86 dólares, mientras que la pérdida media es de 3,45 dólares; la proporción entre operaciones con resultados positivos y negativos está bien equilibrada. La mayor ganancia en una sola operación fue de 15,03 dólares, y la mayor pérdida, de 9,96 dólares.
En general, las pruebas confirman que STE-FlowNet se entrena con éxito a partir de datos históricos, reacciona adecuadamente a las señales del mercado y muestra un crecimiento estable del patrimonio. La estrategia es capaz de combinar la precisión de las previsiones con el control del riesgo. Sin embargo, antes de utilizarla en un proceso de negociación real, es necesario someterla a unas pruebas más exhaustivas y completas.
Conclusión
En este artículo hemos analizado en detalle la arquitectura y los componentes clave del framework STE-FlowNet, poniendo de manifiesto su flexibilidad y capacidad de adaptación a diversas tareas de análisis de datos. Las pruebas realizadas han confirmado la gran eficacia de las soluciones implementadas, demostrando su estabilidad y precisión incluso con series temporales complejas. Hemos prestado especial atención a la capacidad única del framework para integrar el procesamiento de múltiples flujos y las estructuras recurrentes, lo que permite acelerar los cálculos y modelar con mayor profundidad las dependencias de los datos. El enfoque presentado abre nuevas posibilidades para su aplicación práctica en el trading y en ámbitos afines, permitiendo elaborar previsiones de importancia estratégica con un gasto mínimo de recursos.
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 de entrenamiento offline de modelos |
| 2 | StudyOnline.mq5 | Asesor experto | Asesor de entrenamiento en línea de modelos |
| 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/20075
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.