Stratégie de trading décisionnelle basée sur l'indicateur de momentum
ChaoZhang
Aperçu
La stratégie de trading basée sur la décision de l’indicateur de dynamique est une stratégie de suivi de la tendance. Elle utilise une moyenne mobile à deux indices pour construire un indicateur de dynamique, puis un indicateur de variation du taux de change des prix pour générer un signal de négociation.
Principe de stratégie
La stratégie utilise le Decision Point oscillator, un indicateur de moyenne mobile à deux indices, pour mesurer la dynamique. On calcule d’abord le taux de variation quotidien des prix, puis on lissue le taux de variation des prix avec des moyennes mobiles à deux indices de 31 jours et 20 jours, puis on envoie un signal de négociation avec une moyenne mobile à 9 jours.
La stratégie a également introduit des indicateurs de variation des prix pour éviter de produire de faux signaux dans le marché de la liquidation. Plus précisément, il s’agit de calculer le pourcentage de variation des prix sur les 30 derniers jours et de déterminer si le marché est actif à l’aide de sa moyenne mobile.
Analyse des avantages
Cette stratégie, combinée à un indicateur de dynamisme et à un indicateur de taux de variation des prix, permet d’identifier efficacement les tendances à moyen terme et d’éviter de négocier fréquemment dans des conditions de choc. Par rapport aux stratégies de tendance simples telles que le suivi des moyennes mobiles, elle réduit considérablement la probabilité d’une transaction erronée. De plus, le contrôle des risques impose des points d’arrêt, permettant un arrêt rapide et un contrôle efficace des pertes individuelles.
Analyse des risques
La stratégie est principalement basée sur la négociation de tendances à moyen et long terme et ne parvient pas à capturer les fluctuations de prix à court terme. En cas d’extrême situation, le point de rupture peut être franchi, ce qui entraîne des pertes importantes. De plus, une mauvaise configuration des paramètres peut également avoir un impact sur la stratégie.
Pour prévenir les risques, il est possible d’ajuster le point de rupture et d’élargir le seuil de rupture. Il est également possible d’arrêter temporairement la stratégie en cas de situation critique, afin d’éviter la probabilité de rupture du seuil de rupture.
Direction d’optimisation
Cette stratégie peut être optimisée dans les directions suivantes:
L’ajout d’autres indicateurs de filtrage, tels que les indicateurs de volatilité, permet d’éviter les transactions pendant les périodes de forte volatilité.
L’ajout de modèles d’apprentissage automatique qui aident à déterminer la direction et la force des tendances peut améliorer l’exactitude des signaux.
Essayez différents indicateurs dynamiques, tels que les indicateurs de force relative, l’oscillateur stochastique, etc., pour optimiser le moment d’achat et de vente.
Le processus de fonctionnement du disque dur, combiné avec les caractéristiques de l’évolution récente, ajuste dynamiquement les paramètres, poursuit la combinaison optimale de paramètres.
Résumer
L’indicateur de dynamique de décision est une stratégie de suivi de la tendance à moyen et long terme. Il combine l’indicateur de la tendance à moyenne mobile à deux indices et l’indicateur de la variation des prix pour identifier efficacement les tendances et éviter les erreurs de négociation.
/*backtest
start: 2022-12-08 00:00:00
end: 2023-11-10 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("Decision 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(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
/////////////// Decision ///////////////
src = input(ohlc4, title="Source")
length1 = input(31, title="First Smoothing")
length2 = input(20, title="Second Smoothing")
siglength = input(9, title="Signal Smoothing")
fr = input(true, title="Fill Region")
calc_csf(src, length) =>
sm = 2.0 / length
csf = 0.0
csf := (src - nz(csf[1])) * sm + nz(csf[1])
csf
i = (src / nz(src[1], src)) * 100
pmol2 = calc_csf(i - 100, length1)
pmol = calc_csf(10 * pmol2, length2)
pmols = ema(pmol, siglength)
d = pmol - pmols
duml = plot(fr ? (d > 0 ? pmol : pmols) : na, style=plot.style_circles, color=color.yellow, linewidth=0, title="DummyL")
hc = d > 0 ? d > d[1] ? color.lime : color.green : d < d[1] ? color.red : color.orange
///////////// Rate Of Change /////////////
source = close
roclength = input(30, minval=1)
pcntChange = input(7, 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 = d > 0 and isMoving()
short = d < 0 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("Long", strategy.long, when=long)
strategy.entry("Short", strategy.short, when=short)
strategy.exit("L Ex", "Long", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
strategy.exit("S Ex", "Short", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
sigl = plot(false ? na : pmols, title="PMO Signal", color=color.gray, linewidth=2, title="Signal")
mdl = plot(false ? na : pmol, title="PMO", color=color.black, linewidth=2, title="PMO")
fill(duml, sigl, color.green, transp=20, title="PosFill")
fill(duml, mdl, color.red, transp=20, title="NegFill")
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)