Die Ressourcen sind geladen. Beförderung...

Die Strategie des Momentum Breakouts

Schriftsteller:ChaoZhang, Datum: 2024-02-23 14:27:21
Tags:

Übersicht

Die Momentum-Breakout-Strategie ist eine trendfolgende Strategie, die die Dynamik des Marktes verfolgt. Sie kombiniert mehrere Indikatoren, um zu beurteilen, ob der Markt derzeit in einem Aufwärtstrend oder Abwärtstrend ist, und eröffnet Long-Positionen, wenn sie die wichtigsten Widerstandsniveaus durchbrechen, und eröffnet Short-Positionen, wenn sie die wichtigsten Unterstützungsniveaus durchbrechen.

Strategie Logik

Diese Strategie verwendet hauptsächlich Donchian Channels von mehreren Zeitrahmen, um Markttrends und wichtige Preisniveaus zu bestimmen. Insbesondere wird, wenn die Preise durch die obere Schiene des längerfristigen Donchian Kanals wie 40 Tage durchbrechen, es als Aufwärtstrend beurteilt. Zusammen mit zusätzlichen Filtern wie neuen Höchstständen innerhalb des Jahres und der Ausrichtung der gleitenden Durchschnitte werden lange Signale ausgelöst. Wenn die Preise unter die untere Schiene des längerfristigen Donchian Kanals durchbrechen, wird es als Abwärtstrend beurteilt. Zusammen mit Filtern wie neuen Tiefständen innerhalb des Jahres werden kurze Signale ausgelöst.

Die Strategie bietet zwei Optionen für Exit-Positionen: feste Invalidationslinie und Trailing Stop Loss. Die feste Invalidationslinie verwendet die untere/obere Schiene eines kürzeren Donchian Kanals wie 20 Tage. Die Trailing Stop Loss berechnet jeden Tag eine dynamische Stop Loss-Linie basierend auf ATR-Werten. Beide Methoden können Risiken effektiv kontrollieren.

Analyse der Vorteile

Diese Strategie kombiniert Trendbeurteilung und Breakout-Operationen, die kurzfristige Richtungschancen auf dem Markt effektiv erfassen können. Im Vergleich zu einzelnen Indikatoren verwendet sie mehrere Filter, die einige falsche Breakouts herausfiltern und die Qualität der Eintrittssignale verbessern können. Darüber hinaus erhöht die Anwendung von Stop-Loss-Strategien auch ihre Widerstandsfähigkeit und kann Verluste effektiv kontrollieren, auch wenn der Markt kurz zurückzieht.

Risikoanalyse

Das Hauptrisiko dieser Strategie besteht darin, dass die Preise heftig schwanken können, was zu Stop-Losses bei Exit-Positionen führt. Wenn sich die Preise danach schnell umkehren, könnten Chancen verpasst werden. Darüber hinaus kann die Verwendung mehrerer Filter auch einige Chancen herausfiltern und die Häufigkeit der Trades reduzieren.

Um Risiken zu reduzieren, können die ATR-Multiplikatoren angepasst oder die Donchian-Kanal-Intervalle vergrößert werden, um die Wahrscheinlichkeit zu verringern, dass ein Stop-Loss getroffen wird.

Optimierungsrichtlinien

Diese Strategie kann in folgenden Aspekten optimiert werden:

Optimieren Sie die Länge der Donchian-Kanäle, um die beste Kombination von Parametern zu finden.
Versuchen Sie verschiedene Arten von gleitenden Durchschnitten als Filter.
Anpassen des ATR-Multiplikators oder Feststellen für den Stop-Loss.
Fügen Sie mehr Trendbewertungsindikatoren wie MACD hinzu.
Optimierung der Rückblickzeiten für neue Höchst-/Tiefstände innerhalb des Jahres usw.

Durch das Testen verschiedener Parameter kann die optimale Kombination aus Risiken und Renditen gefunden werden.

