Momentum-Indikator Handelsstrategie für Entscheidungen

Schriftsteller:ChaoZhang, Datum: 2023-12-15 15:31:52
Tags:

Übersicht

Die Momentum-Indikator-Entscheidungs-Handelsstrategie ist eine Trendfolgestrategie. Sie baut einen Momentum-Indikator mit Hilfe eines doppelten exponentiellen gleitenden Durchschnitts auf und kombiniert ihn mit dem Kursänderungsindikator, um Handelssignale zu generieren. Wenn der Momentum-Indikator steigt, erzeugt er lange Signale. Wenn der Momentum-Indikator sinkt, erzeugt er kurze Signale. Diese Strategie eignet sich für Händler, die mittelfristige Trends auf dem Markt verfolgen möchten.

Strategieprinzip

Die Strategie verwendet einen Decision Point-Oszillator, der auf einem doppelten exponentiellen gleitenden Durchschnitt basiert, um die Dynamik zu messen. Zuerst berechnet sie die tägliche Kursänderungsrate, dann verwendet sie 31-tägige und 20-tägige doppelte exponentielle gleitende Durchschnitte, um die Kursänderungsrate separat zu glätten. Schließlich verwendet sie einen 9-tägigen glätteten gleitenden Durchschnitt, um Handelssignale auszugeben. Wenn die schnelle Linie über der langsamen Linie liegt, zeigt sie einen Bullenmarkt an. Wenn die schnelle Linie unter der langsamen Linie liegt, zeigt sie einen Bärenmarkt an.

Die Strategie führt auch einen Kursänderungsindikator ein, um falsche Signale in seitlichen Märkten zu vermeiden. Insbesondere berechnet sie die prozentuale Preisänderung in den letzten 30 Tagen und beurteilt, ob der Markt durch seinen gleitenden Durchschnitt aktiv ist. Handelssignale werden nur ausgegeben, wenn der Markt aktiv ist.

Analyse der Vorteile

Die Strategie kombiniert einen Momentum-Indikator und einen Preisänderungsindikator, der mittelfristige Trends effektiv identifizieren und häufigen Handel in volatilen Märkten vermeiden kann. Im Vergleich zu einfachen Trend-Nachfolgestrategien wie gleitendem Durchschnitt kann sie die Wahrscheinlichkeit falscher Trades erheblich reduzieren. Darüber hinaus wird das Risiko kontrolliert, indem Stop-Loss-Punkte festgelegt werden, um Verluste rechtzeitig zu reduzieren und den Verlust pro Handel effektiv zu kontrollieren.

Risikoanalyse

Die Strategie stützt sich hauptsächlich auf den mittelfristigen Trendhandel, der nicht in der Lage ist, kurzfristige Kursschwankungen zu erfassen. Wenn es eine scharfe Marktbewegung gibt, kann der Stop-Loss-Punkt gebrochen werden, was zu größeren Verlusten führt. Darüber hinaus können unangemessene Parameter-Einstellungen auch die Strategie beeinflussen. Zum Beispiel, wenn die doppelten exponentiellen gleitenden Durchschnittsparameter zu kurz gesetzt werden, wird die Wahrscheinlichkeit falscher Trades zunehmen.

Um Risiken vorzubeugen, können Stop-Loss-Punkte angemessen angepasst werden, um den Stop-Loss-Bereich zu erweitern. Wenn eine scharfe Marktbewegung eintritt, kann die Strategie vorübergehend ausgeschaltet werden, um die Wahrscheinlichkeit zu vermeiden, dass der Stop-Loss gebrochen wird. Für die Parameter-Tuning sollte ein detailliertes Backtesting durchgeführt werden, um die optimalen Parameter auszuwählen.

Optimierungsrichtlinien

Die Strategie kann in folgenden Aspekten optimiert werden:

Hinzufügen anderer Filterindikatoren wie Volatilitätsindikator, um den Handel in Zeiten starker Marktschwankungen zu vermeiden.
Hinzufügen von maschinellen Lernmodellen, um die Beurteilung der Trendrichtung und -stärke zu unterstützen, was die Signalgenauigkeit verbessern kann.
Versuchen Sie verschiedene Momentum-Indikatoren wie Relative Strength Index, Stochastic Oszillator, um den Einstiegs- und Ausstiegszeitpunkt zu optimieren.
Im Live-Handel werden die Parameter dynamisch an die aktuellen Marktbedingungen angepasst, um eine optimale Parameterkombination zu erreichen.

Schlussfolgerung

Die Momentum-Indikator-Entscheidungs-Handelsstrategie ist im Allgemeinen eine stetige mittelfristige Trend-Nachstrategie. Sie identifiziert effektiv Trends und vermeidet falsche Trades, indem sie den doppelten exponentiellen gleitenden Durchschnittsmomentumsindikator und den Preisänderungsindikator kombiniert. In der Zwischenzeit kontrolliert sie das Risiko, indem sie Stop-Loss-Punkte setzt. Wenn die Parameter richtig abgestimmt sind und die Backtestergebnisse gut sind, eignet sie sich für mittelfristige Anleger, die übermäßige Renditen anstreben.

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

Mehr