Stratégie de suivi de tendance Momentum Turtle


Date de création: 2023-11-23 11:53:27 Dernière modification: 2023-11-23 11:53:27
Copier: 0 Nombre de clics: 630
1
Suivre
1621
Abonnés

Stratégie de suivi de tendance Momentum Turtle

Aperçu

La stratégie de suivi de la tendance des marées dynamiques est une stratégie de suivi de la tendance basée sur les règles de négociation des marées. Elle utilise des indicateurs de marée pour identifier les tendances et, en combinaison avec des indicateurs de la dynamique, filtre une partie du bruit des transactions. Le principal avantage de cette stratégie est la possibilité de saisir des tendances de prix fortes et de réaliser des gains supplémentaires.

Principe de stratégie

Cette stratégie utilise le système de rupture de base de l’indicateur du tsunami pour déterminer la direction de la tendance. Plus précisément, lorsque le prix de clôture est supérieur au plus haut des 20 derniers jours, c’est un signal positif.

Pour filtrer une partie du bruit des transactions, la stratégie a ajouté un facteur de dynamique. Si les fluctuations de prix sont inférieures à 5 ATR, la stratégie n’entre pas dans les transactions. Cela évite les pertes de transactions mineures causées par l’excès d’aérodynamisme.

Après avoir ouvert la position, la stratégie utilise la valeur N du principe de la pirogue pour franchir la sortie. Ce système établit un point de perte basé sur le prix le plus élevé et le prix le plus bas des 20 derniers jours. Par exemple, le prix de perte multiple est l’ATR de 2 N au-dessous du prix le plus bas des 20 derniers jours.

Analyse des avantages

Le plus grand avantage de cette stratégie est qu’elle combine le suivi de la tendance et la gestion du volume. Le système de négociation de la tortue peut saisir avec précision la tendance des prix à moyen terme et éviter d’être dérangé par le bruit du marché. L’ajout du filtre de volume ATR peut réduire encore plus le nombre de transactions inutiles, ce qui augmente considérablement la marge de profit.

Plus précisément, cette stratégie présente les avantages suivants:

  1. L’indicateur du tsunami est un indicateur de tendance précis et fiable qui permet de suivre efficacement les tendances à moyen terme.
  2. Les mécanismes de filtrage dynamique réduisent les transactions inutiles et évitent les pertes sur le nombre de transactions
  3. Des mesures de contrôle des risques sont en place pour arrêter les pertes en temps opportun si la tendance se retourne
  4. Dans l’ensemble, les paramètres de la stratégie ont été optimisés et sont en parfaite adéquation avec les principes de l’OMC.

Analyse des risques

Bien qu’il y ait beaucoup de possibilités d’optimisation dans cette stratégie, elle comporte des risques potentiels à éviter:

  1. Il n’est pas possible de résoudre le problème de l’excès de volatilité des positions à long terme. Le dimensionnement de la position du système d’ancrage ne prend pas en compte les facteurs de volatilité, ce qui peut entraîner des pertes individuelles excessives.
  2. Lors d’une reprise brutale, le prix de stop-loss peut être dépassé, entraînant des pertes supérieures aux attentes.
  3. Il n’y a pas d’objectif de rendement et il est facile de détenir des positions en trop, ce qui entraîne un risque de plagiat.

Direction d’optimisation

D’après l’analyse des risques ci-dessus, la stratégie présente les principales améliorations suivantes:

  1. On peut envisager d’ajouter des algorithmes de position dynamiques ajustés au taux de volatilité, ce qui permet de réduire activement la position lorsque les pertes de détention atteignent un certain niveau.
  2. Ajout d’un mécanisme de retour en arrière, en pensant à la réduction de la position ou à la reprise de la position vide lors de la formation d’une forme similaire à la tête, aux épaules et aux deux sommets.
  3. Augmentation de l’objectif de profit. Lorsque les bénéfices cumulés atteignent un certain pourcentage du total des actifs du compte, le remboursement de la position peut être partiellement réduit.

Résumer

La stratégie de suivi de la tendance des coulées dynamiques est une stratégie de suivi de la tendance des lignes moyennes et longues très pratique dans l’ensemble. Elle combine à la fois le filtrage des chocs de l’indicateur de jugement de tendance des coulées et de l’indicateur ATR, ce qui permet de bloquer efficacement les tendances de prix fortes. De plus, le contrôle des risques et l’optimisation des paramètres de la stratégie sont également très bien positionnés, ce qui peut réduire les retraits. L’efficacité de cette stratégie peut être encore améliorée si l’on continue à ajouter des modules tels que la gestion de position dynamique, le mécanisme de retournement et les objectifs de profit.

Code source de la stratégie
/*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)