1. Carré
  2. Stratégie dynamique de ligne centrale ATR Stop Loss

Stratégie dynamique de ligne centrale ATR Stop Loss

Auteur:ChaoZhang est là., Date: 2023-10-16 16:20:06 Je suis désolé
Les étiquettes:

img

Résumé

Cette stratégie utilise une fonction de régression linéaire et la méthode des moindres carrés pour calculer un canal de prix, composé de deux lignes vertes et rouges.

La logique de la stratégie

La stratégie calcule la ligne centrale xLG en utilisant une régression linéaire avec une longueur de 25 et un décalage de 5. Ensuite, elle prend 6% au-dessus et au-dessous de la ligne centrale comme plage de canaux, avec xLG1r comme ligne supérieure et xLG1s comme ligne inférieure.

Lorsque le prix est supérieur à xLG1r, il va long. Lorsque le prix est inférieur à xLG1s, il va court. Il enregistre le dernier temps long et le dernier temps court. Un signal long est généré lorsque le dernier temps long est supérieur au dernier temps court. Un signal court est généré lorsque le dernier temps court est supérieur au dernier temps long.

Le stop loss dynamique ATR utilise une période ATR de 1 et un multiplicateur de 2. Pour les longs trades, le stop loss est le prix de clôture moins le multiplicateur de la valeur ATR. Pour les trades courts, le stop loss est le prix de clôture plus le multiplicateur de la valeur ATR.

Analyse des avantages

  • Utilise le canal de régression linéaire pour suivre les tendances à long terme
  • L'arrêt-perte basé sur ATR s'ajuste dynamiquement pour éviter que les arrêts ne soient trop larges ou trop serrés
  • Les signaux de rupture de prix aident à éviter les faux signaux

Risques et améliorations

  • Les paramètres du canal de régression doivent être optimisés, la plage actuelle peut être trop étroite
  • Le multiplicateur ATR doit également être testé pour trouver le paramètre optimal
  • Envisagez d'ajouter une confirmation sur l'évasion pour éviter les fausses évasions

Directions d'optimisation

  • Testez différentes longueurs de période de régression pour trouver de meilleurs paramètres
  • Essayez différentes périodes ATR et multiplicateurs de stop loss
  • Ajouter une confirmation supplémentaire sur les signaux de rupture, comme la rupture de volume

Conclusion

Cette stratégie combine plusieurs techniques telles que le suivi des tendances, les arrêts dynamiques et les signaux de rupture pour créer un système de suivi des tendances adaptatif.

/*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)
Plus de

2019 FMZ - Tous les droits réservés