Stratégie d'inversion de tendance quotidienne

Auteur:ChaoZhang est là., Date: le 22 février 2024 16:22:28
Les étiquettes:

Résumé

La Super Trend Daily Reversal Strategy est une stratégie de trading quantitative qui utilise l'indicateur de Super Trend pour déterminer les tendances du marché, combine la percée de prix et la plage moyenne vraie pour calculer le stop loss, et utilise l'indicateur de taux de variation de prix pour filtrer les signaux de Super Trend.

La logique de la stratégie

L'indicateur de Super Trend est basé sur la moyenne réelle (ATR) et peut déterminer plus clairement la direction des tendances du marché.

La stratégie utilise l'indicateur de taux de variation de prix (ROC) pour filtrer l'indicateur de Super Trend afin d'éviter les signaux non valides. Ne participez aux signaux de Super Trend que lorsque la volatilité des prix est importante, sinon ne participez pas.

Pour le stop loss, la stratégie fournit deux méthodes de stop loss: pourcentage de stop loss fixe et stop loss adaptatif basé sur l'ATR.

Les conditions d'entrée sont un renversement de l'indicateur Super Trend et l'indicateur de taux de variation de prix passe le filtre. Les conditions de sortie sont que Super Trend inverse à nouveau ou franchit la ligne de stop loss. La stratégie adhère au principe de suivi de la tendance et ne permet qu'une position dans chaque direction.

Analyse des avantages

L'avantage majeur de cette stratégie est que l'indicateur Super Trend a une plus grande clarté et stabilité dans le jugement de la direction de la tendance par rapport aux moyennes mobiles ordinaires, avec moins de bruit.

Le mécanisme d'arrêt de perte adaptatif ATR permet également à la stratégie de s'adapter à un environnement de marché plus large.

D'après les résultats des tests, cette stratégie fonctionne exceptionnellement bien sur un marché haussier.

Analyse des risques

Le risque principal de cette stratégie est une mauvaise appréciation de l'inversion de tendance, qui peut manquer les signaux d'inversion ou générer des signaux d'inversion inutiles.

En outre, un stop loss trop large peut également entraîner des pertes plus importantes.

Pour faire face à ces risques, la période de calcul de l'ATR peut être raccourcie de manière appropriée ou le multiplicateur d'arrêt des pertes ATR ajusté.

Directions d'optimisation

La stratégie peut être optimisée dans les aspects suivants:

Ajuster les paramètres de l'indicateur Super Trend afin d'optimiser la période ATR et les multiples ATR afin de rendre la ligne Super Trend plus lisse.
Ajuster les paramètres de l'indicateur du taux de variation des prix afin d'optimiser la période et le seuil du taux de variation afin de réduire les faux signaux.
Essayez différents mécanismes d'arrêt de perte tels que les arrêts de trailing, ou optimisez l'amplitude d'arrêt de perte des arrêts fixes.
Ajouter des indicateurs de jugement supplémentaires pour déterminer les principaux supports/résistances et éviter une mauvaise appréciation des renversements de tendance.
Évaluer les paramètres et les effets sur différents produits afin de trouver la combinaison optimale de paramètres.
Effectuer l'optimisation des tests de retour pour trouver les meilleurs paramètres.

Conclusion

Dans l'ensemble, la stratégie d'inversion quotidienne de la super tendance est une stratégie de suivi de tendance relativement stable et fiable. Elle combine l'indicateur de super tendance et l'indicateur de taux de variation de prix pour le filtrage, ce qui peut identifier efficacement la direction des tendances à moyen et long terme. Le mécanisme d'arrêt de perte adaptatif ATR lui permet également de s'adapter à la plupart des environnements du marché.

/*backtest
start: 2024-01-22 00:00:00
end: 2024-02-21 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("Super Trend Daily 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 ///////////////
_1 = 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

///////////// Super Trend /////////////
_2 = input(false,  "══════ Super Trend ══════")
length = input(title="ATR Period", type=input.integer, defval=3)
mult = input(title="ATR Multiplier", type=input.float, step=0.1, defval=1.3)

atr = mult * atr(length)

longStop = hl2 - atr
longStopPrev = nz(longStop[1], longStop)
longStop :=  close[1] > longStopPrev ? max(longStop, longStopPrev) : longStop

shortStop = hl2 + atr
shortStopPrev = nz(shortStop[1], shortStop)
shortStop := close[1] < shortStopPrev ? min(shortStop, shortStopPrev) : shortStop

dir = 1
dir := nz(dir[1], dir)
dir := dir == -1 and close > shortStopPrev ? 1 : dir == 1 and close < longStopPrev ? -1 : dir

///////////// Rate Of Change ///////////// 
_3 = input(false,  "══════ Rate of Change ══════")
source = close
roclength = input(30, "ROC Length",  minval=1)
pcntChange = input(6, "ROC % Change", 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 = dir == 1 and dir[1] == -1 and isMoving()
short = dir == -1 and dir[1] == 1 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])

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 ///////////////
_4 = input(false,  "════════ Stop Loss ═══════")
SL_type = input("Fixed", options=["Fixed", "ATR Derived"], title="Stop Loss Type")
sl_inp = input(6.0, title='Fixed Stop Loss %') / 100
atrLkb = input(20, minval=1, title='ATR Stop Period')
atrMult = input(1.5, step=0.25, title='ATR Stop Multiplier') 
atr1 = atr(atrLkb)

longStop1 = 0.0
longStop1 :=  short_signal ? na : long_signal ? close - (atr1 * atrMult) : longStop1[1]
shortStop1 = 0.0
shortStop1 := long_signal ? na : short_signal ? close + (atr1 * atrMult) : shortStop1[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 = SL_type == "Fixed" ? long_sl : longStop1, when=since_longEntry > 0)
    strategy.exit("S SL", "S", stop = SL_type == "Fixed" ? short_sl : shortStop1, when=since_shortEntry > 0)

/////////////// Plotting /////////////// 
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)
bgcolor(isMoving() ? dir == 1 ? color.lime : color.red : color.white , transp=80)

Plus de

2019 FMZ - Tous les droits réservés