Sistema de autoaprendizaje por refuerzo para el trading algorítmico en MQL5
Introducción al mundo de los sistemas de trading que se desarrollan por sí mismos
Podemos imaginar un robot de trading que no se limite a seguir ciegamente unas reglas preestablecidas, sino que realmente aprenda de sus errores y éxitos, al igual que lo hace un trader humano. El aprendizaje por refuerzo en el contexto del trading algorítmico representa precisamente este tipo de sistema. No se trata simplemente de otro indicador técnico o conjunto de señales, sino de un enfoque fundamentalmente diferente a la hora de diseñar estrategias de trading, en el que la máquina descubre por sí misma los patrones del mercado a través de una interacción continua con él.
#property copyright "BrainRL Expert v2.0" #property version "2.00" #property strict #include <Trade\Trade.mqh> #include <Arrays\ArrayObj.mqh> // Parámetros de entrada del sistema input int BrainsCount = 5; // Número de cerebros en el colectivo input double LearningRate = 0.10; // Tasa de aprendizaje input double ExplorationRate = 0.30; // Nivel inicial de exploración input double Gamma = 0.90; // Factor de descuento input double MemoryDecay = 0.99; // Decaimiento de la memoria input bool SaveBrains = true; // Guardar los cerebros entrenados input bool LoadBrains = false; // Cargar cerebros guardados input int SaveInterval = 500; // Intervalo de guardado automático (en barras)
En los sistemas de trading clásicos, el programador o el trader debe describir de forma explícita cada regla: cuándo comprar, cuándo vender y dónde colocar los stops. Esto no solo requiere un profundo conocimiento del mercado, sino que también supone que podamos formalizar todos los matices del comportamiento del mercado en forma de instrucciones claras. Pero, ¿y si el mercado es demasiado complejo para una formalización de este tipo? ¿Y si los patrones cambiaran constantemente, se adaptaran y evolucionaran? Es precisamente aquí donde el aprendizaje por refuerzo demuestra su verdadero potencial.
El sistema que analizamos en este artículo está implementado en el lenguaje MQL5 para la plataforma MetaTrader 5 y constituye una arquitectura completa de aprendizaje automático multiagente. Este es capaz de operar de forma autónoma en los mercados financieros, perfeccionando continuamente sus estrategias a partir de la experiencia adquirida.
La filosofía de la arquitectura: de las neuronas a la inteligencia colectiva
La arquitectura del sistema presentado se asemeja más a la estructura del cerebro humano que a la de un asesor experto de trading típico. Se basa en la idea de una organización jerárquica del conocimiento y de la toma colectiva de decisiones. En el nivel más bajo se encuentran las neuronas de memoria: unidades elementales de experiencia, cada una de las cuales almacena información sobre un estado concreto del mercado y la acción que se llevó a cabo en dicho estado.
struct MarketStateBinary { int binaryCode[32]; double volatility; double momentum; double trend; double price; datetime timestamp; double outcome; int activations; };
Estas neuronas no existen de forma aislada. Se agrupan en estructuras de orden superior a las que, por simplicidad, he denominado "cerebros": agentes individuales capaces de tomar decisiones de trading. Cada uno de estos cerebros constituye una personalidad de trading independiente, con sus propios recuerdos, preferencias y estilo de trading.
class CMachineBrain : public CObject { private: CArrayObj m_neurons; Episode m_episodes[]; int m_currentGeneration; double m_brainComplexity; double m_overallIntelligence; double m_learningRate; double m_explorationRate; double m_gamma; double m_memoryDecay; int m_lastActivatedNeuron; MarketStateBinary m_currentMarketState; double m_totalReward; int m_totalTrades; int m_successfulTrades; string m_name; // Estadísticas sobre el balanceo de clases int m_buySignals; int m_sellSignals; int m_buyTrades; int m_sellTrades; double m_buyReward; double m_sellReward;
Pero eso tampoco es lo más alto de la jerarquía. Varios agentes-cerebro individuales se unen para formar una inteligencia colectiva: una especie de consejo de administración en el que cada participante tiene derecho a voto, pero el peso de ese voto depende de sus logros anteriores.
class CCollectiveMind { private: CMachineBrain* m_brains[]; int m_brainsCount; string m_groupName; public: CCollectiveMind(string name, int brainsCount, double lr, double eps, double gamma) { m_groupName = name; m_brainsCount = brainsCount; ArrayResize(m_brains, brainsCount); for(int i = 0; i < brainsCount; i++) { string brainName = name + "_Brain" + IntegerToString(i); double brainLR = lr * (0.8 + (MathRand() % 1000) / 10000.0 * 0.4); double brainEps = eps * (0.8 + (MathRand() % 1000) / 10000.0 * 0.4); m_brains[i] = new CMachineBrain(brainName, brainLR, brainEps, gamma); } Print("Inteligencia colectiva '", name, "' creada | Cerebros: ", brainsCount); }
Esta arquitectura de tres niveles dota al sistema de varias propiedades importantes a la vez. En primer lugar, permite conservar y aprovechar de forma eficaz una enorme cantidad de experiencia. Cada neurona de memoria supone un fragmento microscópico de conocimiento sobre el mercado, pero, en conjunto, conforman una imagen rica en matices de la dinámica del mercado. En segundo lugar, el uso de múltiples agentes garantiza la diversificación de las decisiones y reduce el riesgo de errores catastróficos. Aunque un cerebro llegue a una conclusión errónea, los demás pueden corregir la decisión final. En tercer lugar, el sistema se vuelve más robusto ante los cambios en las condiciones del mercado, ya que los distintos agentes pueden especializarse en diferentes tipos de situaciones de mercado.
Anatomía de la neurona de memoria: cuantización de la experiencia del mercado
Analicemos en detalle en qué consiste el bloque básico de construcción del sistema: la neurona de memoria. No se trata simplemente de un registro en una base de datos, sino de una estructura completa que encapsula una instantánea integral de la experiencia del mercado.
class CMemoryNeuron { public: MarketStateBinary marketState; double action; double reward; double qValue; double confidence; datetime birthTime; int activations; double successRate; double importance; int generation; CMemoryNeuron() { action = 0.5; reward = 0; qValue = 0; confidence = 0.5; birthTime = TimeCurrent(); activations = 0; successRate = 0.5; importance = 1.0; generation = 1; ArrayInitialize(marketState.binaryCode, 0); marketState.volatility = 0; marketState.momentum = 0; marketState.trend = 0; marketState.price = 0; marketState.timestamp = 0; marketState.outcome = 0; marketState.activations = 0; } void UpdateMetrics(double newReward) { activations++; reward = newReward; // Actualización del valor Q qValue = qValue + LearningRate * (newReward - qValue); // Actualización del porcentaje de éxito if(newReward > 0) successRate = successRate * 0.9 + 0.1; else if(newReward < 0) successRate = successRate * 0.9; // Actualización de la importancia importance = successRate * MathLog(activations + 1); confidence = (successRate + MathAbs(qValue)) / 2.0; } };
Cada neurona almacena una representación binaria del estado del mercado, codificada en forma de vector de 32 bits. ¿Por qué precisamente la representación binaria? Porque permite un almacenamiento compacto y una comparación rápida de los estados. La codificación del estado se realiza mediante la cuantización de las características continuas del mercado.
Además del propio estado del mercado, la neurona almacena la acción que se llevó a cabo en ese estado. La acción se representa con un número comprendido entre cero y uno, donde los valores más cercanos a cero corresponden a la venta, los más cercanos a uno a la compra, y los valores intermedios pueden interpretarse como distintos grados de confianza en la dirección, o incluso como la decisión de abstenerse de realizar la operación. Esta representación continua de las acciones aporta al sistema una flexibilidad mucho mayor que la elección rígida entre comprar y vender.
La neurona también lleva un registro de sus estadísticas de activaciones: cuántas veces se ha producido ese estado concreto y se ha utilizado para tomar decisiones. El porcentaje de operaciones exitosas realizadas a partir de esta neurona constituye el indicador de éxito. La importancia de una neurona se calcula como una combinación de su porcentaje de éxito y su frecuencia de uso; de este modo, el sistema destaca aquellos fragmentos de experiencia que no solo funcionan bien, sino que también se dan con la suficiente frecuencia como para ser significativos desde el punto de vista práctico.
Características estacionarias: una nueva perspectiva sobre la representación del mercado
A diferencia de las primeras versiones del sistema, que funcionaban con un conjunto limitado de características básicas, la versión 2.0 utiliza un espacio de características ampliado basado en indicadores estacionarios. La estacionariedad es un concepto clave en la estadística de series temporales, que significa que las propiedades estadísticas de un proceso no varían con el tiempo. Para los sistemas de trading, esto es de vital importancia, ya que la no estacionariedad de las series de precios es una de las principales causas del deterioro del rendimiento de los algoritmos.
El sistema extrae once tipos de características estacionarias de los datos de mercado. El índice de fuerza relativa (RSI) mide si un activo se encuentra en zona de sobrecompra o de sobreventa, normalizando la información sobre la velocidad y la magnitud de las variaciones de precio en una escala de cero a cien. El índice de canal de materias primas (CCI) evalúa la desviación del precio actual respecto a su media estadística, lo que permite identificar patrones cíclicos independientemente del nivel absoluto de los precios.
El oscilador estocástico determina la posición del precio de cierre actual con respecto al rango de precios de un periodo determinado, proporcionando una medida adimensional del impulso. La convergencia-divergencia de las medias móviles MACD se centra en la interacción entre la tendencia y el impulso, identificando posibles puntos de reversión mediante el análisis de la diferencia entre las medias móviles exponenciales.
El rango medio verdadero (ATR) cuantifica la volatilidad del mercado de una forma que no depende de la dirección del movimiento del precio. Las bandas de Bollinger normalizan la posición del precio con respecto a su variabilidad estadística, creando un canal adaptativo que se ensancha y se estrecha en función de las condiciones del mercado.
Las relaciones entre las medias móviles de distintos periodos codifican información sobre la fuerza y la estabilidad de la tendencia. Los fractales de Bill Williams identifican los extremos locales que pueden indicar posibles cambios de tendencia. El índice de movimiento direccional medio (ADX) mide la fuerza de la tendencia, independientemente de su dirección.
El rango porcentual de Williams, al igual que el estocástico, evalúa la posición del precio dentro de un rango reciente, pero con una escala invertida y sensibilidad a los periodos cortos. Por último, las variaciones de precios normalizadas para distintos intervalos de tiempo reflejan la evolución a corto y medio plazo sin estar vinculadas a niveles de precios concretos.
void CalculateStationaryFeatures(const MqlRates &rates[], MarketStateBinary &state) { int size = ArraySize(rates); if(size < 50) return; double prices[]; ArrayResize(prices, size); for(int i = 0; i < size; i++) prices[i] = rates[i].close; // RSI (14 periodos) double rsi = CalculateRSI(prices, 14); state.binaryCode[0] = rsi > 70 ? 1 : 0; state.binaryCode[1] = rsi < 30 ? 1 : 0; state.binaryCode[2] = rsi > 50 ? 1 : 0; // CCI (20 periodos) double cci = CalculateCCI(rates, 20); state.binaryCode[3] = cci > 100 ? 1 : 0; state.binaryCode[4] = cci < -100 ? 1 : 0; state.binaryCode[5] = cci > 0 ? 1 : 0; // Estocástico (14, 3, 3) double stoch = CalculateStochastic(rates, 14, 3, 3); state.binaryCode[6] = stoch > 80 ? 1 : 0; state.binaryCode[7] = stoch < 20 ? 1 : 0; state.binaryCode[8] = stoch > 50 ? 1 : 0; // MACD (12, 26, 9) double macd, signal; CalculateMACD(prices, 12, 26, 9, macd, signal); state.binaryCode[9] = macd > signal ? 1 : 0; state.binaryCode[10] = MathAbs(macd - signal) > 0.0001 ? 1 : 0; state.binaryCode[11] = macd > 0 ? 1 : 0; // ATR (14 periodos) double atr = CalculateATR(rates, 14); double atrNorm = atr / rates[size-1].close; state.binaryCode[12] = atrNorm > 0.01 ? 1 : 0; state.binaryCode[13] = atrNorm > 0.02 ? 1 : 0; state.binaryCode[14] = atrNorm > 0.005 ? 1 : 0; // Bandas de Bollinger (20, 2) double upper, middle, lower; CalculateBollingerBands(prices, 20, 2, upper, middle, lower); double bbPos = (prices[size-1] - lower) / (upper - lower); state.binaryCode[15] = bbPos > 0.8 ? 1 : 0; state.binaryCode[16] = bbPos < 0.2 ? 1 : 0; state.binaryCode[17] = bbPos > 0.5 ? 1 : 0; // Relaciones entre medias móviles (20 frente a 50) double ma20 = CalculateMA(prices, 20); double ma50 = CalculateMA(prices, 50); state.binaryCode[18] = ma20 > ma50 ? 1 : 0; state.binaryCode[19] = (ma20 - ma50) / ma50 > 0.01 ? 1 : 0; state.binaryCode[20] = prices[size-1] > ma20 ? 1 : 0; // Fractales (5 periodos) int fractal = DetectFractal(rates, 5); state.binaryCode[21] = fractal == 1 ? 1 : 0; state.binaryCode[22] = fractal == -1 ? 1 : 0; state.binaryCode[23] = fractal == 0 ? 1 : 0; // ADX (14 periodos) double adx = CalculateADX(rates, 14); state.binaryCode[24] = adx > 25 ? 1 : 0; state.binaryCode[25] = adx > 40 ? 1 : 0; state.binaryCode[26] = adx > 15 ? 1 : 0; // %R de Williams (14 periodos) double willR = CalculateWilliamsR(rates, 14); state.binaryCode[27] = willR > -20 ? 1 : 0; state.binaryCode[28] = willR < -80 ? 1 : 0; state.binaryCode[29] = willR > -50 ? 1 : 0; // Variaciones de precio (10 barras) double priceChange = (prices[size-1] - prices[size-11]) / prices[size-11]; state.binaryCode[30] = priceChange > 0.01 ? 1 : 0; state.binaryCode[31] = priceChange < -0.01 ? 1 : 0; // Métricas adicionales state.volatility = atrNorm; state.momentum = priceChange; state.trend = (ma20 - ma50) / ma50; state.price = prices[size-1]; state.timestamp = rates[size-1].time; }
Cada uno de estos indicadores aporta una perspectiva única sobre la dinámica del mercado y, en conjunto, ofrecen una visión multidimensional del estado del mercado, mucho más completa que un simple análisis de las variaciones de precios. Un aspecto fundamental es que todas estas características son estacionarias o casi estacionarias: sus propiedades estadísticas son relativamente estables a lo largo del tiempo, lo que hace que el aprendizaje sea más eficaz y los resultados más fiables.
La mecánica del aprendizaje: de la exploración a la maestría
El núcleo de cualquier sistema de aprendizaje por refuerzo es el algoritmo que actualiza las valoraciones de las acciones en función de la experiencia adquirida. En este sistema se utiliza un algoritmo de aprendizaje Q modificado, adaptado a las particularidades de los mercados financieros. La fórmula del aprendizaje Q es elegante en su sencillez: la nueva estimación del valor Q se calcula sumando a la estimación anterior el producto de la tasa de aprendizaje por la diferencia entre la recompensa observada y la estimación actual.
Esta fórmula plasma la idea de un acercamiento gradual a la verdadera valoración de la calidad de las acciones. Si la recompensa obtenida resulta ser superior a la valoración actual, el valor Q aumenta, lo que indica al sistema que esa acción, en ese estado, es mejor de lo que se esperaba. Si el resultado es decepcionante, la estimación se reduce. La tasa de aprendizaje controla el grado de agresividad con el que el sistema actualiza sus representaciones: un valor alto da lugar a una adaptación rápida, pero puede provocar inestabilidad, mientras que un valor bajo garantiza un aprendizaje fluido y conservador.
void Learn(double reward) { if(m_lastActivatedNeuron >= 0 && m_lastActivatedNeuron < m_neurons.Total()) { CMemoryNeuron *neuron = m_neurons.At(m_lastActivatedNeuron); neuron.UpdateMetrics(reward); // Seguimiento por clases if(neuron.action > 0.6) // BUY { m_buyTrades++; m_buyReward += reward; } else if(neuron.action < 0.4) // SELL { m_sellTrades++; m_sellReward += reward; } if(reward > 0) m_successfulTrades++; m_totalReward += reward; m_totalTrades++; } // Limpieza periódica y evolución if(m_totalTrades % 100 == 0 && m_totalTrades > 0) { Prune(); Evolve(); } }
Sin embargo, no basta con actualizar los valores Q. El sistema debe resolver el dilema fundamental del aprendizaje por refuerzo: el equilibrio entre la exploración de estrategias desconocidas y la explotación de las soluciones válidas ya conocidas. Si el agente siempre elige la acción con el valor Q actual más alto, nunca descubrirá alternativas potencialmente mejores. Sin embargo, si se dedica constantemente a experimentar, no podrá aprovechar de forma eficaz los conocimientos adquiridos.
double Think(double &features[]) { EncodeToBinary(features, m_currentMarketState); int similarNeuron = FindSimilarState(m_currentMarketState); double action = 0.5; double randomValue = (double)(MathRand() % 10001) / 10000.0; if(m_totalTrades < 150) { // Fase de exploración inicial int cycle = m_totalTrades % 6; if(cycle == 0 || cycle == 1) action = 0.75 + randomValue * 0.2; // BUY else if(cycle == 2 || cycle == 3) action = 0.1 + randomValue * 0.2; // SELL else action = 0.4 + randomValue * 0.2; // HOLD m_lastActivatedNeuron = -1; if(m_totalTrades % 10 == 0 && ShowDetailedLog) Print("Exploration: Operación ", m_totalTrades, " | Action: ", DoubleToString(action, 3)); } else if(similarNeuron >= 0) { CMemoryNeuron *neuron = m_neurons.At(similarNeuron); if(randomValue > m_explorationRate) { // Explotación action = neuron.action; if(neuron.successRate > 0.6) action = MathMin(1.0, action * 1.1); else if(neuron.successRate < 0.4) action = MathMax(0.0, action * 0.9); if(m_totalTrades % 20 == 0 && ShowDetailedLog) Print("Exploit: Action=", DoubleToString(action, 3), " | SR=", DoubleToString(neuron.successRate, 2)); } else { // Exploración action = randomValue; if(m_totalTrades % 20 == 0 && ShowDetailedLog) Print("Explore: Random=", DoubleToString(action, 3)); } m_lastActivatedNeuron = similarNeuron; neuron.activations++; } else { // Nuevo estado action = randomValue; m_lastActivatedNeuron = -1; if(m_totalTrades % 20 == 0 && ShowDetailedLog) Print("New state: Random=", DoubleToString(action, 3)); } m_overallIntelligence = GetSuccessRate() * m_brainComplexity * 0.1; return action; }
El sistema presentado resuelve este dilema mediante una estrategia en varias fases. En la fase más temprana del aprendizaje, durante las primeras ciento cincuenta operaciones, el sistema se encuentra en modo de exploración activa. En esta fase, no se basa en la experiencia acumulada, sino que prueba cíclicamente diferentes tipos de acciones: varias operaciones de compra, varias de venta y varios periodos de inactividad. Es como un trader novato que aún no se ha formado una opinión sobre el mercado y simplemente prueba diferentes estrategias para ver cuál funciona.
Una vez finalizada la fase de exploración inicial, el sistema pasa a un modo más complejo. Ahora, cada vez que se toma una decisión, se genera un número aleatorio y, si este supera el parámetro épsilon (nivel de exploración), el sistema elige la mejor acción conocida: explota su experiencia. Si, por el contrario, el número aleatorio es menor que épsilon, se lleva a cabo una acción de exploración: el sistema prueba algo nuevo, aunque parezca subóptimo según los conocimientos actuales.
Balanceo de clases: solución al problema del desequilibrio
Una de las novedades clave de la versión 2.0 es el sistema integrado de balanceo de clases de decisiones de trading. El problema del desequilibrio entre clases es bien conocido en el aprendizaje automático: cuando una clase aparece con mucha más frecuencia en los datos de entrenamiento, el modelo puede aprender a predecir sistemáticamente la clase más frecuente, ignorando la menos frecuente. En el contexto de los sistemas de trading, esto se manifiesta como una tendencia a abrir únicamente posiciones de compra o únicamente de venta, lo que da lugar a un aprovechamiento subóptimo de las oportunidades del mercado y a un mayor riesgo.
El sistema realiza un seguimiento del número de señales de compra y venta, así como de su eficacia. Cuando se detecta un desequilibrio significativo —si más del setenta por ciento de las señales corresponden a una sola clase—, se activa el mecanismo de corrección.
double ApplyClassBalance(double action) { int totalSignals = m_buySignals + m_sellSignals; if(totalSignals < 50) return action; double buyRatio = (double)m_buySignals / totalSignals; double sellRatio = (double)m_sellSignals / totalSignals; // Corrección del desequilibrio if(buyRatio > 0.70 && action > 0.6) { action = action * 0.7 - 0.15; action = MathMax(0.0, action); if(ShowDetailedLog && m_totalTrades % 50 == 0) Print("Balance: BUY ratio=", DoubleToString(buyRatio, 2), " -> Corrección hacia SELL"); } else if(sellRatio > 0.70 && action < 0.4) { action = action * 0.7 + 0.35; action = MathMin(1.0, action); if(ShowDetailedLog && m_totalTrades % 50 == 0) Print("Balance: SELL ratio=", DoubleToString(sellRatio, 2), " -> Correción hacia BUY"); } // Refuerzo de la clase con buenos resultados if(m_buyTrades > 10 && m_sellTrades > 10) { double buyWinRate = m_buyTrades > 0 ? m_buyReward / m_buyTrades : 0; double sellWinRate = m_sellTrades > 0 ? m_sellReward / m_sellTrades : 0; if(buyWinRate > sellWinRate + 0.3 && action > 0.4 && action < 0.6) { action = action * 1.2; action = MathMin(1.0, action); } else if(sellWinRate > buyWinRate + 0.3 && action > 0.4 && action < 0.6) { action = action * 0.8; action = MathMax(0.0, action); } } // Seguimiento de señales if(action > 0.6) m_buySignals++; else if(action < 0.4) m_sellSignals++; return action; }
La corrección funciona modificando la acción propuesta. Si el sistema tiende a realizar un número excesivo de compras y genera otra señal de compra, dicha señal se atenúa mediante una transformación matemática, lo que la desplaza hacia la zona neutra o incluso hacia la venta. Se aplica una lógica similar cuando hay un exceso de señales de venta.
Además, el sistema analiza la eficacia de cada clase de acciones. Si las compras generan sistemáticamente beneficios considerablemente mayores que las ventas, el sistema da prioridad a las señales de compra en la zona neutral de incertidumbre, donde la decisión no es clara. Esto permite aprovechar eficazmente las ventajas estadísticas sin ignorar por completo la clase con peores resultados.
Este enfoque garantiza la diversificación de las decisiones de trading y evita el desarrollo de un sesgo sistemático que podría resultar catastrófico si cambian las condiciones del mercado. Un sistema que solo haya aprendido a operar en una dirección se verá desamparado cuando el mercado cambie de tendencia.
Gestión de la complejidad: poda y evolución
A medida que avanza el aprendizaje, el número de neuronas del sistema aumenta de forma constante. Cada nuevo estado del mercado puede generar una nueva neurona y, si no se controla este proceso, el sistema alcanzará rápidamente un tamaño inmanejable. Pero el problema no radica solo en el tamaño: el exceso de neuronas provoca un sobreajuste, en el que el sistema memoriza fluctuaciones aleatorias del mercado en lugar de identificar los verdaderos patrones.
void Prune()
{
if(m_neurons.Total() < 1000) return;
int removed = 0;
for(int i = m_neurons.Total() - 1; i >= 0 && removed < 100; i--)
{
CMemoryNeuron *neuron = m_neurons.At(i);
if(neuron.activations > 10 && neuron.successRate < 0.3)
{
m_neurons.Delete(i);
removed++;
}
}
if(removed > 0 && ShowDetailedLog)
Print("Poda: se han eliminado ", removed, " neuronas ");
} El proceso de poda —la limpieza de la red neuronal— se activa automáticamente cuando el número de neuronas supera las mil. El sistema comienza a analizar su memoria en busca de neuronas inútiles o dañinas. Los criterios de selección son sencillos, pero eficaces: la neurona debe tener suficiente experiencia como para que su calidad pueda evaluarse de forma estadísticamente significativa, pero, al mismo tiempo, debe mostrar un bajo índice de aciertos.
Una neurona que se haya activado más de diez veces, pero que haya mostrado un porcentaje de aciertos inferior al treinta por ciento, representa claramente una mala estrategia. No se trata de un fallo aleatorio, sino de un patrón persistente de pérdidas. Esas neuronas se eliminan sin piedad del sistema. En una sola operación de poda se pueden eliminar hasta cien neuronas, lo que evita el crecimiento descontrolado de la red y libera recursos para áreas más prometedoras del espacio de estados.
Cada cien operaciones, además de la poda, se produce una transición evolutiva hacia una nueva generación:
void Evolve() { m_currentGeneration++; m_explorationRate *= m_memoryDecay; m_explorationRate = MathMax(0.01, m_explorationRate); if(ShowDetailedLog) Print("Generación ", m_currentGeneration, " | Exploration: ", DoubleToString(m_explorationRate, 3)); }
No se trata simplemente de un incremento del contador, sino de un momento simbólico en la maduración del sistema. Con cada generación, el nivel de exploración disminuye, lo que indica que el sistema ha acumulado suficiente experiencia y puede basarse más en estrategias probadas. El coeficiente de decaimiento aplicado al parámetro de exploración se ha fijado en noventa y nueve centésimas. Esto significa que, con cada generación, el nivel de exploración se mantiene en el noventa y nueve por ciento del valor anterior.
La sabiduría de la multitud: la toma colectiva de decisiones
Un agente individual, por muy perfecto que sea, siempre está expuesto al riesgo de cometer errores sistemáticos. La inteligencia colectiva resuelve este problema mediante la diversificación: en lugar de un único agente, se crea un conjunto de cerebros independientes, cada uno de los cuales se entrena con parámetros ligeramente diferentes y, por lo tanto, desarrolla su propia visión del mercado.
double ConsensusThink(double &state[]) { double totalAction = 0; double totalWeight = 0; for(int i = 0; i < m_brainsCount; i++) { if(CheckPointer(m_brains[i]) != POINTER_DYNAMIC) continue; double action = m_brains[i].Think(state); double weight = m_brains[i].GetSuccessRate() + 0.1; totalAction += action * weight; totalWeight += weight; } return totalWeight > 0 ? totalAction / totalWeight : 0.5; }
Cuando llega el momento de tomar una decisión de trading, cada cerebro del colectivo formula su propia recomendación de forma independiente. Estas recomendaciones no se promedian sin más, sino que se ponderan en función de la tasa de éxito de cada agente. Un cerebro que muestra buenos resultados de forma constante tiene mayor peso en el consenso final. Un cerebro que tiene dificultades con las condiciones actuales del mercado aporta menos.
La fórmula del consenso es elegante en su sencillez. Cada acción propuesta por el agente se multiplica por un peso igual a su porcentaje de éxito más una pequeña constante (normalmente una décima). Esta constante garantiza que incluso un agente con un índice de éxito nulo tenga al menos algo de peso; quizá sea precisamente su opinión atípica la que resulte decisiva en una situación inusual.
void CollectiveRemember(double action) { for(int i = 0; i < m_brainsCount; i++) if(CheckPointer(m_brains[i]) == POINTER_DYNAMIC) m_brains[i].Remember(action); } void CollectiveLearn(double reward) { for(int i = 0; i < m_brainsCount; i++) if(CheckPointer(m_brains[i]) == POINTER_DYNAMIC) m_brains[i].Learn(reward); }
El sistema también realiza un seguimiento de las métricas colectivas: el número total de neuronas en todos los cerebros y la inteligencia media del colectivo. Estas métricas ofrecen una visión general del grado de madurez y las capacidades del sistema.
La codificación de la realidad del mercado: de los precios a los patrones
Para que el sistema pueda aprender de forma eficaz, debe percibir el mercado no como un flujo caótico de precios, sino como una secuencia estructurada de estados. El proceso de codificar la información del mercado en una representación binaria compacta es el arte de encontrar el equilibrio entre el contenido informativo y la generalización.
int FindSimilarState(MarketStateBinary &state) { int bestMatch = -1; double bestSimilarity = 0; for(int i = 0; i < m_neurons.Total(); i++) { CMemoryNeuron *neuron = m_neurons.At(i); double similarity = CalculateSimilarity(state, neuron.marketState); if(similarity > bestSimilarity) { bestSimilarity = similarity; bestMatch = i; } } return bestSimilarity > 0.75 ? bestMatch : -1; } double CalculateSimilarity(MarketStateBinary &state1, MarketStateBinary &state2) { int matches = 0; for(int i = 0; i < 32; i++) if(state1.binaryCode[i] == state2.binaryCode[i]) matches++; return (double)matches / 32.0; }
Cuando el sistema se enfrenta a un nuevo estado del mercado, calcula su código binario y busca estados similares en su memoria. La similitud se determina mediante un simple recuento de los bits coincidentes. Si coinciden veinticuatro bits de un total de treinta y dos, eso supone un setenta y cinco por ciento de similitud. El umbral del setenta y cinco por ciento se ha elegido como solución de compromiso: lo suficientemente alto como para que los estados sean realmente similares, pero lo suficientemente bajo como para que el sistema pueda generalizar la experiencia entre situaciones parecidas.
La función de recompensa: el lenguaje de la retroalimentación
Cualquier sistema de aprendizaje requiere un bucle de retroalimentación, es decir, una forma de evaluar hasta qué punto la decisión tomada ha sido acertada o errónea. Para un sistema de trading, la recompensa natural es el beneficio o la pérdida derivada de una operación.
double CalculateReward(double action, double entryPrice, double exitPrice, double spread) { double reward; if(action > 0.6) // BUY { reward = (exitPrice - entryPrice - spread) / Point; } else if(action < 0.4) // SELL { reward = (entryPrice - exitPrice - spread) / Point; } else // HOLD { reward = 0; } // Normalización en el intervalo [-1, +1] reward = MathMax(-1.0, MathMin(1.0, reward / 100.0)); return reward; }
Matemáticamente, la recompensa se calcula como la diferencia entre los precios, normalizada en un intervalo que va de menos uno a más uno. En una operación de venta, la lógica se invierte: la recompensa es positiva si el precio ha bajado. Un matiz importante: de la diferencia de precios se deduce el spread, que representa los costes de transacción.
Persistencia del conocimiento: guardado y restauración
El aprendizaje por refuerzo requiere importantes recursos informáticos y tiempo. Sería un desperdicio perder la experiencia acumulada cada vez que se reinicia el sistema. Por eso, resulta fundamental poder guardar el estado de los modelos entrenados y restaurarlos cuando sea necesario.
bool SaveToFile() { string filename = BrainFolder + "/" + m_name + ".brain"; int handle = FileOpen(filename, FILE_WRITE|FILE_BIN|FILE_COMMON); if(handle == INVALID_HANDLE) return false; // Metadatos FileWriteInteger(handle, m_neurons.Total()); FileWriteInteger(handle, m_currentGeneration); FileWriteDouble(handle, m_totalReward); FileWriteInteger(handle, m_totalTrades); FileWriteInteger(handle, m_successfulTrades); FileWriteDouble(handle, m_learningRate); FileWriteDouble(handle, m_explorationRate); FileWriteDouble(handle, m_gamma); // Estadísticas de balanceo FileWriteInteger(handle, m_buySignals); FileWriteInteger(handle, m_sellSignals); FileWriteInteger(handle, m_buyTrades); FileWriteInteger(handle, m_sellTrades); FileWriteDouble(handle, m_buyReward); FileWriteDouble(handle, m_sellReward); // Neuronas int toSave = MathMin(m_neurons.Total(), 5000); for(int i = 0; i < toSave; i++) { CMemoryNeuron *n = m_neurons.At(i); for(int j = 0; j < 32; j++) FileWriteInteger(handle, n.marketState.binaryCode[j]); FileWriteDouble(handle, n.action); FileWriteDouble(handle, n.qValue); FileWriteInteger(handle, n.activations); FileWriteDouble(handle, n.successRate); FileWriteDouble(handle, n.importance); FileWriteInteger(handle, n.generation); } FileClose(handle); Print("Cerebro '", m_name, "' guardado: ", toSave, " neuronas "); return true; }
Cada cerebro del sistema puede guardarse a sí mismo en un archivo binario. Este archivo contiene toda la información necesaria para restaurar completamente el estado del cerebro: el número de neuronas, la generación actual, la recompensa acumulada, el número total de operaciones, el número de operaciones exitosas, los parámetros de aprendizaje y las estadísticas de balanceo de clases. A continuación, se guarda el estado completo de cada neurona.
La restauración desde el archivo se realiza durante la inicialización del cerebro. El sistema intenta encontrar el archivo correspondiente y, si existe, lee todos los datos y reconstruye el array de neuronas. Tras la carga, el sistema se encuentra exactamente en el mismo estado que en el momento del último guardado y puede continuar con el aprendizaje o el trading desde donde se quedó.
Resultados prácticos y perspectivas de desarrollo
Vamos a analizar una prueba del sistema sin ningún aprendizaje previo (autoaprendizaje íntegramente en línea con datos completamente nuevos desde el inicio), realizada para el año 2025 con el par EURUSD y los precios de apertura de H1:

Estas son las estadísticas del sistema, que no están nada mal, incluso con una lógica de trading muy básica y niveles de stop loss y take profit estrictamente fijos:

Como podemos ver, la red neuronal se ha adaptado al mercado, ha comprendido sus patrones y ha obtenido una rentabilidad del +41 % en menos de un año de operativa.
Y así se comporta este sistema al utilizar un esquema cuántico complejo en el proceso de aprendizaje Q y un sistema más eficaz de gestión de órdenes y riesgos, con los precios de apertura de H1 del par EURUSD y también en un régimen de autoaprendizaje completo:

Las pruebas realizadas con datos históricos demuestran la capacidad de adaptación y de autoaprendizaje del sistema. Incluso sin preparación previa, el sistema muestra una evolución positiva sostenida, identificando por sí mismo los patrones del mercado y generando beneficios.
La mejora clave de la versión 2.0 es la solución al problema del desequilibrio entre clases. Antes, el sistema tendía a inclinarse hacia las compras o las ventas; ahora, el mecanismo integrado de balanceo de clases garantiza una distribución uniforme de las decisiones, lo que aumenta la estabilidad y la diversificación.
El espacio ampliado de características, basado en 11 tipos de indicadores estacionarios, ofrece al sistema una comprensión más profunda de la dinámica del mercado, lo que le permite detectar patrones sutiles y adaptarse a distintos regímenes de mercado.
El módulo de persistencia del conocimiento permite guardar y cargar modelos entrenados, lo que evita tener que volver a entrenarlos y garantiza un aprendizaje en línea continuo.
Las principales limitaciones son los elevados requisitos en cuanto a recursos y el riesgo de sobreajuste. A medida que aumenta el número de neuronas, el proceso de toma de decisiones se ralentiza, y la poda solo resuelve parcialmente el problema. Además, es posible que se produzca una pérdida de eficacia ante un cambio en las condiciones del mercado, lo que exige un seguimiento constante y la adaptación del modelo.
Conclusión
El sistema demuestra que en MQL5 es posible desarrollar una estrategia de trading completa basada en el aprendizaje por refuerzo, y que esta puede implementarse de forma compacta y eficiente. La arquitectura de la inteligencia colectiva proporciona robustez y adaptación a las condiciones cambiantes del mercado, y cada módulo —desde el balanceo de clases hasta la poda— potencia las capacidades intelectuales del sistema.
El aprendizaje por refuerzo permite detectar patrones ocultos del mercado y potencia la capacidad analítica del ser humano, sin reemplazar al propio ser humano. Los avances futuros —la integración de arquitecturas profundas, mecanismos de atención y metaaprendizaje— allanarán el camino hacia sistemas más flexibles y adaptables.En definitiva, el valor de este tipo de soluciones viene determinado por su capacidad para generar beneficios de forma constante con un riesgo controlado. El sistema presentado constituye una base sólida para las futuras generaciones de inteligencias de trading capaces de evolucionar por sí mismas.
Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/20122
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.
Se ha publicado el artículo «Sistema de autoaprendizaje con refuerzo para el trading algorítmico» en MQL5:
Autor: Yevgeniy Koshtenko
El archivo mq5 que se proporciona en este artículo no es el que se menciona en el artículo...!!
He compilado y ejecutado el archivo proporcionado, y el rendimiento ha sido deficiente.
El autor debería subir el archivo mq5 correcto.
Qué vergüenza para el editor y los revisores que han permitido que esto ocurra.