Estrategia dinámica de línea central de pérdida de parada de ATR

El autor:¿ Qué pasa?, Fecha: 2023-10-16 16:20:06
Las etiquetas:

Resumen general

Esta estrategia utiliza una función de regresión lineal y el método de mínimos cuadrados para calcular un canal de precios, compuesto por dos líneas verdes y rojas.

Estrategia lógica

La estrategia calcula la línea central xLG usando regresión lineal con longitud 25 y desplazamiento 5. Luego toma el 6% por encima y por debajo de la línea central como rango de canal, con xLG1r como la línea superior y xLG1s como la línea inferior.

Cuando el precio está por encima de xLG1r, va largo. Cuando el precio está por debajo de xLG1s, va corto. Registra el último tiempo largo y corto. Se genera una señal larga cuando el último tiempo largo es mayor que el último tiempo corto. Se genera una señal corta cuando el último tiempo corto es mayor que el último tiempo largo.

El stop loss dinámico de ATR utiliza un período de ATR de 1 y un multiplicador de 2. Para las operaciones largas, el stop loss es el precio de cierre menos el multiplicador del valor de ATR.

Análisis de ventajas

Utiliza el canal de regresión lineal para rastrear las tendencias a largo plazo
La pérdida de parada basada en ATR se ajusta dinámicamente para evitar que las paradas sean demasiado anchas o demasiado ajustadas
Las señales de ruptura de precios ayudan a evitar señales falsas

Riesgos y mejoras

Los parámetros del canal de regresión necesitan optimización, el rango actual puede ser demasiado estrecho
El multiplicador ATR también necesita pruebas para encontrar el parámetro óptimo
Considere la posibilidad de añadir una confirmación de fuga para evitar fallas.

Direcciones de optimización

Prueba diferentes períodos de regresión para encontrar mejores parámetros
Pruebe diferentes períodos ATR y multiplicadores de pérdida de parada
Añadir confirmación adicional sobre las señales de ruptura, como la ruptura de volumen

Conclusión

Esta estrategia combina múltiples técnicas como el seguimiento de tendencias, paradas dinámicas y señales de ruptura para crear un sistema de seguimiento de tendencias adaptativo.

/*backtest
start: 2023-01-01 00:00:00
end: 2023-06-24 00:00:00
period: 4h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
// Thanks to HPotter for the original code for Center of Gravity Backtest
strategy("Center of Gravity BF 🚀", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.15)

/////////////// 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

///////////// Center of Gravity /////////////
Length = input(25, minval=1)
m = input(5, minval=0)
Percent = input(6, minval=0, title="COG %")

xLG = linreg(close, Length, m)
xLG1r = xLG + ((close * Percent) / 100)
xLG1s = xLG - ((close * Percent) / 100)

pos = 0.0
pos := iff(close > xLG1r, 1, iff(close < xLG1s, -1, nz(pos[1], 0))) 
possig = iff(pos == 1, 1, iff(pos == -1, -1, pos))

/////////////// Srategy ///////////////
long = possig == 1 
short = possig == -1 

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

/////////////// Dynamic ATR Stop Losses ///////////////
atrLkb = input(1, minval=1, title='ATR Stop Period')
atrMult = input(2, step=0.25, title='ATR Stop Multiplier') 
atr1 = atr(atrLkb)

longStop = 0.0
longStop :=  short_signal ? na : long_signal ? close - (atr1 * atrMult) : longStop[1]
shortStop = 0.0
shortStop := long_signal ? na : short_signal ? close + (atr1 * atrMult) : shortStop[1]

/////////////// Execution ///////////////
if testPeriod()
    strategy.entry("Long",  strategy.long, when=long)
    strategy.entry("Short", strategy.short, when=short)
    strategy.exit("Long SL", "Long", stop=longStop, when=since_longEntry > 0)
    strategy.exit("Short SL", "Short", stop=shortStop, when=since_shortEntry > 0)

/////////////// Plotting ///////////////
plot(xLG1r, color=color.lime, title="LG1r")
plot(xLG1s, color=color.red, title="LG1s")
plot(strategy.position_size <= 0 ? na : longStop, title="Long Stop Loss", color=color.yellow, style=plot.style_circles, linewidth=1)
plot(strategy.position_size >= 0 ? na : shortStop, title="Short Stop Loss", color=color.orange, style=plot.style_circles, linewidth=1)
bgcolor(strategy.position_size > 0 ? color.lime : strategy.position_size < 0 ? color.red : color.white, transp=90)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=60)

Más.