English Русский Português
preview
Sistema de autoaprendizaje por refuerzo para el trading algorítmico en MQL5

Sistema de autoaprendizaje por refuerzo para el trading algorítmico en MQL5

MetaTrader 5 — Sistemas comerciales |
49 2
Yevgeniy Koshtenko
Yevgeniy Koshtenko

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

Archivos adjuntos |
Fedor Smirnov
Fedor Smirnov | 9 jun 2026 en 08:52
Me he leído este cuento de un tirón. Es una pena que el asesor técnico incluido no se corresponda en absoluto con la descripción.
Better Trader Every Day
Ciro Soto | 13 ago 2026 en 02:21

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.

Métodos de muestreo MCMC: Algoritmo de muestreo por cortes (Slice sampling) Métodos de muestreo MCMC: Algoritmo de muestreo por cortes (Slice sampling)
En este artículo analizaremos el método de muestreo por cortes (slice sampling), un algoritmo MCMC adaptativo que ajusta de forma autónoma los parámetros de muestreo. Su eficacia se ha demostrado en modelos bayesianos de regresión lineal y logística, y los resultados se comparan con los métodos frecuentistas clásicos.
Códice de posicionamiento en los mercados en MQL5 (Parte 1): Aprendizaje bit a bit para Nvidia Códice de posicionamiento en los mercados en MQL5 (Parte 1): Aprendizaje bit a bit para Nvidia
Hoy comenzaremos una nueva serie de artículos basada en nuestros trabajos anteriores, expuestos en la serie "MQL5 Wizard", y llevaremos estos un paso más allá profundizando en nuestro enfoque del trading sistemático y la prueba de estrategias. En esta nueva serie, nos centraremos en los asesores expertos programados para mantener únicamente un tipo de posición: principalmente posiciones largas. Centrarse en una sola tendencia del mercado puede simplificar el análisis, reducir la complejidad de la estrategia y revelar algunas claves importantes, especialmente cuando se opera con activos distintos de las divisas. Por lo tanto, nuestra serie analizará si esto resulta eficaz en las acciones y otros activos distintos de las divisas, donde los sistemas que solo abren posiciones largas suelen mostrar una buena correlación con las estrategias del dinero inteligente o de los inversores institucionales.
EA para la apertura de operaciones según el riesgo con interfaz de usuario integrada en el gráfico (Parte 1): Diseño de la interfaz de usuario EA para la apertura de operaciones según el riesgo con interfaz de usuario integrada en el gráfico (Parte 1): Diseño de la interfaz de usuario
En este artículo se explica cómo crear en MQL5 un panel de control claro y profesional integrado en el gráfico para un asesor experto de apertura de operaciones según el riesgo. Esta guía paso a paso explica cómo diseñar una interfaz gráfica de usuario (GUI) funcional que permita a los traders introducir los parámetros de las operaciones, calcular el tamaño del lote y prepararse para la colocación automática de órdenes.
Redes neuronales en el trading: Modelos de refinamiento iterativo de previsiones (Final) Redes neuronales en el trading: Modelos de refinamiento iterativo de previsiones (Final)
Presentamos el framework RAFT, una potente herramienta para el análisis y la previsión de series temporales financieras. Su arquitectura flexible y optimizada garantiza la precisión de las previsiones, la estabilidad del funcionamiento y agiliza el procesamiento de datos. RAFT reduce el riesgo de cometer errores y facilita la creación de estrategias de trading eficaces.