Schlussfolgerung

Diese Strategie kombiniert mehrere Indikatoren, um die Trendrichtung zu bestimmen, und löst Trades auf wichtigen Breakout-Niveaus aus. Ihr Stop-Loss-Mechanismus macht sie auch anfällig für Risiken. Durch die Optimierung von Parametern können stabile Überzugsrenditen erzielt werden. Sie eignet sich für Anleger, die keine klare Sicht auf den Markt haben, aber Trends folgen möchten.

/*backtest
start: 2024-01-23 00:00:00
end: 2024-02-22 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © HeWhoMustNotBeNamed

//@version=4
strategy("BuyHigh-SellLow Strategy", overlay=true, initial_capital = 10000, default_qty_type = strategy.percent_of_equity, default_qty_value = 100, commission_type = strategy.commission.percent, pyramiding = 1, commission_value = 0.01, calc_on_order_fills = true)
donchianEntryLength = input(40, step=10)
donchianExitLength = input(20, step=10)

considerNewLongTermHighLows = input(true)
shortHighLowPeriod = input(120, step=10)
longHighLowPeriod = input(180, step=10)

considerMAAlignment = input(true)
MAType = input(title="Moving Average Type", defval="ema", options=["ema", "sma", "hma", "rma", "vwma", "wma"])
LookbackPeriod = input(40, minval=10,step=10)

atrLength = input(22)
atrMult = input(4)

exitStrategy = input(title="Exit Strategy", defval="tsl", options=["dc", "tsl"])

considerYearlyHighLow = input(true)
backtestYears = input(10, minval=1, step=1)
f_getMovingAverage(source, MAType, length)=>
    ma = sma(source, length)
    if(MAType == "ema")
        ma := ema(source,length)
    if(MAType == "hma")
        ma := hma(source,length)
    if(MAType == "rma")
        ma := rma(source,length)
    if(MAType == "vwma")
        ma := vwma(source,length)
    if(MAType == "wma")
        ma := wma(source,length)
    ma

f_getTrailingStop(atr, atrMult)=>
    stop = close - atrMult*atr
    stop := strategy.position_size > 0 ? max(stop, stop[1]) : stop
    stop

f_getMaAlignment(MAType, includePartiallyAligned)=>
    ma5 = f_getMovingAverage(close,MAType,5)
    ma10 = f_getMovingAverage(close,MAType,10)
    ma20 = f_getMovingAverage(close,MAType,20)
    ma30 = f_getMovingAverage(close,MAType,30)
    ma50 = f_getMovingAverage(close,MAType,50)
    ma100 = f_getMovingAverage(close,MAType,100)
    ma200 = f_getMovingAverage(close,MAType,200)

    upwardScore = 0
    upwardScore := close > ma5? upwardScore+1:upwardScore
    upwardScore := ma5 > ma10? upwardScore+1:upwardScore
    upwardScore := ma10 > ma20? upwardScore+1:upwardScore
    upwardScore := ma20 > ma30? upwardScore+1:upwardScore
    upwardScore := ma30 > ma50? upwardScore+1:upwardScore
    upwardScore := ma50 > ma100? upwardScore+1:upwardScore
    upwardScore := ma100 > ma200? upwardScore+1:upwardScore
    
    upwards = close > ma5 and ma5 > ma10 and ma10 > ma20 and ma20 > ma30 and ma30 > ma50 and ma50 > ma100 and ma100 > ma200
    downwards = close < ma5 and ma5 < ma10 and ma10 < ma20 and ma20 < ma30 and ma30 < ma50 and ma50 < ma100 and ma100 < ma200
    upwards?1:downwards?-1:includePartiallyAligned ? (upwardScore > 5? 0.5: upwardScore < 2?-0.5:upwardScore>3?0.25:-0.25) : 0

//////////////////////////////////// Calculate new high low condition //////////////////////////////////////////////////
f_calculateNewHighLows(shortHighLowPeriod, longHighLowPeriod, considerNewLongTermHighLows)=>
    newHigh = highest(shortHighLowPeriod) == highest(longHighLowPeriod) or not considerNewLongTermHighLows
    newLow = lowest(shortHighLowPeriod) == lowest(longHighLowPeriod) or not considerNewLongTermHighLows
    [newHigh,newLow]

//////////////////////////////////// Calculate Yearly High Low //////////////////////////////////////////////////
f_getYearlyHighLowCondition(considerYearlyHighLow)=>
    yhigh = security(syminfo.tickerid, '12M', high[1]) 
    ylow = security(syminfo.tickerid, '12M', low[1]) 
    yhighlast = yhigh[365]
    ylowlast = ylow[365]
    yhighllast = yhigh[2 * 365]
    ylowllast = ylow[2 * 365]
    
    yearlyTrendUp = na(yhigh)? true : na(yhighlast)? close > yhigh : na(yhighllast)? close > max(yhigh,yhighlast) : close > max(yhigh, min(yhighlast, yhighllast))
    yearlyHighCondition = (  (na(yhigh) or na(yhighlast) ? true : (yhigh > yhighlast) ) and ( na(yhigh) or na(yhighllast) ? true : (yhigh > yhighllast))) or yearlyTrendUp or not considerYearlyHighLow
    yearlyTrendDown = na(ylow)? true : na(ylowlast)? close < ylow : na(ylowllast)? close < min(ylow,ylowlast) : close < min(ylow, max(ylowlast, ylowllast))
    yearlyLowCondition = (  (na(ylow) or na(ylowlast) ? true : (ylow < ylowlast) ) and ( na(ylow) or na(ylowllast) ? true : (ylow < ylowllast))) or yearlyTrendDown or not considerYearlyHighLow
    
    label_x = time+(60*60*24*1000*1)
    [yearlyHighCondition,yearlyLowCondition]

donchian(rangeLength)=>
    upper = highest(rangeLength)
    lower = lowest(rangeLength)
    middle = (upper+lower)/2
    [middle, upper, lower]

inDateRange = true
[eMiddle, eUpper, eLower] = donchian(donchianEntryLength)
[exMiddle, exUpper, exLower] = donchian(donchianExitLength)
maAlignment = f_getMaAlignment(MAType, false)
[yearlyHighCondition, yearlyLowCondition] = f_getYearlyHighLowCondition(considerYearlyHighLow)
[newHigh,newLow] = f_calculateNewHighLows(shortHighLowPeriod, longHighLowPeriod, considerNewLongTermHighLows)

maAlignmentLongCondition = highest(maAlignment, LookbackPeriod) == 1 or not considerMAAlignment 

atr = atr(atrLength)
tsl = f_getTrailingStop(atr, atrMult)

//U = plot(eUpper, title="Up", color=color.green, linewidth=2, style=plot.style_linebr)
//D = plot(exLower, title="Ex Low", color=color.red, linewidth=2, style=plot.style_linebr)
longCondition = crossover(close, eUpper[1]) and yearlyHighCondition and newHigh and maAlignmentLongCondition
exitLongCondition = crossunder(close, exLower[1])

shortCondition = crossunder(close, eLower[1]) and yearlyLowCondition and newLow
exitShortCondition = crossover(close, exUpper[1])
strategy.entry("Buy", strategy.long, when=longCondition and inDateRange, oca_name="oca_buy")
strategy.exit("ExitBuyDC", "Buy", when=exitStrategy=='dc', stop=exLower)
strategy.exit("ExitBuyTSL", "Buy", when=exitStrategy=='tsl', stop=tsl)
plot(strategy.position_size > 0 ? (exitStrategy=='dc'?exLower:tsl) : na, title="Trailing Stop", color=color.red, linewidth=2, style=plot.style_linebr)
//strategy.close("Buy", when=exitLongCondition)

Mehr