Trendausbruchsstrategien
ChaoZhang
Überblick
Die Strategie zielt darauf ab, starke Trends in den Kryptowährungsmärkten zu erfassen, indem sie Multi-Channel- und Moving-Averages verwendet, um Trendbildungssignale zu identifizieren, und kombiniert mit Quantitative Filter, die falsche Durchbrüche anzeigen können, während die Anpassung von Stop-Losses verwendet wird, um Gewinne zu erzielen, die in einem Trendmarkt erzielt werden können.
Strategieprinzip
Die Strategie verwendet eine Kombination aus Fast Channel, Slow Channel und Fast Moving Average, um Trends zu identifizieren. Die Fast Channel-Parameter sind empfindlicher eingestellt, um kurzfristige Preisbewegungen zu erfassen. Die Slow Channel-Parameter sind langsamer, um große Trends zu beurteilen.
Konkret berechnet es zunächst die oberen und unteren Bahnen des schnellen Kanals und den Moving Average. Wenn der Preis die oberen Bahnen durchbricht, erzeugt dies ein Mehr-Signal, wenn die unteren Bahnen des schnellen Kanals auch über dem Moving Average liegen. Umgekehrt erzeugt das Unterbrechen des Untergangs ein Abstandssignal, um zu beurteilen, ob die oberen Bahnen des schnellen Kanals unter dem Moving Average liegen.
Darüber hinaus erkennt es die K-Linie-Form und verlangt eine Reihe von K-Linien, die in einer Reihenfolge angeordnet sind, um falsche Durchbrüche zu filtern. Es berechnet auch die Preisdynamik-Indikatoren, um zu vermeiden, dass der Markt in den Schwingungen des Kanals gefangen ist.
Bei Stop-Loss verwendet die Strategie einen adaptiven Stop-Loss. Die Stop-Loss-Grenze wird dynamisch angepasst, um die Schwankungen in der letzten Zeit zu berücksichtigen. Dies ermöglicht es, so viel wie möglich zurückzuverfolgen, während die Stop-Loss-Garantie gegeben ist.
Analyse der Stärken
Der größte Vorteil dieser Strategie besteht darin, dass die Regeln für die Bildung von Handelssignalen strenger sind und nicht-trendige Falschbrüche effektiv filtern und Trendwendepunkte wirklich erfassen können. Insbesondere gibt es folgende Aspekte:
Die Kombination von Multi-Channel- und Moving-Average-Kombinationen, die strengere Beurteilungsstandards haben, reduzieren die Wahrscheinlichkeit von Fehlentscheidungen.
K-Linien werden in der Reihenfolge geprüft, um zu vermeiden, dass ein einziger isometrischer K-Linienfehler auftritt.
In Kombination mit dem Preisveränderungsindikator kann ermittelt werden, ob ein Ausgleich eingeleitet wird, um eine verpasste Chance auf eine Umkehr zu vermeiden.
Wenn die Messung mit dem Quantifizierungskennzeichen erfolgt, wird nur ein Signal erzeugt, das mit der Quantifizierung einhergeht, um einen ungültigen Durchbruch zu vermeiden.
Die Anpassung von Stop-Loss-Mechanismen ermöglicht es, Trendgewinne maximal zu lockern, wenn die Stop-Loss-Garantie gegeben ist.
Daher ist die Strategie als Ganzes, mit ihren Eigenschaften wie Konfigurationsoptimierung, Entscheidungsgefühl und Schadensabhängigkeit, ideal, um Trends zu erfassen.
Risikoanalyse
Obwohl die Strategie bei der Filterung von Fake-Break- und Abhörtrends optimiert wurde, gibt es einige Risiken, die zu beachten sind:
Die Parameter sind zu kompliziert eingestellt, die Wirkung der verschiedenen Parameterkombinationen ist sehr unterschiedlich, die optimale Parameter müssen nach einer Vielzahl von Tests gefunden werden, und die falsche Einstellung kann zu viele Fehlsignale erzeugen.
Schnelle Durchschnitte und Durchgangsspalten über die Stunde sind anfällig für häufige Positionseröffnungen und Schließungen, die nicht für eine dauerhafte Verfolgung des Trends geeignet sind.
Die Berechnung der Stop-Loss-Grenze des Adaptive Stop-Mechanismus basiert auf einer einfachen Standarddifferenz, die für Extremsituationen möglicherweise zu gering ist.
Das Unternehmen ist zu stark von technischen Indikatoren abhängig und kann nicht auf grundlegende Veränderungen reagieren.
Diese Strategie gehört zu den Trend-Tracking-Strategien, die in einem konjunkturell schwankenden Markt schlechter abschneiden.
Angesichts dieser Risiken empfiehlt es sich, folgende Maßnahmen zu ergreifen:
Es kann auch eine Optimierung der Parameter mit Methoden wie maschinellem Lernen in Betracht gezogen werden.
Durch eine angemessene Erweiterung des Kanalintervalls und eine angemessene Verlängerung der Moving Average-Periode kann die unnötige Häufigkeit von Lageröffnungen verringert werden.
Die Einführung von fortschrittlicheren Modellen zur Berechnung der Volatilitätsrate wie etwa von Hedgefonds kann in Erwägung gezogen werden.
Verwenden Sie grundlegende Informationen, um zu vermeiden, dass Sie nur mit technischen Indikatoren handeln.
Es ist wichtig, dass die Verbraucher sich über die Lage des Marktes informieren und den Handel in den unruhigen Märkten unterbrechen.
Optimierungsrichtung
Die Strategie kann noch weiter optimiert werden:
Die automatische Optimierung von Parametern durch die Zugabe von Machine Learning-Algorithmen. Die Parameter können in verschiedenen Marktumgebungen aufgezeichnet werden, um eine Abfrage zu erstellen und eine dynamische Optimierung durchzuführen.
Erhöhung der Beurteilung der Marktsituation, wie z. B. die Beurteilung, ob die Situation ein Trend ist oder ein Schwingungsmodul, und die Unterbrechung des Handels in einem schwingenden Markt, um unnötige Verluste zu vermeiden.
Optimieren Sie Ihre Stop-Loss-Strategie, indem Sie andere Stop-Loss-Methoden wie Tracking-Stopps, Proportion-Stopps und andere erwägen.
Die Einbeziehung von Fundamentaldaten, Warnungen bei einem fundamentalen Ereignis, um zu vermeiden, dass nur technische Indikatoren zu Verlusten führen.
Eine Kombinationsoptimierung, bei der die Strategie mit anderen nicht relevanten Strategien kombiniert wird, kann das Risiko weiter ausbreiten.
Das System wurde in den USA eingeführt, um den Handel zu quantifizieren, die Signale automatisch auszuführen und die Risiken zu kontrollieren.
Zusammenfassen
Insgesamt ist die Strategie sehr gut geeignet, um Trendchancen in den Kryptowährungsmärkten zu erfassen. Sie verwendet mehrere Kanäle und bewegliche Durchschnitte, um Handelssignale zu erzeugen und filtert effektiv den Lärm falscher Durchbrüche, um die Trendgewinne zu sperren. Allerdings ist es wichtig, die Parameteroptimierung, die Stop-Loss-Methode und die Beurteilung der Marktlage zu berücksichtigen.
/*backtest
start: 2022-09-21 00:00:00
end: 2023-09-27 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("Extremely Overfit", overlay=true, commission_type=strategy.commission.percent, commission_value=.16, default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding = 1)
price = close
goLong = input(title="go long?", type=input.bool, defval=true)
goShort = input(title="go short?", type=input.bool, defval=true)
//trendRestrict = input(title="basic trend restriction?", type=input.bool, defval=false)
dynamicRestrict = true //input(title="dynamic trend restriction?", type=input.bool, defval=true)
longtrendimpt = true //input(title="additional weight on long-term trends?", type=input.bool, defval=true)
volRestrict = true //input(title="volume restriction?", type=input.bool, defval=true)
conservativeClose = false //input(title="conservative order closing?", type=input.bool, defval=false)
Restrictiveness = input ( -40,step=10,title ="Restrictiveness (higher = make fewer trades)")
volatilityImportance = 3.2 //input( 3.2, step = 0.1, minval = 0)
fastChannelLength = input( 6 )
fastChannelMargin = input ( 3.2, step = 0.1, minval = 0)
slowChannelLength = input ( 6, step = 1, minval = 0)
slowChannelMargin = input ( 1.5, step = 0.1, minval = 0)
fastHMAlength = input (4, step = 1, minval = 0)
stopLoss = input( 3, step = 0.1, minval = 0)
//altClosePeriod = input( 27, step = 1, minval = 1)
//altCloseFactor = input( 4.9, step = 0.1)
stopLossFlexibility = 50 //input(50, step=10, title="effect of volatility on SL?")
volumeMAlength = 14 //input ( 14, step = 1, minval = 1)
volumeVolatilityCutoff = 3.8 // ( 3.8, step = 1, minval = 0)
trendSensitivity = 3.8 //input ( 3.8, step = 0.1)
obvLookback = 10 //input(10, step = 10, minval = 10)
obvCorrThreshold = 0.89 //input(0.89, step = 0.01)
ROClength = 80 //input( 80, step = 10)
ROCcutoff = 5.6 //input( 5.6, step=0.1)
trendRestrict = false
//trendLookback = input ( 360, step = 10, minval = 10)
//longTrendLookback = input(720, step = 10, minval = 10)
//longTrendImportance = input(1.5, step = 0.05)
trendLookback = 360
longTrendLookback = 720
longTrendImportance = 1.5
//conservativeness = input( 2.4, step = 0.1)
conservativeness = 0
//trendPower = input( 0, step=1)
trendPower = 0
//conservativenessLookback = input( 650, step = 10, minval = 0)
conservativenessLookback = 10
//consAffectFactor = input( 0.85,step=0.01)
consAffectFactor = 0.85
//volatilityLookback = input(50, step=1, minval=2)
volatilityLookback = int(50)
recentVol = stdev(price,volatilityLookback)/sqrt(volatilityLookback)
//price channel
fastChannel = ema(price, fastChannelLength)
fastChannelUB = fastChannel * (1 + (float(fastChannelMargin) / 1000)) + (recentVol * (float(volatilityImportance) * (1 + (Restrictiveness/100))))
fastChannelLB = fastChannel * (1 - (float(fastChannelMargin) / 1000)) - (recentVol * (float(volatilityImportance) * (1 + (Restrictiveness/100))))
fchU = ((fastChannelUB < open) and (fastChannelUB < close))
fchL = ((fastChannelLB > open) and (fastChannelLB > close))
//plot(fastChannelUB)
//plot(fastChannelLB)
//slow channel
//slowChannelLBmargin = input ( 2, step = 0.1, minval = 0 )
slowChannel = ema(ema(price,slowChannelLength),slowChannelLength)
slowChannelUB = slowChannel * (1 + (float(slowChannelMargin) / 2000)) + (recentVol * (float(volatilityImportance) * (1 + (Restrictiveness/100))))
slowChannelLB = slowChannel * (1 - (float(slowChannelMargin) / 2000)) - (recentVol * (float(volatilityImportance) * (1 + (Restrictiveness/100))))
schU = ((slowChannelUB < close))
schL = ((slowChannelLB > close))
cschU = (((slowChannelUB * (1 + conservativeness)) < close))
cschL = (((slowChannelUB * (1 - conservativeness)) > close))
//plot(slowChannel,color = #00FF00)
//plot(slowChannelUB,color = #00FF00)
//plot(slowChannelLB,color = #00FF00)
fastHMA = hma(price,fastHMAlength)
fastAboveUB = (fastHMA > slowChannelUB)
fastBelowLB = (fastHMA < slowChannelLB)
//plot(fastHMA, color = #FF0000, linewidth = 2)
//consecutive candles
//consecutiveCandlesReq = input(1, step = 1, minval = 1, maxval = 4)
consecutiveCandlesReq = 1
consecutiveBullReq = float(consecutiveCandlesReq)
consecutiveBearReq = float(consecutiveCandlesReq)
cbull = ((close[0] > close[1]) and (consecutiveBullReq == 1)) or (((close[0] > close[1]) and (close[1] > close[2])) and consecutiveBullReq == 2) or (((close[0] > close[1]) and (close[1] > close[2]) and (close[2] > close[3])) and consecutiveBullReq == 3) or (((close[0] > close[1]) and (close[1] > close[2]) and (close[2] > close[3]) and (close[3] > close[4])) and consecutiveBullReq == 4)
cbear = ((close[0] < close[1]) and (consecutiveBearReq == 1)) or (((close[0] < close[1]) and (close[1] < close[2])) and consecutiveBearReq == 2) or (((close[0] < close[1]) and (close[1] < close[2]) and (close[2] < close[3])) and consecutiveBearReq == 3) or (((close[0] < close[1]) and (close[1] < close[2]) and (close[2] < close[3]) and (close[3] < close[4])) and consecutiveBearReq == 4)
//trend detection
//trendCutoff = input(0, step = 0.1)
trendCutoff = 0
trendDetectionPct = float(trendCutoff/100)
trendVal = float((close[0] - close[trendLookback])/close[0])
trendUp = (trendVal > (0 + trendDetectionPct))
trendDown = (trendVal < (0 - trendDetectionPct))
//plot(trendVal+36.5,linewidth=2)
// peak indicators
peakHigh = ((fastHMA > fastChannelUB) and (fastChannelLB > slowChannelUB))
peakLow = ((fastHMA < fastChannelLB) and (fastChannelUB < slowChannelLB))
TpeakHigh = (fastHMA > fastChannelUB) and (fastChannelUB > slowChannelUB)
TpeakLow = (fastHMA < fastChannelUB) and (fastChannelLB < slowChannelLB)
//TpeakHigh = (fastHMA > fastChannelUB) and (fastChannelLB > avg(slowChannelUB,slowChannelLB))
//TpeakLow = (fastHMA < fastChannelUB) and (fastChannelUB < avg(slowChannelLB,slowChannelUB))
//TpeakHigh = ((crossover(fastHMA,fastChannelUB)) and (fastChannelLB > slowChannelUB))
//TpeakLow = ((crossover(fastChannelLB,fastHMA)) and (fastChannelUB < slowChannelLB))
//TpeakHigh = (fastHMA > (fastChannelUB * (1 + (trendPower/800)))) and (fastChannelUB > (slowChannelUB * (1 + (trendPower/800))))
//TpeakLow = (fastHMA < (fastChannelUB * (1 - (trendPower/800)))) and (fastChannelLB < (slowChannelLB * (1 - (trendPower/800))))
//TpeakHigh = (fastHMA > (fastChannelUB * (1 + (trendPower/800)))) and (avg(fastChannelUB,fastChannelLB) > (slowChannelUB * (1 + (trendPower/800))))
//TpeakLow = (fastHMA < (fastChannelUB * (1 - (trendPower/800)))) and (avg(fastChannelLB,fastChannelUB) < (slowChannelLB * (1 - (trendPower/800))))
//plot(fastChannelUB * (1 + (trendPower/700)), color=#FF69B4)
// and for closing...
closeLong = (crossover(fastHMA,fastChannelUB) and (fastChannelLB > slowChannelUB))
closeShort = (crossover(fastChannelLB,fastHMA) and (fastChannelUB < slowChannelLB))
//closeLong = (crossover(fastHMA,fastChannelUB) and (fastChannelLB > slowChannelUB)) or (roc(price,altClosePeriod) > altCloseFactor)
//closeShort = (crossover(fastChannelLB,fastHMA) and (fastChannelUB < slowChannelLB)) or (roc(price,altClosePeriod) < (altCloseFactor) * -1)
//closeLong = (crossover(fastHMA,fastChannelUB) and (fastChannelLB > slowChannelUB)) or (((price - fastChannelUB) > (altCloseFactor * abs(((fastChannelUB - fastChannelLB)/2) - ((slowChannelUB - slowChannelLB)/2)))) and (fastChannelLB > slowChannelUB))
//closeShort = (crossover(fastChannelLB,fastHMA) and (fastChannelUB < slowChannelLB)) or (((fastChannelLB - price) > (altCloseFactor * abs(((fastChannelUB - fastChannelLB)/2) - ((slowChannelUB - slowChannelLB)/2)))) and (fastChannelUB < slowChannelLB))
//closeLong = crossover(fastHMA,fastChannelUB) and ((fastChannelLB[0] - fastChannelLB[1]) < (slowChannelUB[0] - slowChannelUB[1]))
//closeShort = crossover(fastChannelLB,fastHMA) and ((fastChannelUB[0] - fastChannelUB[1]) > (slowChannelLB[0] - slowChannelLB[1]))
//stop-loss
priceDev = stdev(price,trendLookback) * (1 + stopLossFlexibility/5)
stopLossMod = stopLoss * (1 + (priceDev/price))
//longStopPrice = strategy.position_avg_price * (1 - (stopLoss/100))
//shortStopPrice = strategy.position_avg_price * (1 + (stopLoss/100))
longStopPrice = strategy.position_avg_price * (1 - (stopLossMod/100))
shortStopPrice = strategy.position_avg_price * (1 + (stopLossMod/100))
// volume
volumeMA = ema(volume,volumeMAlength)
volumeDecrease = ((not volRestrict ) or (volumeMA[0] < ema(volumeMA[1] * (1 - (volumeVolatilityCutoff/100)),5)))
volumeCutoff = ema(volumeMA[1] * (1 - (volumeVolatilityCutoff/100)),5)
//plot(volumeMA)
//plot(volumeCutoff)
// detect volatility
//trendinessLookback = input ( 600, step = 10, minval = 0)
trendinessLookback = trendLookback
trendiness = (stdev(price,trendinessLookback)/price) * (1 - (Restrictiveness/100))
longtermTrend = ((price - price[longTrendLookback])/price)
//dynamicTrendDetected = (dynamicRestrict and (abs(trendiness * 100) < trendSensitivity))
dynamicTrendDetected = (longtrendimpt and (dynamicRestrict and (abs(trendiness * 100) < (trendSensitivity+(longtermTrend * longTrendImportance))))) or (not longtrendimpt and ((dynamicRestrict and (abs(trendiness * 100) < trendSensitivity))))
// adapt conservativeness to volatility
//consVal = sma(((stdev(price,conservativenessLookback))/price)*100,25)
consVal = sma(((stdev(price,conservativenessLookback))/price)*100,25)
cVnorm = sma(avg(consVal,3),60)
cVal = consVal - cVnorm
//conservativenessMod = conservativeness * (cVal * consAffectFactor)
conservativenessMod = conservativeness * (consVal * consAffectFactor)
//plot(consVal,linewidth=4)
//plot(cVnorm,color = #00FF00)
//plot(cVal,linewidth=2)
// ROC cutoff (for CLOSING)
//rocCloseLong = (ema(roc(price,ROClength),10) > ROCcutoff)
//rocCloseShort = (ema(roc(price,ROClength),10) < (ROCcutoff * -1))
ROCval = roc(price,ROClength)
ROCema = ema(ROCval,30)
ROCabs = abs(ROCema)
ROCallow = ROCabs < ROCcutoff
ROCallowLong = (ROCabs < ROCcutoff) or ((ROCabs >= ROCcutoff) and ((fastChannelLB < slowChannelLB) and (fastHMA < fastChannelLB)))
ROCallowShort = (ROCabs < ROCcutoff) or ((ROCabs >= ROCcutoff) and ((fastChannelUB > slowChannelUB) and (fastHMA > fastChannelUB)))
//plot(ROCallow)
// obv
evidence_obv = (correlation(price,obv[0],obvLookback))
obvAllow = evidence_obv > obvCorrThreshold
//if (not na(vrsi))
if trendRestrict or dynamicTrendDetected
//if (strategy.position_size == 0)
if not (strategy.position_size < 0)
if trendUp
//if cbear and schL and fchL and trendUp and goLong
if cbear and TpeakLow and volumeDecrease and ROCallow and goLong and obvAllow
//if cbear and peakLow and rocHigh and volumeDecrease and goLong
strategy.entry("Long", strategy.long, comment="Long")
if not (strategy.position_size > 0)
if trendDown
//if cbull and schU and fchU and trendDown and goShort
if cbull and TpeakHigh and volumeDecrease and ROCallow and goShort and obvAllow
//if cbull and peakHigh and rocLow and volumeDecrease and goShort
strategy.entry("Short", strategy.short, comment="Short")
else
//if (strategy.position_size == 0)
if not (strategy.position_size < 0)
//if cbear and peakLow and goLong
//if cbear and peakLow and volumeDecrease and ROCallow and goLong
if TpeakLow and goLong and obvAllow
strategy.entry("Long", strategy.long, comment="Long")
if not (strategy.position_size > 0)
//if cbull and peakHigh and goShort
//if cbull and peakHigh and volumeDecrease and ROCallow and goShort
if TpeakHigh and goShort and obvAllow
strategy.entry("Short", strategy.short, comment="Short")
if conservativeClose
//pkHigh = ((fastHMA > fastChannelUB) and (fastChannelUB > (slowChannelUB * (1 + conservativeness/1000))))
//pkLow = ((fastHMA < fastChannelLB) and (fastChannelLB < (slowChannelLB * (1 - conservativeness/1000))))
//pkHigh = ((fastHMA > fastChannelUB) and (fastChannelUB > (slowChannelUB * (1 + conservativenessMod/1000))))
//pkLow = ((fastHMA < fastChannelLB) and (fastChannelLB < (slowChannelLB * (1 - conservativenessMod/1000))))
pkHigh = ((fastHMA > fastChannelUB) and (fastChannelUB > (slowChannelUB * (1 + ((conservativenessMod/1000) * (1 - Restrictiveness/100))))))
pkLow = ((fastHMA < fastChannelLB) and (fastChannelLB < (slowChannelLB * (1 - ((conservativenessMod/1000) * (1 - Restrictiveness/100))))))
if (strategy.position_size > 0)
//if fastAboveUB
//if pkHigh and closeLong
if closeLong
strategy.close("Long", comment="closeLong")
if (strategy.position_size < 0)
//if fastBelowLB
//if pkLow and closeShort
if closeShort
strategy.close("Short", comment="closeShort")
else
if (strategy.position_size > 0)
//if fastAboveUB
if peakHigh
strategy.close("Long", comment="closeLong")
if (strategy.position_size < 0)
//if fastBelowLB
if peakLow
strategy.close("Short", comment="closeShort")
if (strategy.position_size > 0)
strategy.exit(id="Long", stop=longStopPrice, comment="stopLong")
if (strategy.position_size < 0)
strategy.exit(id="Short", stop=shortStopPrice, comment="stopShort")
//plot(strategy.equity, title="equity", color=color.red, linewidth=2, style=plot.style_areabr)