Diese Strategie zielt darauf ab, starke Trends auf den Kryptowährungsmärkten zu erfassen, indem mehrere Kanäle und gleitende Durchschnitte verwendet werden, um Trendsignale zu identifizieren, und kombiniert Volumenindikatoren, um falsche Ausbrüche zu filtern, während Verluste anpassungsfähig gestoppt werden, um Gewinne zu erzielen, so dass Gewinne in Trendmärkten erzielt werden können.
Die Strategie verwendet eine Kombination aus schnellem Kanal, langsamem Kanal und schnellem gleitendem Durchschnitt, um Trends zu identifizieren. Die schnellen Kanalparameter sind empfindlicher, um kurzfristige Kursschwankungen zu erfassen; die langsamen Kanalparameter sind gemäßigter, um den großen Trend zu beurteilen; die schnellen gleitenden Durchschnittsparameter befinden sich dazwischen und erzeugen Handelssignale, wenn er durch den Kanal bricht.
Insbesondere berechnet es zuerst die oberen und unteren Schienen des schnellen Kanals und den gleitenden Durchschnitt. Wenn der Preis durch die oberen Schienen bricht, wenn die unteren Schienen des langsamen Kanals auch über dem gleitenden Durchschnitt liegen, wird ein langes Signal erzeugt; umgekehrt, wenn es durch die unteren Schienen bricht, überprüft es, ob die oberen Schienen des langsamen Kanals unter dem gleitenden Durchschnitt liegen und ein kurzes Signal erzeugen.
Darüber hinaus erkennt es das K-Linienmuster, das erfordert, dass mehrere K-Linien in einer Reihenfolge angeordnet werden, um falsche Ausbrüche zu filtern; und berechnet den Indikator für die Kursänderung, um festzustellen, ob er in eine Konsolidierung eingetreten ist, um fehlende Umkehrmöglichkeiten zu vermeiden; und enthält Volumenindikatoren, um sicherzustellen, dass das Volumen dem Preis beim Ausbruch folgt.
Für den Stop-Loss verwendet die Strategie adaptive Stop-Loss. Basierend auf der jüngsten Volatilität passt sie den Stop-Loss-Prozentsatz dynamisch an. Dies ermöglicht es, so viel wie möglich von dem Trendgewinn einzusperren und gleichzeitig einen effektiven Stop-Loss zu gewährleisten.
Der größte Vorteil dieser Strategie besteht darin, dass die Kriterien für die Erzeugung von Handelssignalen relativ streng sind, was nicht-Trend-falsche Ausbrüche effektiv herausfiltern und wirklich Wendepunkte in Markttrends erfassen kann.
Die Kombination aus mehreren Kanälen und gleitenden Durchschnitten hat strengere Kriterien und kann die Wahrscheinlichkeit von Fehleinschätzungen verringern.
Die Validierung der K-Sequenz vermeidet falsche Signale von einer einzigen abweichenden K-Linie.
Durch die Einbeziehung eines Indikators für die Preisänderungsrate kann festgestellt werden, ob eine Konsolidierung eingeleitet wurde, um zu vermeiden, dass Umkehrmöglichkeiten verpasst werden.
Durch das Hinzufügen des Volume-Indikator-Urteils wird sichergestellt, dass Signale nur dann generiert werden, wenn das Volumen dem Preis folgt, wodurch ein ineffektiver Ausbruch vermieden wird.
Der adaptive Stop-Loss-Mechanismus kann das Sperren von Trendgewinnen maximieren und gleichzeitig einen Stop-Loss gewährleisten.
Im Allgemeinen hat diese Strategie die Eigenschaften einer optimierten Konfiguration, einer umsichtigen Entscheidungsfindung, eines adaptiven Stop Loss, was sie sehr geeignet macht, um Trendchancen zu erfassen.
Obwohl diese Strategie bei der Filterung falscher Ausbrüche und der Erfassung von Trends viel optimiert hat, gibt es immer noch einige Risiken zu beachten:
Die komplexen Parameter-Einstellungen können zu großen Unterschieden zwischen Parameterkombinationen führen, was umfangreiche Tests erfordert, um die optimalen Parameter zu finden, da sonst zu viele falsche Signale erzeugt werden können.
Wenn die Lücke zwischen schnellem gleitendem Durchschnitt und Kanal zu klein ist, führt dies dazu, dass häufige Ein- und Ausgänge auftreten, was nicht dazu beiträgt, Trends dauerhaft zu verfolgen.
Die Berechnung des Stop-Loss-Prozentsatzes im adaptiven Stop-Loss-Mechanismus beruht auf einer einfachen Standardabweichung, die bei extremen Marktbedingungen zu einem unzureichenden Stop-Loss führen kann.
Sie ist stark auf technische Indikatoren angewiesen und kann nicht auf wesentliche grundlegende Veränderungen reagieren.
Als Trend-Folge-Strategie ist es in den in den Bandschichten gebundenen unruhigen Märkten unterdurchschnittlich.
Zur Kontrolle dieser Risiken werden folgende Maßnahmen empfohlen:
Führen Sie ausreichende Backtests durch, um optimale Parameterkombinationen zu bestimmen, oder erwägen Sie die Verwendung von maschinellem Lernen für die Parameteroptimierung.
Moderate Erweiterung der Kanalintervalle, Verlängerung der gleitenden Durchschnittszeiten, um unnötige Einträge zu reduzieren.
Überlegen Sie, fortschrittlichere Volatilitätsmodelle wie Hedgefonds-Methoden einzuführen.
Sie sollten sich rechtzeitig auf grundlegende Informationen beziehen, um rein technischen Handel zu vermeiden.
Erhöhen Sie das Urteilsvermögen über Marktzustände und unterbrechen Sie den Handel in unruhigen Märkten.
Die Strategie kann auf folgende Weise weiter optimiert werden:
Einführung von Algorithmen für maschinelles Lernen zur automatischen Optimierung von Parametern durch Erfassung der Parameterleistung in verschiedenen Marktumgebungen zur Erstellung einer Suchtabelle für die dynamische Optimierung.
Hinzufügen von Urteilen über Marktzustände, z. B. Hinzufügen von Modulen, um festzustellen, ob der Markt Trend oder unbeständig ist, und Pause beim Handel in unbeständigen Märkten, um unnötige Verluste zu vermeiden.
Optimieren Sie Stop-Loss-Strategien wie Trailing Stop-Loss, proportional Stop-Loss usw.
Einbeziehung von fundamentalen Faktoren, um bei großen fundamentalen Ereignissen Warnungen auszusenden und Verluste zu vermeiden, die sich ausschließlich auf technische Indikatoren stützen.
Durchführung einer Optimierung des Portfolios und Kombination dieser Strategie mit anderen unabhängigen Strategien zur weiteren Diversifizierung der Risiken.
Einführung eines quantitativen Handelsrahmens für die automatisierte Ausführung von Signalen und eine strenge Risikokontrolle.
Zusammenfassend ist diese Strategie sehr geeignet, um Trendchancen in Kryptowährungsmärkten zu erfassen. Sie verwendet mehrere Kanäle und gleitende Durchschnitte, um Handelssignale zu generieren, und filtert effektiv falsches Breakout-Rauschen aus und sperrt erfolgreich Trendgewinne.
/*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)