El filtro de Kalman para estrategias de reversión a la media en Forex

Introducción

El filtro de Kalman es un algoritmo recursivo utilizado en el trading algorítmico para estimar el estado real de una serie temporal financiera filtrando el ruido de los movimientos de precios. Actualiza dinámicamente las predicciones basándose en nuevos datos del mercado, lo que lo hace valioso para estrategias adaptativas como la reversión a la media. Este artículo presenta primero el filtro de Kalman, cubriendo su cálculo e implementación. A continuación, aplicamos el filtro a una estrategia clásica de reversión a la media en el mercado de divisas como ejemplo. Por último, realizamos diversos análisis estadísticos comparando el filtro con una media móvil en diferentes pares de divisas.

El filtro de Kalman

El filtro de Kalman, introducido por Rudolf E. Kalman en 1960, es un estimador recursivo óptimo utilizado para el seguimiento y la predicción de sistemas dinámicos. Desarrollado originalmente para sistemas aeroespaciales y de control, se ha aplicado ampliamente en finanzas, robótica y procesamiento de señales. El filtro funciona en dos pasos: un paso de predicción, en el que estima el siguiente estado del sistema, y un paso de actualización, en el que refina la estimación basándose en nuevas observaciones y minimizando el ruido. 

En el ámbito del trading algorítmico, se puede considerar simplemente como un filtro de régimen común que suelen utilizar los operadores, similar a los modelos de media móvil o regresión lineal. El filtro de Kalman se adapta dinámicamente a los nuevos datos, reduce el ruido y actualiza eficazmente las estimaciones en tiempo real, lo que lo hace eficaz para detectar cambios en el régimen del mercado. Sin embargo, asume una dinámica lineal, requiere un ajuste cuidadoso de los parámetros, puede tardar en detectar cambios bruscos y es computacionalmente más complejo que filtros más simples como las medias móviles.

Algunos usos comunes del filtro de Kalman en el trading algorítmico:

• Operaciones de reversión a la media: utilizar el precio actual en comparación con el precio estimado como filtro de entrada.
• Operaciones con pares: Estima dinámicamente el diferencial entre activos correlacionados y ajusta los ratios de cobertura en función de las condiciones cambiantes del mercado.
• Seguimiento de tendencias: Filtra el ruido a corto plazo para detectar con mayor precisión las tendencias de precios a largo plazo.
• Estimación de la volatilidad: Proporciona estimaciones adaptativas de la volatilidad del mercado para la gestión del riesgo y el dimensionamiento de posiciones.

La fórmula para calcular el valor del filtro de Kalman es la siguiente:

Para comprender la compleja fórmula de una manera sencilla, recurramos a un ejemplo visual.

El filtro de Kalman funciona actualizando su estimación del precio real basándose en mediciones y predicciones ruidosas. Por lo general, se obtiene en tres pasos:

1. Predicción: El filtro comienza con una estimación inicial del precio (precio previsto) y su incertidumbre (covarianza prevista). Esto se muestra en la zona prevista naranja, el rango dentro del cual el filtro espera que se encuentre el precio real, teniendo en cuenta tanto la estimación anterior como el ruido del proceso.

2. Actualización: Cuando hay nuevos datos de precios (precios medidos) disponibles, el filtro de Kalman los compara con el precio previsto. A continuación, calcula lo que se denomina ganancia de Kalman (línea morada) para decidir qué peso otorgar a la nueva medición frente a la predicción. Si la medición tiene mucho ruido, el filtro confía más en su predicción. 

3. Estimación: El filtro actualiza el precio previsto incorporando la nueva medición. El precio actualizado (mostrado por la zona azul de estimación) tiene una incertidumbre reducida en comparación con la predicción. Esta zona se reduce a medida que el filtro refina su estimación. 

Aquí, la incertidumbre de la predicción se define por la covarianza entre la medición y la predicción. Una covarianza mayor implica una estimación menos fiable, mientras que una menor implica una mayor certeza del filtro en su estimación. Si la medición es confiable, la ganancia de Kalman es alta y el filtro confía más en los nuevos datos (reduciendo la incertidumbre). Si la medición es ruidosa, la ganancia es menor y el filtro depende más de la predicción anterior.

El curioso se define por la varianza, es decir, la varianza de la medición y la varianza del proceso. No se ajustan automáticamente como la covarianza, se determinan desde el principio en función de qué tan suave desea que sea su filtro de Kalman.

