Estrategia de seguimiento de tendencias de Momentum Turtle

El autor:¿ Qué pasa?, Fecha: 2023-11-23 11:53:27
Las etiquetas:

Resumen general

La estrategia de seguimiento de tendencias de tortuga de momento es una estrategia de seguimiento de tendencias basada en las reglas de comercio de tortuga. Utiliza los indicadores de tortuga para identificar tendencias y combina métricas de momento para filtrar algunas operaciones de ruido. La principal ventaja de esta estrategia es la capacidad de capturar fuertes tendencias de precios y lograr rendimientos excesivos.

Principio de la estrategia

Esta estrategia utiliza el sistema de ruptura en los Indicadores de Tortuga para determinar la dirección de la tendencia. Específicamente, cuando el precio de cierre es mayor que el precio más alto en los últimos 20 días, es una señal alcista y va largo; cuando el precio de cierre es menor que el precio más bajo en los últimos 20 días, es una señal bajista y la estrategia va corta.

Para filtrar algunas operaciones de ruido, esta estrategia también incorpora un factor de impulso. Si la fluctuación del precio es inferior a 5 ATR, la estrategia no entrará en operaciones. Esto evita las pérdidas por las whipssaws en los mercados laterales.

Después de abrir posiciones, la estrategia utiliza las salidas de N-breakout en las reglas originales de Turtle para el stop loss. Este sistema establece el stop loss basado en los precios más altos y más bajos en los últimos 20 días. Por ejemplo, el stop loss para posiciones largas sería de 2N ATR por debajo del mínimo en los últimos 20 días. La toma de ganancias para esta estrategia es simple: se establece en el 10% del valor total de la cuenta.

Análisis de ventajas

La mayor ventaja de esta estrategia es que combina tanto el seguimiento de tendencias como la gestión del impulso. El sistema Turtle puede capturar con precisión las tendencias a mediano plazo en los precios sin ser perturbado por el ruido del mercado. El filtro de impulso ATR adicional reduce aún más el número innecesario de operaciones, aumentando así enormemente el potencial de ganancia.

En concreto, esta estrategia tiene las siguientes fortalezas:

Los indicadores de tortuga identifican con precisión las tendencias y rastrean las tendencias a medio plazo.
Los filtros de impulso reducen las operaciones innecesarias y evitan perder en la frecuencia de las operaciones.
Las medidas sólidas de control de riesgos permiten detener las pérdidas oportunamente cuando las tendencias se invierten.
En general, la estrategia se alinea bien con los principios originales de Turtle.

Análisis de riesgos

Aunque existe un gran potencial para una mayor optimización, la estrategia también conlleva algunos riesgos a evitar:

No tiene en cuenta las fluctuaciones excesivas de las tenencias a largo plazo.
Los precios de stop loss corren el riesgo de que se tomen durante inversiones extremas, lo que conduce a pérdidas más altas de lo esperado.
La ausencia de objetivos de beneficios implica una tenencia excesiva y el riesgo de mantener posiciones submarinas.

Oportunidades de mejora

Basándose en los riesgos anteriores, las principales oportunidades de optimización incluyen:

Consideremos modelos dinámicos de posicionamiento ajustados a la volatilidad para reducir el tamaño de las operaciones perdedoras.
Añadir mecanismos de inversión para reducir o revertir los patrones de topping como cabeza y hombros o tops dobles.
Añadir objetivos de ganancia para que las participaciones se reduzcan cuando las ganancias acumuladas alcanzan un % del capital total.

Conclusión

En general, la estrategia de seguimiento de tendencias de Momentum Turtle es un sistema robusto para el seguimiento de tendencias a mediano y largo plazo. Combina indicadores de tortuga para la identificación de tendencias y filtros ATR para la gestión de volatilidad para capturar tendencias fuertes. Además, los controles de riesgo y el ajuste de parámetros son sólidos para reducir las reducciones.

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

//@version=4
strategy("Heiken Ashi 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(2029, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)

testPeriod() => true

///////////// HA /////////////
haTicker = heikinashi(syminfo.tickerid)
haOpen = security(haTicker, "D", open)
haHigh = security(haTicker, "D", high)
haLow = security(haTicker, "D", low)
haClose = security(haTicker, "D", close)

///////////// Rate Of Change ///////////// 
source = close
roclength = input(30, minval=1)
pcntChange = input(7.0, 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 = haOpen < haClose and isMoving()
short = haOpen > haClose 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("L",  strategy.long, when=long)
    strategy.entry("S", strategy.short, when=short)
    strategy.exit("L SL", "L", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
    strategy.exit("S SL", "S", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)

/////////////// Plotting ///////////////
plotcandle(haOpen, haHigh, haLow, haClose, title='HA Candles', color = haOpen < haClose ? color.lime : color.red)
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)

Más.