Trendfolgestrategie für den zentralen Schwerkraftkanal
ChaoZhang
Überblick
Die Strategie kombiniert Zentralgravitations- und SSL-Channel-Indikatoren, um Preistrends zu beurteilen und zu durchbrechen. Sie gehört zu den Strategien der Trend-Tracking-Klasse. Die Strategie kombiniert Dynamische ATR-Stopps zur Risikokontrolle.
Strategieprinzip
Der Gravitationsindikator des Rechenzentrums, in dem die oberen und unteren Bahnen als Trendgrenzen für steigende und fallende Preise gelten.
Berechnen Sie die SSL-Channel-Indikatoren, wobei der interne Kanal die Vergleiche ist und der externe Kanal die Trendrichtung.
Wenn der Preis die Oberbahn oder den Kanal durchbricht, wird er als Aufwärtstrend beurteilt und mehr gemacht. Wenn der Preis die Unterbahn oder den Kanal durchbricht, wird er als Abwärtstrend beurteilt und leer gemacht.
Der dynamische ATR-Stop wird verwendet, um die Stop-Loss-Position zu verfolgen, um Verluste zu vermeiden.
In Kombination mit der Rückmeldung erzeugen wir ein echtes Handelssignal.
Die Strategie nutzt gleichzeitig zwei Indikatoren, um die Richtung des Trends zu bestimmen. Einer dient zur Bestimmung von Durchbrüchen, der andere zur Bestätigung von Trends. Die Kombination der beiden kann die Richtigkeit der Beurteilung verbessern.
Analyse der Stärken
Es gibt zwei Indikatoren, mit denen man Trends beurteilen kann, um die Genauigkeit zu verbessern.
Der Zentralgravitationsindikator ist empfindlich für Trendänderungen, und der SSL-Kanal beurteilt die Richtung des Trends als “cleared”“.
Der dynamische ATR-Stop ist flexibel und passt den Stop-Loss in Echtzeit an Marktbewegungen an.
Die Regeln der Strategie sind einfach, klar und leicht zu verstehen und umzusetzen.
Die Optimierung der Parameter ist groß und kann für verschiedene Märkte angepasst werden.
Die Rückmeldung ist abgeschlossen, um die Wirksamkeit der Strategie zu überprüfen.
Risikoanalyse
Es kann ein Ausfall des Zentralgravitationsindikators und des SSL-Kanals auftreten, was zu einem Fehlsignal führt. Die Bestätigung kann mit anderen Indikatoren erfolgen.
Dynamische Stop-Losses sind möglicherweise zu radikal und können entsprechend gelockert werden.
Die falsche Auswahl der Rücklaufzeiten kann zu einer schlechten Effektivität der Strategie führen und muss für verschiedene Marktphasen zurückgeprüft werden.
Die Auswirkungen der Transaktionskosten müssen berücksichtigt werden.
Optimierungsrichtung
Verschiedene Parameterkombinationen werden getestet, um die optimale Parameterpaare zu finden.
Optimierung der ATR-Zyklen und der Multiplikatorparameter für dynamische Stop-Losses.
Einführung anderer Indikatoren zur Signalfilterung, wie MACD, KDJ usw.
Die Einführung von maschinellen Lernmodellen hilft dabei, Trends zu bestimmen.
Optimierung der Kapitalverwaltung und Positionskontrolle.
Parameter-Anpassungen und Optimierungen für spezifische Sorten.
Zusammenfassen
Die Strategie kombiniert Zentral-Gravitations- und SSL-Channel-Indikatoren, um Trends zu beurteilen, und nutzt dynamische ATR-Stop-Loss-Control-Risiken. Es ist eine praktikable Trendverfolgungsstrategie. Verbesserungen durch Parameteroptimierung, Einführung anderer Indikatoren und Maschinelles Lernen können die Strategie-Stabilität und die Wirksamkeit in der Praxis weiter verbessern.
/*backtest
start: 2023-08-19 00:00:00
end: 2023-09-13 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
// Thanks to HPotter for the original code for Center of Gravity Backtest
strategy("CoG SSL BF 🚀", overlay=true, 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
/////////////// SSL Channels ///////////////
_1 = input(false, "═════════ SSL ══════════")
len1=input(title="SMA Length 1", defval=12)
len2=input(title="SMA Length 2", defval=13)
smaHigh = sma(high, len1)
smaLow = sma(low, len2)
Hlv = 0
Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? smaHigh : smaLow
sslUp = Hlv < 0 ? smaLow : smaHigh
///////////// Center of Gravity /////////////
_2 = input(false, "═════════ CoG ══════════")
Length = input(25, minval=1)
m = input(5, minval=0)
Percent = input(6, minval=0, title="COG %")
xLG = linreg(close, Length, m)
xLG1r = xLG + ((close * Percent) / 100)
xLG1s = xLG - ((close * Percent) / 100)
pos = 0.0
pos := iff(close > xLG1r, 1, iff(close < xLG1s, -1, nz(pos[1], 0)))
possig = iff(pos == 1, 1, iff(pos == -1, -1, pos))
///////////// Rate Of Change /////////////
_3 = input(false, "══════ Rate of Change ══════")
source = close
roclength = input(2, "ROC Length", minval=1)
pcntChange = input(10, "ROC % Change", minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Srategy ///////////////
long = possig == 1 or (sslUp > sslDown and isMoving())
short = possig == -1 or (sslUp < sslDown 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])
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
/////////////// Dynamic ATR Stop Losses ///////////////
_4 = input(false, "════════ Stop Loss ═══════")
atrLkb = input(1, minval=1, title='ATR Stop Period')
atrMult = input(2, step=0.25, title='ATR Stop Multiplier')
atr1 = atr(atrLkb)
longStop = 0.0
longStop := short_signal ? na : long_signal ? close - (atr1 * atrMult) : longStop[1]
shortStop = 0.0
shortStop := long_signal ? na : short_signal ? close + (atr1 * atrMult) : shortStop[1]
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("L", strategy.long, when=long)
strategy.entry("S", strategy.short, when=short)
strategy.exit("L SL", "L", stop=longStop, when=since_longEntry > 0)
strategy.exit("S SL", "S", stop=shortStop, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
p1 = plot(sslDown, linewidth = 1, color=color.red, title="SSL down")
p2 = plot(sslUp, linewidth = 1, color=color.lime, title="SSL up")
fill(p1, p2, color = not isMoving() ? color.white : sslDown < sslUp ? color.lime : color.red, transp=80)
plot(xLG1r, color=color.lime, title="LG1r")
plot(xLG1s, color=color.red, title="LG1s")
plot(strategy.position_size <= 0 ? na : longStop, title="Long Stop Loss", color=color.yellow, style=plot.style_circles, linewidth=1)
plot(strategy.position_size >= 0 ? na : shortStop, title="Short Stop Loss", color=color.orange, style=plot.style_circles, linewidth=1)
bgcolor(long ? color.green : short ? color.red : not isMoving() ? color.white : na, transp=80)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=60)