Trend nach Strategie auf Basis des adaptiven gleitenden Durchschnitts

Schriftsteller:ChaoZhang, Datum: 2024-01-30 16:30:20
Tags:

Übersicht

Diese Strategie verwendet den Kaufman Adaptive Moving Average (KAMA) Indikator, um ein Trend nach dem Handelssystem zu entwerfen. Es kann Trends schnell verfolgen, wenn sie sich bilden, und Geräusche während unruhiger Märkte filtern. Gleichzeitig integriert das System auch Parabol SAR (PSAR) und Average True Range Trailing Stop als Stop-Loss-Mechanismen mit starken Risikokontrollfunktionen.

Strategie Logik

Die Länge des KAMA-Indikators wird dynamisch anhand der jüngsten Marktvolatilität angepasst. Wenn die Preisänderungen größer sind als der jüngste Lärm, wird das EMA-Fenster kürzer. Wenn die Preisänderungen kleiner sind als der jüngste Lärm, wird das EMA-Fenster länger. Dies ermöglicht es KAMA, Trends schnell zu verfolgen, während es Lärm während unruhiger Märkte filtert.
Das System beurteilt hauptsächlich die Trendrichtung anhand des schnellsten KAMA (KAMA 1). Es geht lang, wenn KAMA 1 nach oben zeigt und kurz, wenn KAMA 1 nach unten zeigt. Um falsche Bruchfälle auszufiltern, wird ein KAMA-Filter eingestellt. Handelssignale werden nur erzeugt, wenn die Änderung in KAMA 1 eine Standardabweichung der jüngsten Schwankungen übersteigt.
Für den Stop-Loss bietet das System drei optionale Stop-Loss-Methoden: KAMA-Umkehrung, PSAR-Umkehrung und ATR-Trailing-Stop.

Analyse der Vorteile

Das einzigartige Design des KAMA-Indikators ermöglicht es dem System, aufkommende Trends schnell zu erfassen, den Handel während unruhiger Märkte zu beenden, die Handelsfrequenz effektiv zu kontrollieren und unnötige Verschiebungen und Provisionskosten zu reduzieren.
Das System verfügt über mehrere eingebaute Stop-Loss-Mechanismen. Anleger können das passende Stop-Loss-Schema entsprechend ihren persönlichen Risikopräferenzen wählen, um einzelne Verluste effektiv zu kontrollieren.
Das System basiert vollständig auf Indikatoren und Stop-Loss-Linien und vermeidet damit häufige Fehler, die durch wechselnde Transaktionen verursacht werden.
Mehrere Parameter-Einstellungen und Zustandskombinationen bieten einen großen Raum für die Anpassung des Systems.

Risikoanalyse

Das System berücksichtigt keine systemischen Risiken und kann Verluste unter extremen Marktbedingungen nicht wirksam kontrollieren.
Das System PARAMETERS muss möglicherweise an unterschiedliche Produkte und Häufigkeiten angepasst werden, da es sonst zu aggressive oder zu konservative Ergebnisse liefert.
Wenn man sich ausschließlich auf den KAMA-Indikator für den Stop-Loss verlässt, ist es leicht, sich während unruhiger Märkte in Whipsaws zu verfangen. Dies muss mit PSAR oder ATR Trailing Stop kombiniert werden, um zu lösen.

Optimierungsrichtlinien

Hinzufügen von Trendfilterindikatoren wie ADX oder impliziter Volatilität, um zu vermeiden, dass falsche Signale während unruhiger und trendübergreifender Phasen erzeugt werden.
Optimieren und Backtest PARAMETER für einzelne Produkte und feste Frequenzen zur Verbesserung der Stabilität.
Trainieren Sie neuronale Netzwerke oder Entscheidungsbaummodelle mit vielen historischen Daten, um Eingangs- und Ausstiegszeiten und Stop-Loss zu beurteilen.
Versuchen Sie, die Strategie auf andere Produkte wie Kryptowährungen zu migrieren. Dies kann die Anpassung von PARAMETERN oder das Hinzufügen anderer Hilfsindikatoren erfordern.

Zusammenfassung

Diese Strategie integriert KAMA für die Trendbeurteilung und mehrere Stop-Loss-Methoden, um Trendrichtungen effektiv zu verfolgen und Risiken zu kontrollieren. Die Einzigartigkeit des KAMA-Indikators ermöglicht es der Strategie, schnell die Richtung aufstrebender Trends zu bestimmen und falsche Ausbruchprobleme zu vermeiden. Anpassbare und optimierbare PARAMETER bieten den Benutzern großen Raum für eine personalisierte Anpassung. Durch die Optimierung von PARAMETERN und die Integration von MACHINE LEARNING-Modellen für einzelne Produkte und Frequenzen kann die Leistung der Strategie weiter verbessert werden.

