Estrategia de ruptura de impulso

El autor:¿ Qué pasa?, Fecha: 2023-11-15 11:09:21
Las etiquetas:

Resumen general

La estrategia de ruptura de impulso es una estrategia de negociación cuantitativa que sigue las tendencias del mercado. Cálcula el indicador de impulso basado en precios históricos para determinar la tendencia y la fuerza de los movimientos de los precios del mercado, con el objetivo de capturar las tendencias a medio y largo plazo en el mercado.

Estrategia lógica

El núcleo de esta estrategia se basa en el indicador de impulso. El indicador de impulso es el precio de cierre del período actual menos el precio de cierre hace N períodos. Cuando el último cierre de la barra es mayor que hace N períodos, el impulso es positivo, lo que indica una tendencia al alza; cuando el último cierre de la barra es menor que hace N períodos, el impulso es negativo, lo que indica una tendencia a la baja.

La estrategia primero calcula el momento de 18 períodos, que es el cierre actual menos el cierre de hace 18 períodos, almacenado en mom0. Luego calcula el momento de 1 período de mom0, almacenado en mom1.

Cuando mom0>0 y mom1>0, se genera una señal larga, lo que indica un fuerte impulso al alza.

La estrategia registra el tiempo de las señales largas y cortas más recientes. Cuando el tiempo de la señal larga es más reciente que el tiempo de la señal corta, mantiene una posición larga. Cuando el tiempo de la señal corta es más reciente que el tiempo de la señal larga, mantiene una posición corta.

Análisis de ventajas

Las ventajas de esta estrategia incluyen:

La lógica es simple y fácil de entender, adecuada para principiantes en el comercio cuantitativo.
Los indicadores de impulso pueden capturar las tendencias y la fortaleza del mercado con tasas de ganancia relativamente altas cuando se rastrean las tendencias a medio y largo plazo.
El filtro de doble impulso ayuda a evitar pérdidas por fallas.
Añade posiciones después de la señal para establecer posiciones de tendencia y lograr rendimientos excedentes durante los mercados de tendencia.
La salida de stop loss oportuna controla el tamaño de la pérdida de una sola operación y evita grandes pérdidas por reversiones.

Análisis de riesgos

Algunos riesgos de esta estrategia a tener en cuenta:

Pueden considerar ampliar el rango de stop loss durante retrocesos a corto plazo en una tendencia alcista.
Las operaciones abiertas y cerradas frecuentes en mercados variados aumentan los costos de las comisiones y el deslizamiento.
Las tenencias continuadas en la dirección original después de la inversión de tendencia aumentan las pérdidas.
La configuración incorrecta de los parámetros conduce a señales faltantes o a la generación de señales falsas. Los parámetros deben ajustarse para diferentes mercados.

Direcciones de optimización

Algunas maneras de optimizar la estrategia:

Optimizar los parámetros de impulso ajustando el cálculo de la longitud de impulso en función del marco de tiempo y del mercado.
Añadir otros filtros de indicadores como MACD, KD para evitar pérdidas por inversiones de tendencia.
Optimizar la estrategia de stop loss ampliando las paradas en las tendencias y ajustando las paradas en los mercados que no están en tendencia.
Añadir reglas de dimensionamiento de posiciones para disminuir el tamaño en no tendencias y aumentar el tamaño en tendencias para obtener más ganancias.
Optimizar los parámetros por separado para diferentes productos para mejorar la adaptabilidad.
Incorporar algoritmos de aprendizaje automático para optimizar dinámicamente los parámetros.

Conclusión

La estrategia Momentum Breakout es un sistema intuitivo de seguimiento de tendencias. Puede capturar de manera efectiva las tendencias a medio y largo plazo y lograr buenas ganancias durante los mercados de tendencia. La gestión de riesgos a través de la optimización de pérdidas de parada y el uso de otros indicadores para juzgar la tendencia también son importantes. Con la optimización continua, esta estrategia puede desarrollarse en un sistema comercial cuantitativo estable que genere ganancias.

