Momentum-Breakout-Strategie

Schriftsteller:ChaoZhang, Datum: 2023-11-15 11:09:21
Tags:

Übersicht

Die Momentum-Breakout-Strategie ist eine quantitative Handelsstrategie, die den Markttrends folgt. Sie berechnet den Momentum-Indikator auf der Grundlage historischer Preise, um den Trend und die Stärke der Marktpreisbewegungen zu bestimmen, um mittelfristige bis langfristige Trends auf dem Markt zu erfassen. Sie geht lang, wenn die Dynamik von negativ zu positiv übergeht, und geht kurz, wenn die Dynamik von positiv zu negativ übergeht. Diese Strategie eignet sich für Märkte mit offensichtlichen Trends und kann übermäßige Renditen erzielen.

Strategie Logik

Der Kern dieser Strategie basiert auf dem Momentum-Indikator. Der Momentum-Indikator ist der Schlusskurs des aktuellen Zeitraums abzüglich des Schlusskurses vor N Perioden. Wenn der letzte Schlusskurs höher ist als vor N Perioden, ist der Momentum positiv, was auf einen Aufwärtstrend hinweist; wenn der letzte Schlusskurs niedriger ist als vor N Perioden, ist der Momentum negativ, was auf einen Abwärtstrend hinweist.

Die Strategie berechnet zunächst den 18-Perioden-Impuls, der der aktuelle Schließung minus der Schließung vor 18 Perioden entspricht, gespeichert in mom0. Sie berechnet dann den 1-Perioden-Impuls von mom0, gespeichert in mom1.

Wenn mom0>0 und mom1>0 ein langes Signal erzeugt wird, das auf eine starke Aufwärtsdynamik hinweist, wenn mom0<0 und mom1<0 ein kurzes Signal erzeugt wird, das auf eine starke Abwärtsdynamik hinweist.

Die Strategie zeichnet die Zeit der jüngsten langen und kurzen Signale auf. Wenn die lange Signalzeit kürzer ist als die kurze Signalzeit, hält sie eine Long-Position. Wenn die kurze Signalzeit kürzer ist als die lange Signalzeit, hält sie eine Short-Position.

Analyse der Vorteile

Zu den Vorteilen dieser Strategie gehören:

Die Logik ist einfach und leicht verständlich, geeignet für Anfänger im quantitativen Handel.
Die Dynamikindikatoren können Markttrends und -stärke mit relativ hohen Gewinnraten erfassen, wenn sie mittelfristige und langfristige Trends verfolgen.
Der doppelte Impulsfilter hilft, Verluste durch falsche Ausbrüche zu vermeiden.
Es fügt Positionen nach dem Signal hinzu, um Trendpositionen zu etablieren und während der Trendmärkte überschüssige Renditen zu erzielen.
Eine rechtzeitige Stop-Loss-Exit-Kontrolle überwacht die Größe eines einzelnen Handelsverlusts und vermeidet große Verluste durch Umkehrungen.

Risikoanalyse

Einige Risiken dieser Strategie sind zu beachten:

Kann die Erweiterung des Stop-Loss-Bereichs in Betracht ziehen.
Häufige offene und geschlossene Trades in unterschiedlichen Märkten erhöhen die Kosten für Provisionen und Slippage.
Die fortgesetzte Bestandhaltung in der ursprünglichen Richtung nach einer Trendumkehr vergrößert die Verluste.
Die falsche Einstellung der Parameter führt zu fehlenden Signalen oder zu falschen Signalen, die für verschiedene Märkte angepasst werden müssen.

Optimierungsrichtlinien

Einige Möglichkeiten zur Optimierung der Strategie:

Optimierung der Impulsparameter durch Anpassung der Impulslängenberechnung an den Zeitrahmen und den Markt.
Hinzufügen anderer Indikatorfilter wie MACD, KD, um Verluste durch Trendumkehrungen zu vermeiden.
Optimierung der Stop-Loss-Strategie durch Erweiterung der Stopps in Trends und Verschärfung der Stops in Nicht-Trend-Märkten.
Zusätzliche Positionsgrößenregeln zur Verringerung der Größe bei Nichttrends und zur Erhöhung der Größe bei Trends, um mehr Gewinne zu erzielen.
Optimierung der Parameter für verschiedene Produkte, um die Anpassungsfähigkeit zu verbessern.
Einbeziehung von Algorithmen für maschinelles Lernen zur dynamischen Optimierung von Parametern.

