Estrategia de negociación de decisiones con indicadores de momentum
ChaoZhang
Descripción general
La estrategia de trading de indicadores dinámicos es una estrategia de seguimiento de tendencias que utiliza un indicador de movimiento de dos índices y luego combina un indicador de la tasa de cambio de los precios para generar una señal de negociación. Cuando el indicador de movimiento sube, produce una señal múltiple; cuando el indicador de movimiento baja, produce una señal de falta.
Principio de estrategia
La estrategia utiliza el indicador de promedio móvil binario Decision Point oscillator para medir el movimiento. Primero se calcula la tasa de cambio diario de los precios, luego se utiliza una media móvil binaria de 31 días y 20 días de longitud para suavizar la tasa de cambio de precios, y finalmente se emite una señal de negociación con una media móvil plana de 9 días.
La estrategia también introdujo un indicador de la tasa de cambio de precios para evitar que se produzcan señales erróneas en el mercado de liquidación. En concreto, se calcula la tasa de cambio porcentual de los precios de los últimos 30 días para determinar si el mercado está activo a través de su media móvil. La señal de negociación solo se emite cuando el mercado está activo.
Análisis de las ventajas
Esta estrategia, combinada con un indicador de movimiento y un indicador de la tasa de cambio de precios, permite identificar con eficacia las tendencias a medio plazo y evitar el comercio frecuente en situaciones de agitación. En comparación con las estrategias de tendencias simples como el seguimiento de las medias móviles, puede reducir considerablemente la probabilidad de operaciones erróneas. Además, el control del riesgo establece un punto de parada para el control oportuno y efectivo de las pérdidas individuales.
Análisis de riesgos
La estrategia se basa en el BASE para el comercio de tendencias en líneas medianas y largas, y no puede capturar las fluctuaciones de precios a corto plazo. En situaciones extremas, los puntos de parada pueden ser superados y causar grandes pérdidas. Además, la configuración inadecuada de los parámetros también puede afectar la estrategia.
Para prevenir el riesgo, se puede ajustar adecuadamente el punto de parada y ampliar la amplitud de parada. También se puede cerrar temporalmente la estrategia en caso de una situación extrema, para evitar la probabilidad de que se rompa el límite. En cuanto al ajuste de parámetros, se debe realizar una retroalimentación detallada y elegir el parámetro óptimo.
Dirección de optimización
La estrategia puede ser optimizada en las siguientes direcciones:
La adición de otros indicadores de filtración, como el índice de volatilidad, puede evitar el comercio durante las fuertes fluctuaciones en el mercado.
La adición de modelos de aprendizaje automático, que ayudan a determinar la dirección y la intensidad de las tendencias, puede mejorar la precisión de la señal.
Prueba diferentes indicadores de dinámica, como el indicador de fuerza relativa, el oscilador estocástico, etc., para optimizar el tiempo de compra y venta.
Durante el funcionamiento en el disco duro, se combinan las características de la situación actual, los parámetros de ajuste dinámico y la búsqueda de la combinación óptima de parámetros.
Resumir
La estrategia de negociación del indicador de movimiento es una estrategia de seguimiento de tendencias sólida a medio y largo plazo. Combina el indicador de movimiento de la media de los dos índices y el indicador de la tasa de cambio de precios para identificar la tendencia y evitar el error de negociación. Al mismo tiempo, establece un punto de parada para controlar el riesgo. Si los parámetros se ajustan razonablemente y el efecto de retroalimentación es bueno, es adecuado para los inversores que buscan ganancias excedentarias a medio y largo plazo.
/*backtest
start: 2022-12-08 00:00:00
end: 2023-11-10 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("Decision BF", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)
/////////////// Time Frame ///////////////
testStartYear = input(2017, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)
testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)
testPeriod() => true
/////////////// Decision ///////////////
src = input(ohlc4, title="Source")
length1 = input(31, title="First Smoothing")
length2 = input(20, title="Second Smoothing")
siglength = input(9, title="Signal Smoothing")
fr = input(true, title="Fill Region")
calc_csf(src, length) =>
sm = 2.0 / length
csf = 0.0
csf := (src - nz(csf[1])) * sm + nz(csf[1])
csf
i = (src / nz(src[1], src)) * 100
pmol2 = calc_csf(i - 100, length1)
pmol = calc_csf(10 * pmol2, length2)
pmols = ema(pmol, siglength)
d = pmol - pmols
duml = plot(fr ? (d > 0 ? pmol : pmols) : na, style=plot.style_circles, color=color.yellow, linewidth=0, title="DummyL")
hc = d > 0 ? d > d[1] ? color.lime : color.green : d < d[1] ? color.red : color.orange
///////////// Rate Of Change /////////////
source = close
roclength = input(30, minval=1)
pcntChange = input(7, minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Strategy ///////////////
long = d > 0 and isMoving()
short = d < 0 and isMoving()
last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
sl_inp = input(2.0, title='Stop Loss %') / 100
tp_inp = input(5000.0, title='Take Profit %') / 100
take_level_l = strategy.position_avg_price * (1 + tp_inp)
take_level_s = strategy.position_avg_price * (1 - tp_inp)
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("Long", strategy.long, when=long)
strategy.entry("Short", strategy.short, when=short)
strategy.exit("L Ex", "Long", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
strategy.exit("S Ex", "Short", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
sigl = plot(false ? na : pmols, title="PMO Signal", color=color.gray, linewidth=2, title="Signal")
mdl = plot(false ? na : pmol, title="PMO", color=color.black, linewidth=2, title="PMO")
fill(duml, sigl, color.green, transp=20, title="PosFill")
fill(duml, mdl, color.red, transp=20, title="NegFill")
bgcolor(isMoving() ? long ? color.lime : short ? color.red : na : color.white, transp=70)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=50)