/*backtest
start: 2023-12-01 00:00:00
end: 2023-12-31 23:59:59
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/
// © BenHampson
// @version=4
// Credit to:
// - ChuckBanger for much of the KAMA code
// - cheatcountry for the KAMA Filter code
// - millerrh for much of the ATR Stop code
// - racer8 for much of the Position Sizing code

// I have combined aspects of their work and built upon it to form a strategy I like. 
// The KAMA, with its filter, is used for entry.
// An ATR trailing stop loss, PSAR, and the KAMA can all optionally be used as exits, or you can use a combination of the three.

strategy(title="KAMA Strategy - Kaufman's Adaptive Moving Average", shorttitle="KAMA Strategy", overlay=true)

src = input(title="Source", type=input.source, defval=close)

// Exits
KAMA1SL = input(title = 'KAMA 1 Stop Loss', type = input.bool, defval = true)
ATRTSL = input(title = 'ATR Trailing Stop Loss', type = input.bool, defval = false)
PSARSL = input(title = 'PSAR Stop Loss', type = input.bool, defval = false)

// KAMA 1 (Fastest)
length1 = input(title="KAMA 1: Length", type=input.integer, defval=14)
fastLength1 = input(title="KAMA 1: Fast KAMA Length", type=input.integer, defval=2)
slowLength1 = input(title="KAMA 1: Slow KAMA Length", type=input.integer, defval=20)

length2 = input(title="KAMA 2: Length 2", type=input.integer, defval=15)
fastLength2 = input(title="KAMA 2: Fast KAMA Length", type=input.integer, defval=3)
slowLength2 = input(title="KAMA 2: Slow KAMA Length", type=input.integer, defval=22)

length3 = input(title="KAMA 3: Length 3", type=input.integer, defval=16)
fastLength3 = input(title="KAMA 3: Fast KAMA Length", type=input.integer, defval=4)
slowLength3 = input(title="KAMA 3: Slow KAMA Length", type=input.integer, defval=24)

length4 = input(title="KAMA 4: Length", type=input.integer, defval=17)
fastLength4 = input(title="KAMA 4: Fast KAMA Length", type=input.integer, defval=5)
slowLength4 = input(title="KAMA 4: Slow KAMA Length", type=input.integer, defval=26)

// KAMA 5 (Medium)
length5 = input(title="KAMA 5: Length", type=input.integer, defval=18)
fastLength5 = input(title="KAMA 5: Fast KAMA Length", type=input.integer, defval=6)
slowLength5 = input(title="KAMA 5: Slow KAMA Length", type=input.integer, defval=28)

length6 = input(title="KAMA 6: Length", type=input.integer, defval=19)
fastLength6 = input(title="KAMA 6: Fast KAMA Length", type=input.integer, defval=7)
slowLength6 = input(title="KAMA 6: Slow KAMA Length", type=input.integer, defval=30)

length7 = input(title="KAMA 7: Length", type=input.integer, defval=20)
fastLength7 = input(title="KAMA 7: Fast KAMA Length", type=input.integer, defval=8)
slowLength7 = input(title="KAMA 7: Slow KAMA Length", type=input.integer, defval=32)

// KAMA 8 (Slowest)
length8 = input(title="KAMA 8: Length", type=input.integer, defval=21)
fastLength8 = input(title="KAMA 8: Fast KAMA Length", type=input.integer, defval=9)
slowLength8 = input(title="KAMA 8: Slow KAMA Length", type=input.integer, defval=34)

// Kaufman's Adaptive Moving Average
getKAMA(src, length1, fastLength1, slowLength1) =>
    mom = abs(change(src, length1))
    volatility = sum(abs(change(src)), length1)
    
    // Efficiency Ratio
    er = volatility != 0 ? mom / volatility : 0
    
    fastAlpha = 2 / (fastLength1 + 1)
    slowAlpha = 2 / (slowLength1 + 1)
    
    // KAMA Alpha
    sc = pow((er * (fastAlpha - slowAlpha)) + slowAlpha, 2)
    
    kama = 0.0
    kama := sc * src + (1 - sc) * nz(kama[1])
    kama

kama1 = getKAMA(src, length1, fastLength1, slowLength1)
kama2 = getKAMA(src, length2, fastLength2, slowLength2)
kama3 = getKAMA(src, length3, fastLength3, slowLength3)
kama4 = getKAMA(src, length4, fastLength4, slowLength4)
kama5 = getKAMA(src, length5, fastLength5, slowLength5)
kama6 = getKAMA(src, length6, fastLength6, slowLength6)
kama7 = getKAMA(src, length7, fastLength7, slowLength7)
kama8 = getKAMA(src, length8, fastLength8, slowLength8)

//If the kama1 has increased...
kama1delta = kama1[0] - kama1[1]
kama3delta = kama3[0] - kama3[1]
kama8delta = kama8[0] - kama8[1]

// KAMA Plots
plot(kama1, title="KAMA 1", color=#e91e63, display=display.all, linewidth=2)
plot(kama2, title="KAMA 2", color=color.red, display=display.all)
plot(kama3, title="KAMA 3", color=color.red, display=display.all)
plot(kama4, title="KAMA 4", color=color.orange, display=display.all)
plot(kama5, title="KAMA 5", color=color.orange, display=display.all)
plot(kama6, title="KAMA 6", color=color.yellow, display=display.all)
plot(kama7, title="KAMA 7", color=color.yellow, display=display.all)
plot(kama8, title="KAMA 8", color=color.white, display=display.all)



//========================================= KAMA FILTER ===========================================

// Copyright (c) 2019-present, Franklin Moormann (cheatcountry)
// Moving Average Adaptive Filter [CC] script may be freely distributed under the MIT license.

entryFilter = input(title="KAMA Entry Filter", type=input.float, defval=1, minval=0.01)
exitFilter = input(title="KAMA Exit Filter", type=input.float, defval=0.5, minval=0.01)

entryMAAF = entryFilter * stdev(kama1delta, length1)
exitMAAF = exitFilter * stdev(kama1delta, length1)
srcEma = ema(src, length1)



//========================================= TRAILING ATR STOP ====================================

// The following is an adaptation of Trailing ATR Stops by @millerrh
// He based it on scripts by @garethyeo & @SimpleCryptoLife

// Inputs

atrLookback = input(defval=14,title="Trailing ATR Lookback Period",type=input.integer)
multiplier = input(defval=3,title="Trailing ATR Multiplier",type=input.float, step=0.1, minval=0.5, maxval=4)
trailMode = input(title="Trail Mode", defval="Trailing", options=["Running", "Trailing"])
trigInput = input(title="Trigger Trailing Stop On", defval="Wick", options=["Close","Wick"]) 

// Calculate ATR
atrValue = atr(atrLookback)
atrMultiplied = atrValue * multiplier

// Plot the price minus the ATR
atrLow = low - atrMultiplied

// Calculate the low trailing ATRs every time. The trailing stop loss never goes down.
// Set them to something to start with
trailAtrLow = atrLow

// If the ATR Low has gone up AND it has gone above the trail, the low trailing ATR should also go up. If the ATR Low has gone up or down, but not below the trail, the ATR trail stays where it is
trailAtrLow := na(trailAtrLow[1]) ? trailAtrLow : atrLow >= trailAtrLow[1] ? atrLow : trailAtrLow[1]

// Trigger stop based on candle close or low
trigSupport = trigInput == "Close" ? close : trigInput == "Wick" ? low : na

// Determine if price is below support
supportHit = trigSupport <= trailAtrLow

// If price is below support, reset the trailing ATR
trailAtrLow := supportHit ? atrLow : trailAtrLow

// Plot Lines
plotLow = ATRTSL ? trailAtrLow : na
plot(plotLow, title="ATR Low", color=color.white, transp=50, style=plot.style_linebr, linewidth=1, display=display.all)



//====================================== PSAR STOP ==========================================

start = input(0.02, "PSAR Start")
increment = input(0.02, "PSAR Increment")
maximum = input(0.2, "PSAR Max Value")
psar = sar(start, increment, maximum)
psarPlot  = PSARSL ? psar : na
plot(psarPlot, "Parabolic SAR", style=plot.style_cross, color=#3A6CA8, display=display.all)



//========================================= ENTRY & EXITS =====================================================

// Entry
long = kama1delta > 0 and kama1delta > entryMAAF
strategy.entry("Buy", true, when = long) 

// Close
longClose = (PSARSL ? crossunder(close, psar) : na) or (KAMA1SL ? kama1delta < 0 and abs(kama1delta) > exitMAAF : na) or (ATRTSL ? supportHit : na)
strategy.close("Buy", when = longClose, comment = "Sell")

Mehr