/*backtest
start: 2023-10-15 00:00:00
end: 2023-11-14 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("Momentum BF 🚀", overlay=true, precision=2, 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 ///////////////
_0 = input(false,  "════════ Test Period ═══════")
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

///////////// Momentum /////////////
_1 = input(false, "═══════ Momentum ══════")
length = input(18)
price = close

momentum(seria, length) =>
    mom = seria - seria[length]
    mom

mom0 = momentum(price, length)
mom1 = momentum(mom0, 1)

/////////////// Strategy /////////////// 
long = mom0 > 0 and mom1 > 0
short = mom0 < 0 and mom1 < 0

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])

since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1]) 
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1]) 

/////////////// Stop Losses Long ///////////////
_5 = input(false,  "═══════ Stop Loss L ══════")
SL_typel = input("Fixed", options=["Fixed", "ATR Derived"], title="Stop Loss Type")
sl_inpl = input(8.0, title='Fixed Stop Loss %') / 100
atrLkbl = input(20, minval=1, title='ATR Stop Period')
atrMultl = input(1.5, step=0.25, title='ATR Stop Multiplier') 
atr1l = atr(atrLkbl)

longStop1l = 0.0
longStop1l := short_signal ? na : long_signal ? close - (atr1l * atrMultl) : longStop1l[1]

slLongl = in_long_signal ? strategy.position_avg_price * (1 - sl_inpl) : na
long_sll = in_long_signal ? slLongl : na

/////////////// Stop Losses Short ///////////////
_6 = input(false, "═══════ Stop Loss S ══════")
SL_types = input("Fixed", options=["Fixed", "ATR Derived"], title="Stop Loss Type")
sl_inps = input(7.0, title='Fixed Stop Loss %') / 100
atrLkbs = input(20, minval=1, title='ATR Stop Period')
atrMults = input(1.5, step=0.25, title='ATR Stop Multiplier') 
atr1s = atr(atrLkbs)

shortStop1s = 0.0
shortStop1s := long_signal ? na : short_signal ? close + (atr1s * atrMults) : shortStop1s[1]

slShorts = strategy.position_avg_price * (1 + sl_inps)
short_sls = in_short_signal ? slShorts : na

_7 = input(false, "══════ Longs or Shorts ═════")
useLongs = input(true, title="Use Longs")
useShorts = input(true, title="Use Shorts")

/////////////// Execution ///////////////
if testPeriod()
    if useLongs
        strategy.entry("L", strategy.long, when=long)
        strategy.exit("L SL", "L", stop = SL_typel == "Fixed" ? long_sll : longStop1l, when=since_longEntry > 0)
    if useShorts
        strategy.exit("S SL", "S", stop = SL_types == "Fixed" ? short_sls : shortStop1s, when=since_shortEntry > 0)
        strategy.entry("S", strategy.short, when=short)
    if not useShorts
        strategy.close("L", when=short)
    if not useLongs
        strategy.close("S", when=long)

/////////////// Plotting /////////////// 
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=40)
p0 = plot(close)
p1 = plot(strategy.position_size <= 0 ? na : SL_typel == "Fixed" ? long_sll : longStop1l, title="Long Stop Loss", color=color.yellow, style=plot.style_linebr, linewidth=2)
p2 = plot(strategy.position_size >= 0 ? na : SL_types == "Fixed" ? short_sls : shortStop1s, title="Short Stop Loss", color=color.orange, style=plot.style_linebr, linewidth=2)
p3 = plot(strategy.position_size <= 0 ? na : strategy.position_avg_price, style=plot.style_linebr, title="Long Entry", color=color.green, linewidth=2)
p4 = plot(strategy.position_size >= 0 ? na : strategy.position_avg_price, style=plot.style_linebr, title="Short Entry", color=color.red, linewidth=2)
fill(p0, p3, color = color.lime, transp=60)
fill(p0, p4, color = color.red, transp=60)

Más.