A continuación se muestran algunos ejemplos de cómo las variaciones afectan la suavidad de la curva:

En general, la varianza del proceso (Q) representa cuánto espera el modelo que cambie el estado real con el tiempo, mientras que la varianza de la medición (R) refleja la confianza en los datos observados. Un valor más alto de Q hace que el filtro responda mejor a los cambios repentinos, pero aumenta la volatilidad. Un valor más alto de R suaviza las predicciones al confiar más en las estimaciones pasadas, a costa de retrasar los ajustes. Un Q bajo y un R moderado producen predicciones estables, mientras que un Q alto y un R bajo hacen que el filtro sea más reactivo pero más ruidoso.

Codificación de la estrategia

Las estrategias de reversión a la media suelen seguir el enfoque de comprar cuando hay sobreventa, vender cuando hay sobrecompra y salir cuando el precio vuelve a la media. Esta estrategia se basa en la suposición de que los datos sobre precios son generalmente estables y no tienden a alcanzar niveles extremos. Cuando el precio se encuentra en un extremo, se espera que finalmente vuelva al punto de equilibrio. Esta teoría es especialmente válida para datos semiestacionarios como los del mercado de divisas, donde las estrategias de reversión a la media han sido rentables a lo largo de los años.

Cuantificaremos nuestro enfoque utilizando Bandas de Bollinger de 100 períodos con una desviación de 2,0. El plan detallado es el siguiente:

• Compre cuando el último precio de cierre sea inferior a la banda inferior.
• Vender cuando el último precio de cierre sea superior a la banda superior.
• Cerrar la posición siempre que el precio cruce la banda media.
• Sólo una posición a la vez para evitar operar en exceso.
• Establezca el margen de stop loss en un 1 % del precio para evitar el riesgo de cola que es habitual en las estrategias de reversión a la media.

Tenemos previsto operar con pares de divisas en un marco temporal de 15 minutos, un marco temporal habitual que ofrece suficientes operaciones y garantiza una calidad aceptable.

Siempre comenzamos por definir primero las funciones necesarias, ya que esto facilita la codificación de la lógica comercial más adelante. En este caso, solo necesitamos codificar las funciones de compra y venta de la siguiente manera:

#include <Trade/Trade.mqh>
CTrade trade;
//+------------------------------------------------------------------+
//| Buy Function                                                     |
//+------------------------------------------------------------------+
void executeBuy(string symbol) {
       double ask = SymbolInfoDouble(symbol, SYMBOL_ASK);
       double lots=0.01;
       double sl = ask*(1-0.01);
       trade.Buy(lots,symbol,ask,sl);
}

//+------------------------------------------------------------------+
//| Sell Function                                                    |
//+------------------------------------------------------------------+
void executeSell(string symbol) {      
       double bid = SymbolInfoDouble(symbol, SYMBOL_BID);
       double lots=0.01;
       double sl = bid*(1+0.01);
       trade.Sell(lots,symbol,bid,sl);     
}

A continuación, inicializamos las variables globales y el inicializador aquí. Esto inicializa el número mágico para el asesor experto, así como el identificador de las Bandas de Bollinger que utilizaremos más adelante.

input int Magic = 0;
input int bbPeriod = 100;
input double d = 2.0;

int barsTotal = 0;
int handleMa;

//+------------------------------------------------------------------+
//| Initialization                                                   |
//+------------------------------------------------------------------+
int OnInit()
{   handleBb = iBands(_Symbol,PERIOD_CURRENT,bbPeriod,0,d,PRICE_CLOSE);  
    trade.SetExpertMagicNumber(Magic);
    return INIT_SUCCEEDED;
}

Por último, en la función OnTick(), utilizamos esto para asegurarnos de que solo procesamos la lógica de la operación cada barra en lugar de cada tick:

int bars = iBars(_Symbol,PERIOD_CURRENT);
  
