Indicateur de dynamique Stratégie de négociation de décision

Auteur:ChaoZhang est là., Date: 2023-12-15 15h31 et 52 min
Les étiquettes:

Résumé

L'indicateur de dynamisme est une stratégie de trading de décision qui consiste à suivre une tendance. Il construit un indicateur de dynamisme en utilisant une moyenne mobile exponentielle double et le combine avec un indicateur de taux de changement de prix pour générer des signaux de trading.

Principe de stratégie

La stratégie utilise un oscillateur de point de décision basé sur une moyenne mobile exponentielle double pour mesurer la dynamique. Elle calcule d'abord le taux de variation quotidienne des prix, puis utilise des moyennes mobiles exponentielles doubles de 31 jours et 20 jours pour lisser le taux de variation des prix séparément. Enfin, elle utilise une moyenne mobile lissée de 9 jours pour émettre des signaux de trading. Lorsque la ligne rapide est au-dessus de la ligne lente, elle indique un marché haussier. Lorsque la ligne rapide est en dessous de la ligne lente, elle indique un marché baissier.

La stratégie introduit également un indicateur de taux de variation des prix pour éviter de faux signaux sur les marchés latéraux. Plus précisément, elle calcule le changement de prix en pourcentage au cours des 30 derniers jours et juge si le marché est actif à travers sa moyenne mobile. Les signaux de trading ne sont émis que lorsque le marché est actif.

Analyse des avantages

La stratégie combine l'indicateur de dynamique et l'indicateur de taux de changement de prix, ce qui permet d'identifier efficacement les tendances à moyen terme et d'éviter les transactions fréquentes sur les marchés volatils.

Analyse des risques

La stratégie repose principalement sur le trading de tendance à moyen et long terme, incapable de capturer les fluctuations de prix à court terme. Lorsqu'il y a un mouvement marqué du marché, le point de stop loss peut être brisé, ce qui entraîne de plus grandes pertes. En outre, des paramètres inappropriés peuvent également affecter la stratégie. Par exemple, si les paramètres de la moyenne mobile exponentielle double sont définis trop courts, la probabilité de mauvais métiers augmentera.

Pour prévenir les risques, les points de stop loss peuvent être ajustés de manière appropriée pour élargir la plage de stop loss. Lorsqu'un mouvement de marché brusque se produit, la stratégie peut être temporairement désactivée pour éviter la probabilité d'une rupture du stop loss. Pour l'ajustement des paramètres, un backtesting détaillé doit être effectué pour sélectionner les paramètres optimaux.

Directions d'optimisation

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

Ajoutez d'autres indicateurs de filtrage comme l'indicateur de volatilité pour éviter les transactions en période de fortes fluctuations du marché.
Ajouter des modèles d'apprentissage automatique pour aider à juger de la direction et de la force de la tendance, ce qui peut améliorer la précision du signal.
Essayez différents indicateurs de dynamique comme l'indice de force relative, l'oscillateur stochastique pour optimiser le timing d'entrée et de sortie.
Dans le cadre de la négociation en direct, ajuster dynamiquement les paramètres combinés avec les conditions récentes du marché afin de rechercher une combinaison optimale de paramètres.

Conclusion

L'indicateur de dynamisme est généralement une stratégie de suivi de tendance à moyen et long terme. Il identifie efficacement les tendances et évite les mauvais métiers en combinant l'indicateur de dynamisme moyen mobile exponentiel double et l'indicateur de taux de changement de prix. Pendant ce temps, il contrôle le risque en définissant des points de stop-loss. Si les paramètres sont correctement ajustés et que les résultats des backtests sont bons, il convient aux investisseurs à moyen et long terme qui recherchent des rendements excessifs.

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

Plus de

2019 FMZ - Tous les droits réservés