Die Ressourcen sind geladen. Beförderung...

Momentum Turtle Trendverfolgungsstrategie

Schriftsteller:ChaoZhang, Datum: 2023-11-23 11:53:27
Tags:

Übersicht

Die Momentum Turtle Trend Tracking Strategie ist eine Trend-Folge-Strategie, die auf den Turtle Trading-Regeln basiert. Sie verwendet die Turtle Indicators, um Trends zu identifizieren und kombiniert Momentum-Metriken, um einige Lärm-Trades auszufiltern. Der Hauptvorteil dieser Strategie ist die Fähigkeit, starke Preistrends zu erfassen und überschüssige Renditen zu erzielen.

Strategieprinzip

Diese Strategie verwendet das Breakout-System in den Schildkrötenindikatoren, um die Trendrichtung zu bestimmen. Insbesondere, wenn der Schlusskurs höher ist als der höchste Preis in den letzten 20 Tagen, ist es ein bullisches Signal und geht lang; wenn der Schlusskurs niedriger ist als der niedrigste Preis in den letzten 20 Tagen, ist es ein bärisches Signal und die Strategie geht kurz.

Um einige Lärm-Trades zu filtern, beinhaltet diese Strategie auch einen Momentum-Faktor. Wenn die Kursschwankung weniger als 5 ATRs beträgt, tritt die Strategie nicht in Trades ein. Dies vermeidet Verluste durch Whipsaws in seitlichen Märkten.

Nach Eröffnung von Positionen verwendet die Strategie die N-Breakout-Ausgänge in den ursprünglichen Turtle-Regeln für den Stop-Loss. Dieses System setzt den Stop-Loss basierend auf den höchsten und niedrigsten Preisen der letzten 20 Tage fest. Zum Beispiel wäre der Stop-Loss für Long-Positionen 2N ATRs unter dem niedrigsten Tief der letzten 20 Tage. Die Gewinnentnahme für diese Strategie ist einfach - bei 10% des Gesamtkontoverdienstes festgelegt.

Analyse der Vorteile

Der größte Vorteil dieser Strategie besteht darin, dass sie sowohl Trendverfolgung als auch Momentummanagement kombiniert. Das Turtle-System kann mittelfristige Preistrends genau erfassen, ohne von Marktlärm gestört zu werden. Der zusätzliche ATR-Momentumfilter reduziert die unnötige Anzahl von Trades weiter und erhöht damit das Gewinnpotenzial erheblich.

Diese Strategie weist insbesondere folgende Stärken auf:

Schildkrötenindikatoren identifizieren Trends genau und verfolgen mittelfristige Trends.
Momentumfilter reduzieren unnötige Trades und vermeiden Verluste bei der Handelsfrequenz.
Durch solide Risikokontrollmaßnahmen können Verluste rechtzeitig gestoppt werden, wenn sich die Trends umkehren.
Insgesamt passt die Strategie-Ausrichtung gut zu den ursprünglichen Turtle-Prinzipien.

Risikoanalyse

Obwohl es ein großes Potenzial für weitere Optimierungen gibt, birgt die Strategie auch einige Risiken, vor denen man sich schützen sollte:

Bei der Größenordnung von Schildkrötenpositionen wird keine Volatilität berücksichtigt, die zu übergroßen Verlusten führen kann.
Die Stop-Loss-Preise riskieren, bei extremen Umkehrungen aufgenommen zu werden, was zu höheren als erwarteten Verlusten führt.
Das Fehlen von Gewinnzielen bedeutet übermäßige Beteiligungen und das Risiko, Unterwasserpositionen zu halten.

Möglichkeiten zur Verbesserung

Auf der Grundlage der oben genannten Risiken sind die wichtigsten Optimierungsmöglichkeiten folgende:

Es ist nicht möglich, die Größe der positionierten Positionen zu bestimmen, wenn die Anpassung an die Volatilität nicht möglich ist.
Fügen Sie Umkehrmechanismen hinzu, um die Oberflächenmuster wie Kopf und Schultern oder Doppeltöpfe zu reduzieren oder umzukehren.
Zusätzliche Gewinnziele, so daß die Beteiligungen reduziert werden, wenn die kumulierten Gewinne einen Prozentsatz des Gesamtkapitals erreichen.

Schlussfolgerung

Insgesamt ist die Momentum Turtle Trend Tracking Strategie ein robustes System für mittelfristige bis langfristige Trendverfolgung. Sie kombiniert Turtle-Indikatoren zur Trendidentifizierung und ATR-Filter für das Volatilitätsmanagement, um starke Trends zu erfassen. Darüber hinaus sind Risikokontrollen und Parameter-Tuning solide, um Drawdowns zu reduzieren. Weitere Verbesserungen wie dynamische Größe, Umkehrungen und Gewinnentnahme können die Leistung verbessern.

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

//@version=4
strategy("Heiken Ashi 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(2029, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)

testPeriod() => true

///////////// HA /////////////
haTicker = heikinashi(syminfo.tickerid)
haOpen = security(haTicker, "D", open)
haHigh = security(haTicker, "D", high)
haLow = security(haTicker, "D", low)
haClose = security(haTicker, "D", close)

///////////// Rate Of Change ///////////// 
source = close
roclength = input(30, minval=1)
pcntChange = input(7.0, 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 = haOpen < haClose and isMoving()
short = haOpen > haClose 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("L",  strategy.long, when=long)
    strategy.entry("S", strategy.short, when=short)
    strategy.exit("L SL", "L", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
    strategy.exit("S SL", "S", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)

/////////////// Plotting ///////////////
plotcandle(haOpen, haHigh, haLow, haClose, title='HA Candles', color = haOpen < haClose ? color.lime : color.red)
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