if (barsTotal!= bars){
   barsTotal = bars;

Obtenemos los valores actuales de las Bandas de Bollinger creando matrices de búfer que pueden almacenar los valores actuales copiándolos desde el identificador.

double bbLower[], bbUpper[], bbMiddle[];
CopyBuffer(handleBb,UPPER_BAND,1,1,bbUpper);
CopyBuffer(handleBb,LOWER_BAND,1,1,bbLower);
CopyBuffer(handleBb,0,1,1,bbMiddle);

Esta comprobación recorre todas las posiciones abiertas actualmente en la cuenta de trading para comprobar si la posición ha sido abierta por este EA específico. Si ya hay una posición abierta por este EA, establecemos la variable NotInPosition en falso (false). Por cada posición abierta que haya vuelto a la banda media, la cerramos.

bool NotInPosition = true;
for(int i = 0; i<PositionsTotal(); i++){
    ulong pos = PositionGetTicket(i);
    string symboll = PositionGetSymbol(i);
    if(PositionGetInteger(POSITION_MAGIC) == Magic&&symboll== _Symbol){
       NotInPosition = false;
       if((PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY&&price>bbMiddle[0])
       ||(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL&&price<bbMiddle[0]))trade.PositionClose(pos);  
  }
}  

La lógica comercial final se llevará a cabo de la siguiente manera:

if(price<bbLower[0]&&NotInPosition) executeBuy(_Symbol);
if(price>bbUpper[0]&&NotInPosition) executeSell(_Symbol);

Compile el EA y diríjase al visualizador del probador de estrategias para comprobar si el EA funciona según lo esperado.

Una operación típica en el visualizador debería tener este aspecto:

A continuación, volvemos a MetaEditor y programamos los filtros del régimen.

En primer lugar, para la media móvil exponencial de 500 períodos, queremos que la estrategia de reversión a la media se alinee con la tendencia al entrar, como confirmación adicional. Añadimos estas líneas al EA original:

int handleMa;
handleMa = iMA(_Symbol,PERIOD_CURRENT,maPeriod,0,MODE_EMA,PRICE_CLOSE);
 
double ma[];
CopyBuffer(handleMa,0,1,1,ma);
    
if(price<bbLower[0]&&price>ma[0]&&NotInPosition) executeBuy(_Symbol);
if(price>bbUpper[0]&&price<ma[0]&&NotInPosition) executeSell(_Symbol);

 A continuación, codificamos la función para obtener el valor del filtro de Kalman:

//+------------------------------------------------------------------+
//| Kalman Filter Function                                           |
//+------------------------------------------------------------------+
double KalmanFilter(double price,double measurement_variance,double process_variance)
{
    // Prediction step (state does not change)
    double predicted_state = prev_state;
    double predicted_covariance = prev_covariance + process_variance;

    // Kalman gain calculation
    double kalman_gain = predicted_covariance / (predicted_covariance + measurement_variance);

    // Update step (incorporate new price observation)
    double updated_state = predicted_state + kalman_gain * (price - predicted_state);
    double updated_covariance = (1 - kalman_gain) * predicted_covariance;

    // Store updated values for next iteration
    prev_state = updated_state;
    prev_covariance = updated_covariance;

    return updated_state;
}

La función sigue el procedimiento recursivo como se muestra en este diagrama:

Para implementar el filtro de Kalman en el EA, añadimos estas líneas a la función OnTick():

double kalman = KalmanFilter(price,mv,pv);
if(price<bbLower[0]&&price>kalman&&NotInPosition) executeBuy(_Symbol);
if(price>bbUpper[0]&&price<kalman&&NotInPosition) executeSell(_Symbol);

El filtro de Kalman funciona actualizando continuamente su estimación del precio real, suavizando el ruido y adaptándose a los movimientos de los precios a lo largo del tiempo. Básicamente actúa como un predictor de precios. Cuando el precio cae por debajo de la banda inferior de las Bandas de Bollinger, indica que el mercado está sobrevendido y se espera que vuelva a la media. Aquí utilizamos el filtro de Kalman como confirmación de la inversión. En el escenario de sobreventa, si el precio es más alto que la estimación de Kalman, sugiere que el precio ya ha mostrado signos de un potencial movimiento ascendente. En el escenario de venta, ocurre lo contrario.

Sin embargo, aunque el promedio móvil también es un filtro de régimen común, su propósito es ligeramente diferente al del filtro de Kalman. Los promedios móviles sirven como indicador de tendencia, y la posición del precio en relación con la media móvil señala la dirección de la tendencia actual.

El código completo es el siguiente:

#include <Trade/Trade.mqh>
CTrade trade;

input double mv = 10;
input double pv = 1.0;
input int Magic = 0;
input int bbPeriod = 100;
input double d = 2.0;
input int maPeriod = 500;

double prev_state;       // Previous estimated price
double prev_covariance = 1;  // Previous covariance (uncertainty)
int barsTotal = 0;
int handleMa;
int handleBb;

//+------------------------------------------------------------------+
//| Initialization                                                   |
//+------------------------------------------------------------------+
int OnInit()
{   handleMa = iMA(_Symbol,PERIOD_CURRENT,maPeriod,0,MODE_EMA,PRICE_CLOSE);
    handleBb = iBands(_Symbol,PERIOD_CURRENT,bbPeriod,0,d,PRICE_CLOSE);
    prev_state = iClose(_Symbol,PERIOD_CURRENT,1);  
    trade.SetExpertMagicNumber(Magic);
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Deinitializer function                                           |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
  }

//+------------------------------------------------------------------+
//| OnTick Function                                                  |
//+------------------------------------------------------------------+
void OnTick()
{
  int bars = iBars(_Symbol,PERIOD_CURRENT);
  
  if (barsTotal!= bars){
     barsTotal = bars;
     bool NotInPosition = true;
     double price = iClose(_Symbol,PERIOD_CURRENT,1); 
     double bbLower[], bbUpper[], bbMiddle[];
     double ma[];
     double kalman = KalmanFilter(price,mv,pv);
     
     CopyBuffer(handleMa,0,1,1,ma);
     CopyBuffer(handleBb,UPPER_BAND,1,1,bbUpper);
     CopyBuffer(handleBb,LOWER_BAND,1,1,bbLower);
     CopyBuffer(handleBb,0,1,1,bbMiddle);
     
     for(int i = 0; i<PositionsTotal(); i++){
         ulong pos = PositionGetTicket(i);
         string symboll = PositionGetSymbol(i);
         if(PositionGetInteger(POSITION_MAGIC) == Magic&&symboll== _Symbol){
            NotInPosition = false;
            if((PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY&&price>bbMiddle[0])
            ||(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL&&price<bbMiddle[0]))trade.PositionClose(pos);  
      }
    }  
    
     if(price<bbLower[0]&&price>kalman&&NotInPosition) executeBuy(_Symbol);
     if(price>bbUpper[0]&&price<kalman&&NotInPosition) executeSell(_Symbol);
    }
}

//+------------------------------------------------------------------+
//| Kalman Filter Function                                           |
//+------------------------------------------------------------------+
double KalmanFilter(double price,double measurement_variance,double process_variance)
{
    // Prediction step (state does not change)
    double predicted_state = prev_state;
    double predicted_covariance = prev_covariance + process_variance;

    // Kalman gain calculation
    double kalman_gain = predicted_covariance / (predicted_covariance + measurement_variance);

    // Update step (incorporate new price observation)
    double updated_state = predicted_state + kalman_gain * (price - predicted_state);
    double updated_covariance = (1 - kalman_gain) * predicted_covariance;

    // Store updated values for next iteration
    prev_state = updated_state;
    prev_covariance = updated_covariance;

    return updated_state;
}

//+------------------------------------------------------------------+
//| Buy Function                                                     |
//+------------------------------------------------------------------+
void executeBuy(string symbol) {
       double ask = SymbolInfoDouble(symbol, SYMBOL_ASK);
       double lots=0.01;
       double sl = ask*(1-0.01);
       trade.Buy(lots,symbol,ask,sl);
}

//+------------------------------------------------------------------+
//| Sell Function                                                    |
//+------------------------------------------------------------------+
void executeSell(string symbol) {      
       double bid = SymbolInfoDouble(symbol, SYMBOL_BID);
       double lots=0.01;
       double sl = bid*(1+0.01);
       trade.Sell(lots,symbol,bid,sl);     
} 

Para cambiar el filtro del régimen, simplemente ajuste los criterios finales de compra/venta.

Análisis estadístico

Compile el EA y vaya a la terminal MetaTrader 5, en la parte superior izquierda, haga clic en Ver->Símbolos->Forex y seleccione "Mostrar símbolo" para todos los pares principales y secundarios. Esto los coloca en su lista de vigilancia del mercado para un análisis posterior del mismo.

A continuación, vamos al Probador de estrategias y realizamos una prueba retrospectiva de la estrategia utilizando datos de los últimos 3 años. Esto nos ayudará a hacernos una idea de si los filtros del régimen mejoran la rentabilidad de la mayoría de los pares de divisas con los que podríamos operar.

Por supuesto, el número de operaciones filtradas depende de los parámetros de los indicadores. En este estudio, utilizamos valores de parámetros comúnmente aplicados que filtran un número similar de operaciones: una media móvil exponencial de 500 períodos y una varianza de medición de 10 y una varianza de proceso de 1 para el filtro de Kalman. Se recomienda a los lectores que ajusten los parámetros para obtener los resultados más eficaces.

Primero probamos el resultado sin filtros de régimen como referencia. Esperamos que, en promedio, el EA con filtros de régimen supere a la mayoría de los resultados de referencia.

El resultado de los pares de divisas con mejor rendimiento muestra algo así:

Observamos que, en promedio, la estrategia ha ejecutado más de 800 operaciones en los últimos tres años para cada par, lo que proporciona suficientes muestras para implicar generalidad en las conclusiones. La distribución se encuentra principalmente dispersa en torno a un factor de beneficio de entre 0,8 y 1,1, lo cual es aceptable, pero ningún par supera el factor de beneficio de 1,1 ni la marca de 1 en el índice de Sharpe. En general, la estrategia básica funciona con muchos pares de divisas en los últimos años, pero la rentabilidad no es especialmente impresionante. Ten esto en cuenta al compararlo con el rendimiento cuando se aplican filtros.

A continuación, realizamos una prueba retrospectiva de la estrategia con el filtro de media móvil incluido. Aquí están los resultados:

Vemos que, al utilizar el filtro de media móvil, hemos filtrado aproximadamente el 70 % de las operaciones originales, dejando unas 250 operaciones para cada par. Además, las operaciones filtradas son, en promedio, de mayor calidad en comparación con la referencia. La mayoría de los pares de divisas oscilan entre un factor de beneficio de 0,9 y 1,2, y el par con mejor rendimiento tiene un factor de beneficio de 1,33 y un ratio de Sharpe de 2,34. Esto sugiere que el uso de la media móvil como filtro ha mejorado en general la rentabilidad de esta estrategia clásica de reversión a la media.

Ahora, abordemos el tema tabú y veamos cómo funciona la estrategia con el filtro de Kalman.

El filtro de Kalman filtró aproximadamente el 60 % de las operaciones originales, dejando unas 350 operaciones para cada par. A partir de la distribución, vemos que la mayoría de los factores de rentabilidad se sitúan entre 0,85 y 1,2, lo que es similar al rendimiento medio móvil y mejor que el rendimiento de referencia. Además, teniendo en cuenta el número total de pares de divisas con un factor de beneficio superior a 1,0 y un factor de beneficio superior a 1,2, podemos concluir que tanto la media móvil como el filtro de Kalman son similares en cuanto a la mejora de la calidad media de las operaciones para esta estrategia. El filtro de Kalman no es superior a la media móvil en este escenario, lo que sugiere que la complejidad no siempre se traduce en un mejor rendimiento.

Mencionamos que el uso del filtro de Kalman difiere ligeramente del uso de la media móvil en términos de lógica de filtrado. Sin embargo, en este caso, parecen funcionar de manera similar en cuanto a filtrar las malas operaciones. Para investigar si están filtrando operaciones similares, analizaremos las diferencias entre sus operaciones filtradas para determinar si el efecto del filtro de Kalman es simplemente el mismo que el de la EMA.

A modo de referencia, elegiremos el par de divisas AUDUSD, ya que ha sido el par con mejor rendimiento en las dos condiciones mencionadas anteriormente.

El resultado de la prueba retrospectiva de la referencia:

El resultado de la prueba retrospectiva del filtro de media móvil exponencial:

El resultado del filtro de Kalman:

Lo primero que podemos observar es que la tasa de ganancias de la versión de media móvil es significativamente mayor que la de la referencia o la versión de Kalman, mientras que su ganancia media es menor y su pérdida media es mayor que las demás. Esto ya sugiere que la versión de media móvil está realizando operaciones muy diferentes a las de la versión Kalman. Para investigar más a fondo, obtenemos el informe de Excel de la prueba retrospectiva haciendo clic con el botón derecho del ratón en la página de resultados de la prueba retrospectiva:

Para cada informe, anotamos el número de fila del signo «Deals»:

A continuación, pasamos a Python o Jupyter Notebook. Copiamos y pegamos el siguiente código, cambiamos el número skiprow por el número de fila «Deals» de cada informe de Excel y ya está.

import pandas as pd
import matplotlib.pyplot as plt
from matplotlib_venn import venn3
df1 = pd.read_excel("baseline.xlsx", skiprows=1805)
df2 = pd.read_excel("ma.xlsx", skiprows =563 )
df3 = pd.read_excel("kalman.xlsx",skiprows = 751)
df1 = df1[['Time']][1:-1]
df1 = df1[df1.index % 2 == 0]  # Filter for rows with odd indices
df2 = df2[['Time']][1:-1]
df2 = df2[df2.index % 2 == 0]
df3 = df3[['Time']][1:-1]
df3 = df3[df3.index % 2 == 0]

# Convert "Time" columns to datetime
df1['Time'] = pd.to_datetime(df1['Time'])
df2['Time'] = pd.to_datetime(df2['Time'])
df3['Time'] = pd.to_datetime(df3['Time'])

# Find intersections
set1 = set(df1['Time'])
set2 = set(df2['Time'])
set3 = set(df3['Time'])

# Create the Venn diagram
venn_labels = {
    '100': len(set1 - set2 - set3),  # Only in df1
    '010': len(set2 - set1 - set3),  # Only in df2
    '001': len(set3 - set1 - set2),  # Only in df3
    '110': len(set1 & set2 - set3),  # In df1 and df2
    '011': len(set2 & set3 - set1),  # In df2 and df3
    '101': len(set1 & set3 - set2),  # In df1 and df3
    '111': len(set1 & set2 & set3)   # In all three
}

# Plot the Venn diagram
plt.figure(figsize=(8, 8))
venn3(subsets=venn_labels, set_labels=('Baseline', 'EMA', 'Kalman'))
plt.title("Venn Diagram of Time Overlap")
plt.show()

La lógica de este código consiste básicamente en almacenar los tiempos de salida de posición en tres marcos de datos para cada versión, omitiendo filas y seleccionando filas con índices pares. A continuación, almacenamos cada marco de datos en un conjunto y obtenemos el diagrama de Venn comparando si los tiempos se superponen. El gráfico mostrará el número de operaciones en cada región, separadas por diferentes colores. Tenga en cuenta que ni siquiera la referencia contendrá todas las operaciones que tienen las versiones EMA y Kalman, ya que hemos configurado la estrategia para operar solo una vez por vez, lo que hace que se pierdan algunas operaciones que tienen las otras versiones.

Aquí está el diagrama de Venn resultante:

Al observar el área donde se superponen Kalman y MA, encontramos que, de los cientos de operaciones que realizó cada versión, solo 71 fueron iguales. Esto sugiere que los efectos de filtrado de estos dos son muy diferentes, a pesar de filtrar un número similar de operaciones de la estrategia original. Esto enfatiza aún más la importancia de estudiar y utilizar el filtro de Kalman, ya que proporciona una opción de filtrado única que difiere de los filtros de tendencia comunes.

Conclusión

En este artículo, hemos presentado un algoritmo recursivo avanzado para el trading algorítmico denominado filtro de Kalman. Comenzamos explicando sus mecanismos e implementaciones, proporcionando visualizaciones y fórmulas. A continuación, repasamos todo el proceso de desarrollo de una estrategia de reversión a la media en Forex y la implementación del filtro de Kalman en MQL5. Por último, realizamos diversos análisis estadísticos, incluyendo análisis de mercado, pruebas retrospectivas y comparaciones superpuestas, para evaluar su capacidad de filtrado en comparación con la media móvil y la referencia.

En el comercio real, el filtro de Kalman es ampliamente utilizado por las principales instituciones de comercio cuantitativo, pero sigue siendo menos conocido en el ámbito del comercio minorista. El objetivo de este artículo es proporcionar información y aplicaciones prácticas a la comunidad MQL5, ofreciendo un enfoque para evaluar la capacidad de filtrado del filtro de Kalman, de modo que pueda integrarse mejor en el desarrollo de estrategias futuras. Se anima a los lectores a que prueben este sistema por sí mismos y lo incorporen a su propio arsenal de trading.

Tabla de archivos

Nombre del archivo	Uso de archivo
Kalman visualizations.ipynb	El código Python para las visualizaciones utilizadas en este artículo.
MR-Kalman.mq5	El código del asesor experto.