Schlussfolgerung

Die Momentum-Breakout-Strategie ist ein intuitives Trendfolgesystem. Sie kann mittelfristige bis langfristige Trends effektiv erfassen und gute Gewinne während der Trendmärkte erzielen. Das Risikomanagement durch Stop-Loss-Optimierung und die Verwendung anderer Indikatoren zur Beurteilung des Trends sind ebenfalls wichtig. Mit kontinuierlicher Optimierung kann diese Strategie zu einem stabilen, gewinnbringenden quantitativen Handelssystem entwickelt werden.

/*backtest
start: 2023-10-15 00:00:00
end: 2023-11-14 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("Momentum 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 ///////////////
_0 = 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

///////////// Momentum /////////////
_1 = input(false, "═══════ Momentum ══════")
length = input(18)
price = close

momentum(seria, length) =>
    mom = seria - seria[length]
    mom

mom0 = momentum(price, length)
mom1 = momentum(mom0, 1)

/////////////// Strategy /////////////// 
long = mom0 > 0 and mom1 > 0
short = mom0 < 0 and mom1 < 0

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]) 

/////////////// Stop Losses Long ///////////////
_5 = input(false,  "═══════ Stop Loss L ══════")
SL_typel = input("Fixed", options=["Fixed", "ATR Derived"], title="Stop Loss Type")
sl_inpl = input(8.0, title='Fixed Stop Loss %') / 100
atrLkbl = input(20, minval=1, title='ATR Stop Period')
atrMultl = input(1.5, step=0.25, title='ATR Stop Multiplier') 
atr1l = atr(atrLkbl)

longStop1l = 0.0
longStop1l := short_signal ? na : long_signal ? close - (atr1l * atrMultl) : longStop1l[1]

slLongl = in_long_signal ? strategy.position_avg_price * (1 - sl_inpl) : na
long_sll = in_long_signal ? slLongl : na

/////////////// Stop Losses Short ///////////////
_6 = input(false, "═══════ Stop Loss S ══════")
SL_types = input("Fixed", options=["Fixed", "ATR Derived"], title="Stop Loss Type")
sl_inps = input(7.0, title='Fixed Stop Loss %') / 100
atrLkbs = input(20, minval=1, title='ATR Stop Period')
atrMults = input(1.5, step=0.25, title='ATR Stop Multiplier') 
atr1s = atr(atrLkbs)

shortStop1s = 0.0
shortStop1s := long_signal ? na : short_signal ? close + (atr1s * atrMults) : shortStop1s[1]

slShorts = strategy.position_avg_price * (1 + sl_inps)
short_sls = in_short_signal ? slShorts : na

_7 = input(false, "══════ Longs or Shorts ═════")
useLongs = input(true, title="Use Longs")
useShorts = input(true, title="Use Shorts")

/////////////// Execution ///////////////
if testPeriod()
    if useLongs
        strategy.entry("L", strategy.long, when=long)
        strategy.exit("L SL", "L", stop = SL_typel == "Fixed" ? long_sll : longStop1l, when=since_longEntry > 0)
    if useShorts
        strategy.exit("S SL", "S", stop = SL_types == "Fixed" ? short_sls : shortStop1s, when=since_shortEntry > 0)
        strategy.entry("S", strategy.short, when=short)
    if not useShorts
        strategy.close("L", when=short)
    if not useLongs
        strategy.close("S", when=long)

/////////////// Plotting /////////////// 
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=40)
p0 = plot(close)
p1 = plot(strategy.position_size <= 0 ? na : SL_typel == "Fixed" ? long_sll : longStop1l, title="Long Stop Loss", color=color.yellow, style=plot.style_linebr, linewidth=2)
p2 = plot(strategy.position_size >= 0 ? na : SL_types == "Fixed" ? short_sls : shortStop1s, title="Short Stop Loss", color=color.orange, style=plot.style_linebr, linewidth=2)
p3 = plot(strategy.position_size <= 0 ? na : strategy.position_avg_price, style=plot.style_linebr, title="Long Entry", color=color.green, linewidth=2)
p4 = plot(strategy.position_size >= 0 ? na : strategy.position_avg_price, style=plot.style_linebr, title="Short Entry", color=color.red, linewidth=2)
fill(p0, p3, color = color.lime, transp=60)
fill(p0, p4, color = color.red, transp=60)

Mehr