Hochfrequente Kryptowährungshandelsstrategie, die TrippleMACD Crossover und Relative Strength Index kombiniert

Schriftsteller:ChaoZhang, Datum: 2024-03-22
Tags:

Übersicht

Dieser Artikel stellt eine Hochfrequenz-Kryptowährungshandelsstrategie vor, die den TrippleMACD-Crossover mit dem Relative Strength Index (RSI) kombiniert. Die Strategie verwendet drei Sätze von MACD-Indikatoren mit verschiedenen Parametern und ermittelt ihre Signallinien im Durchschnitt, während sie auch den RSI-Indikator enthält, um optimale Kauf- und Verkaufszeiten zu bestimmen. Die Strategie ist für den automatisierten Handel in einem Zeitrahmen von 1 Minute konzipiert, wobei nur lange Trades berücksichtigt werden. Darüber hinaus nutzt die Strategie die lineare Regression, um Konsolidierungsphasen auf dem Markt zu identifizieren und Trades bei unruhigen Marktbedingungen zu vermeiden.

Strategieprinzip

Der Kern dieser Strategie besteht darin, drei Sätze von MACD-Indikatoren mit unterschiedlichen Parametern zu verwenden, um Trendsignale auf verschiedenen Zeitskalen zu erfassen. Durch das Durchschnitten der Signallinien dieser drei MACD-Indikatoren kann das Rauschen effektiv ausgeglichen werden und zuverlässigere Handelssignale bereitgestellt werden. Gleichzeitig wird der RSI-Indikator verwendet, um die Stärke der bullischen Trends zu bestätigen. Die Strategie erzeugt ein Kaufsignal nur, wenn alle drei MACD-Indikatoren bullische Signale zeigen und der RSI-Indikator auch die Stärke des bullischen Trends bestätigt.

Darüber hinaus verwendet die Strategie eine lineare Regression, um Konsolidierungsphasen auf dem Markt zu identifizieren. Durch die Berechnung des Verhältnisses der oberen und unteren Schattenlängen zur Körperlänge von Kerzen kann festgestellt werden, ob sich der aktuelle Markt in einem Konsolidierungszustand befindet. Wenn die Länge der oberen und unteren Schatten mehr als doppelt so groß ist wie die Länge des Körpers, gilt der Markt als in einer Konsolidierungsphasen, und die Strategie wird den Handel während dieser Zeit vermeiden.

Analyse der Vorteile

Multi-Timeframe-Analyse: Durch die Verwendung von drei Sätzen von MACD-Indikatoren mit verschiedenen Parametern kann die Strategie Trendsignale auf verschiedenen Zeiträumen erfassen und so die Genauigkeit und Zuverlässigkeit der Trades verbessern.
Signalglättung: Durchschnittliche Messung der Signallinien der drei MACD-Indikatoren verringert das Rauschen und vermeidet irreführende Signale, die von einem einzigen Indikator erzeugt werden können.
Trendbestätigung: Die Einbeziehung des RSI-Indikators zur Bestätigung der Stärke von Aufwärtstrends erhöht die Zuverlässigkeit der Handelssignale weiter.
Identifizierung der Konsolidierung: Die Verwendung der linearen Regression zur Identifizierung der Konsolidierungsphasen auf dem Markt ermöglicht es der Strategie, den Handel unter unruhigen Marktbedingungen zu vermeiden und das Risiko der Strategie zu reduzieren.
Automatisierter Handel: Die Strategie ist für den automatisierten Handel in einem Zeitrahmen von 1 Minute konzipiert und ermöglicht eine schnelle Reaktion auf Marktveränderungen und eine effiziente Handelsausführung.

Risikoanalyse

Parameteroptimierung: Die Strategie beinhaltet mehrere Parameter, wie die schnellen und langsamen Linienperioden der drei MACD-Indikatoren und die Periode des RSI-Indikators. Die Auswahl dieser Parameter hat einen signifikanten Einfluss auf die Performance der Strategie. Wenn die Parameter nicht richtig optimiert werden, kann die Performance der Strategie abnehmen.
Überanpassungsrisiko: Die Strategie kann bei bestimmten historischen Daten gut abschneiden, sich aber möglicherweise nicht an die Marktveränderungen bei der tatsächlichen Anwendung anpassen, was zu einem Strategieversagen führt.
Black-Swan-Ereignisse: Die Strategie stützt sich in erster Linie auf technische Indikatoren und reagiert möglicherweise nicht ausreichend auf signifikante fundamentale Ereignisse, was zu schlechten Ergebnissen bei extremen Marktbedingungen führen könnte.

Optimierungsrichtung

Dynamische Anpassung der Parameter: Dynamische Anpassung der Parameter der Strategie, wie z. B. der schnellen und langsamen Zeilen der MACD-Indikatoren und der Periode des RSI-Indikators, basierend auf Veränderungen der Marktbedingungen, um sich an unterschiedliche Marktumgebungen anzupassen.
Einbeziehung zusätzlicher Indikatoren: Zusätzlich zu den bestehenden MACD- und RSI-Indikatoren sollten weitere technische Indikatoren wie Bollinger-Bänder und gleitende Durchschnitte berücksichtigt werden, um die Genauigkeit und Zuverlässigkeit der Handelssignale weiter zu verbessern.
Optimierung des Risikomanagements: Umfassendere Risikomanagementmaßnahmen in der Strategie wie dynamisches Stop-Loss- und Positionsmanagement umzusetzen, um das Gesamtrisiko der Strategie zu reduzieren.
Optimierung des maschinellen Lernens: Verwenden Sie maschinelle Lernalgorithmen wie neuronale Netzwerke und unterstützende Vektormaschinen, um die Parameter und Handelsregeln der Strategie zu optimieren und die Anpassungsfähigkeit und Robustheit der Strategie zu verbessern.

Schlussfolgerung

Dieser Artikel stellt eine Hochfrequenz-Kryptowährungshandelsstrategie vor, die den TrippleMACD-Crossover mit dem RSI-Indikator kombiniert. Die Strategie verwendet drei Sätze von MACD-Indikatoren mit verschiedenen Parametern und den RSI-Indikator, um zuverlässige Handelssignale zu generieren, während lineare Regression zur Identifizierung von Konsolidierungsphasen auf dem Markt verwendet wird, um Trades bei unruhigen Marktbedingungen zu vermeiden. Die Vorteile der Strategie liegen in der Multi-Timeframe-Analyse, Signalglättung, Bestätigung, Konsolidierungstrend-Identifizierung und automatisierter Handelsrisiken.

/*backtest
start: 2024-02-01 00:00:00
end: 2024-02-29 23:59:59
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=5
//indicator("Triplle",shorttitle="Triplle MACD", overlay=true, scale = scale.none)
//indicator("Triplle","TrippleMACD",true)
strategy(title="TrippleMACD", shorttitle="TrippleMACD + RSI strategy", format=format.price, precision=4, overlay=true)

// RSI 
ma(source, length, type) =>
    switch type
        "SMA" => ta.sma(source, length)
        "Bollinger Bands" => ta.sma(source, length)
        "EMA" => ta.ema(source, length)
        "SMMA (RMA)" => ta.rma(source, length)
        "WMA" => ta.wma(source, length)
        "VWMA" => ta.vwma(source, length)

rsiLengthInput = input.int(14, minval=1, title="RSI Length", group="RSI Settings")
rsiSourceInput = input.source(close, "Source", group="RSI Settings")
maTypeInput = input.string("SMA", title="MA Type", options=["SMA", "Bollinger Bands", "EMA", "SMMA (RMA)", "WMA", "VWMA"], group="MA Settings")
maLengthInput = input.int(14, title="MA Length", group="MA Settings")
bbMultInput = input.float(2.0, minval=0.001, maxval=50, title="BB StdDev", group="MA Settings")
showDivergence = input.bool(false, title="Show Divergence", group="RSI Settings")

up = ta.rma(math.max(ta.change(rsiSourceInput), 0), rsiLengthInput)
down = ta.rma(-math.min(ta.change(rsiSourceInput), 0), rsiLengthInput)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))
rsiMA = ma(rsi, maLengthInput, maTypeInput)
isBB = maTypeInput == "Bollinger Bands"

//rsiPlot = plot(rsi, "RSI", color=#7E57C2)
//plot(rsiMA, "RSI-based MA", color=color.yellow)
//rsiUpperBand = hline(70, "RSI Upper Band", color=#787B86)
//midline = hline(50, "RSI Middle Band", color=color.new(#787B86, 50))
//rsiLowerBand = hline(30, "RSI Lower Band", color=#787B86)
//fill(rsiUpperBand, rsiLowerBand, color=color.rgb(126, 87, 194, 90), title="RSI Background Fill")
bbUpperBand = plot(isBB ? rsiMA + ta.stdev(rsi, maLengthInput) * bbMultInput : na, title = "Upper Bollinger Band", color=color.green)
bbLowerBand = plot(isBB ? rsiMA - ta.stdev(rsi, maLengthInput) * bbMultInput : na, title = "Lower Bollinger Band", color=color.green)
//fill(bbUpperBand, bbLowerBand, color= isBB ? color.new(color.green, 90) : na, title="Bollinger Bands Background Fill")

//midLinePlot = plot(50, color = na, editable = false, display = display.none)
//fill(rsiPlot, midLinePlot, 100, 70, top_color = color.new(color.green, 0), bottom_color = color.new(color.green, 100),  title = "Overbought Gradient Fill")
//fill(rsiPlot, midLinePlot, 30,  0,  top_color = color.new(color.red, 100), bottom_color = color.new(color.red, 0),      title = "Oversold Gradient Fill")

// Divergence
lookbackRight = 5
lookbackLeft = 5
rangeUpper = 60
rangeLower = 5
bearColor = color.red
bullColor = color.green
textColor = color.white
noneColor = color.new(color.white, 100)

plFound = na(ta.pivotlow(rsi, lookbackLeft, lookbackRight)) ? false : true
phFound = na(ta.pivothigh(rsi, lookbackLeft, lookbackRight)) ? false : true
_inRange(cond) =>
	bars = ta.barssince(cond == true)
	rangeLower <= bars and bars <= rangeUpper

//------------------------------------------------------------------------------
// Regular Bullish
// rsi: Higher Low

rsiHL = rsi[lookbackRight] > ta.valuewhen(plFound, rsi[lookbackRight], 1) and _inRange(plFound[1])

// Price: Lower Low

priceLL = low[lookbackRight] < ta.valuewhen(plFound, low[lookbackRight], 1)
bullCondAlert = priceLL and rsiHL and plFound
bullCond = showDivergence and bullCondAlert

// plot(
//      plFound ? rsi[lookbackRight] : na,
//      offset=-lookbackRight,
//      title="Regular Bullish",
//      linewidth=2,
//      color=(bullCond ? bullColor : noneColor)
//      )

// plotshape(
// 	 bullCond ? rsi[lookbackRight] : na,
// 	 offset=-lookbackRight,
// 	 title="Regular Bullish Label",
// 	 text=" Bull ",
// 	 style=shape.labelup,
// 	 location=location.absolute,
// 	 color=bullColor,
// 	 textcolor=textColor
// 	 )

//------------------------------------------------------------------------------
// Regular Bearish
// rsi: Lower High

rsiLH = rsi[lookbackRight] < ta.valuewhen(phFound, rsi[lookbackRight], 1) and _inRange(phFound[1])

// Price: Higher High

priceHH = high[lookbackRight] > ta.valuewhen(phFound, high[lookbackRight], 1)

bearCondAlert = priceHH and rsiLH and phFound
bearCond = showDivergence and bearCondAlert

// plot(
// 	 phFound ? rsi[lookbackRight] : na,
// 	 offset=-lookbackRight,
// 	 title="Regular Bearish",
// 	 linewidth=2,
// 	 color=(bearCond ? bearColor : noneColor)
// 	 )

// plotshape(
// 	 bearCond ? rsi[lookbackRight] : na,
// 	 offset=-lookbackRight,
// 	 title="Regular Bearish Label",
// 	 text=" Bear ",
// 	 style=shape.labeldown,
// 	 location=location.absolute,
// 	 color=bearColor,
// 	 textcolor=textColor
// 	 )
// END RSI

// Getting inputs
stopLuse          = input(1.040)
fast_length = input(title = "Fast Length", defval = 5)
slow_length = input(title = "Slow Length", defval = 8)
fast_length2 = input(title = "Fast Length2", defval = 13)
slow_length2 = input(title = "Slow Length2", defval = 21)
fast_length3 = input(title = "Fast Length3", defval = 34)
slow_length3 = input(title = "Slow Length3", defval = 144)
fast_length4 = input(title = "Fast Length3", defval = 68)
slow_length4 = input(title = "Slow Length3", defval = 288)
src = input(title = "Source", defval = close)
signal_length2 = input.int(title="Signal Smoothing", minval = 1, maxval = 200, defval = 11)
signal_length = input.int(title = "Signal Smoothing",  minval = 1, maxval = 50, defval = 9)
sma_source = input.string(title = "Oscillator MA Type",  defval = "EMA", options = ["SMA", "EMA"])
sma_signal = input.string(title = "Signal Line MA Type", defval = "EMA", options = ["SMA", "EMA"])
// Calculating
fast_ma = sma_source == "SMA" ? ta.sma(src, fast_length) : ta.ema(src, fast_length)
slow_ma = sma_source == "SMA" ? ta.sma(src, slow_length) : ta.ema(src, slow_length)

fast_ma2 = sma_source == "SMA2" ? ta.sma(src, fast_length2) : ta.ema(src, fast_length2)
slow_ma2 = sma_source == "SMA2" ? ta.sma(src, slow_length2) : ta.ema(src, slow_length2)

fast_ma3 = sma_source == "SMA3" ? ta.sma(src, fast_length3) : ta.ema(src, fast_length3)
slow_ma3 = sma_source == "SMA3" ? ta.sma(src, slow_length3) : ta.ema(src, slow_length3)

fast_ma4 = sma_source == "SMA3" ? ta.sma(src, fast_length3) : ta.ema(src, fast_length3)
slow_ma4 = sma_source == "SMA3" ? ta.sma(src, slow_length3) : ta.ema(src, slow_length3)

macd = fast_ma - slow_ma
macd2 = fast_ma2 - slow_ma2
macd3 = fast_ma3 - slow_ma3
macd4 = fast_ma4 - slow_ma4

signal = sma_signal == "SMA" ? ta.sma(macd, signal_length) : ta.ema(macd, signal_length)
signal2 = sma_signal == "SMA" ? ta.sma(macd2, signal_length) : ta.ema(macd2, signal_length)
signal3 = sma_signal == "SMA" ? ta.sma(macd3, signal_length) : ta.ema(macd3, signal_length)
signal4 = sma_signal == "SMA" ? ta.sma(macd4, signal_length) : ta.ema(macd4, signal_length)
//hist = (macd + macd2 + macd3)/1 - (signal + signal2 + signal3)/1
hist = (macd + macd2 + macd3 + macd4)/4 - (signal + signal2 + signal3 + signal4)/4
signal5 = (signal + signal2 + signal3)/3

sma_signal2 = input.bool(title="Simple MA (Signal Line)", defval=true)

lin_reg = input.bool(title="Lin Reg", defval=true)
linreg_length = input.int(title="Linear Regression Length", minval = 1, maxval = 200, defval = 11)

bopen = lin_reg ? ta.linreg(open, linreg_length, 0) : open
bhigh = lin_reg ? ta.linreg(high, linreg_length, 0) : high
blow = lin_reg ? ta.linreg(low, linreg_length, 0) : low
bclose = lin_reg ? ta.linreg(close, linreg_length, 0) : close

shadow = (bhigh - bclose) + (bopen - blow)
body = bclose - bopen
perc = (shadow/body)
cond2 = perc >=2 and bclose+bclose[1]/2 > bopen+bopen[1]/2

r = bopen < bclose

//signal5 = sma_signal2 ? ta.sma(bclose, signal_length) : ta.ema(bclose, signal_length)
plotcandle(r ? bopen : na, r ? bhigh : na, r ? blow: na, r ? bclose : na, title="LinReg Candles", color= color.green, wickcolor=color.green, bordercolor=color.green, editable= true)
plotcandle(r ? na : bopen, r ? na : bhigh, r ? na : blow, r ? na : bclose, title="LinReg Candles", color=color.red, wickcolor=color.red, bordercolor=color.red, editable= true)
//alertcondition(hist[1] >= 0 and hist < 0, title = 'Rising to falling', message = 'The MACD histogram switched from a rising to falling state')
//alertcondition(hist[1] <= 0 and hist > 0, title = 'Falling to rising', message = 'The MACD histogram switched from a falling to rising state')

green = hist >= 0 ? (hist[1] < hist ? "G" : "GL") : (hist[1] < hist ? "RL" : "R")
Buy = green == "G" and green[1] != "G" and green[1] != "GL" and bopen < bclose and rsi < 55.0 //and not cond2
//StopBuy = (green == "R" or green == "RL" or green == "RL") and bopen > bclose and bopen[1] < bclose[1]
StopBuy = bopen > bclose and bopen[1] < bclose[1] and (green == "G" or green == "GL" or green == "R") and bopen[2] < bclose[2] and bopen[3] < bclose[3]
hists = close[3] < close[2] and close[2] < close[1]
//Buy = green == "RL" and hist[0] > -0.07 and hist[0] < 0.00 and rsi < 55.0 and hists
//StopBuy = green == "GL" or green == "R"
alertcondition(Buy, "Long","Покупка в лонг")
alertcondition(StopBuy, "StopLong","Закрытие сделки")

//hline(0, "Zero Line", color = color.new(#787B86, 50))
plot(hist + (close - (close * 0.03)), title = "Histogram", style = plot.style_line, color = (hist >= 0 ? (hist[1] < hist ? #26A69A : #B2DFDB) : (hist[1] < hist ? #FFCDD2 : #FF5252)))
plotshape(Buy ? low : na, 'Buy', shape.labelup, location.belowbar , color=color.new(#0abe40, 50), size=size.small, offset=0)
plotshape(StopBuy ? low : na, 'Buy', shape.cross, location.abovebar , color=color.new(#be0a0a, 50), size=size.small, offset=0)
plot(macd4  + (close - (close * 0.01)),   title = "MACD",   color = #2962FF)
plot(signal5 + (close - (close * 0.01)), title = "Signal", color = #FF6D00)

plotchar(cond2 , char='↓', color = color.rgb(0, 230, 119), text = "-")

if (Buy)
    strategy.entry("long", strategy.long)

// if (startShortTrade)
//     strategy.entry("short", strategy.short)

profitTarget = strategy.position_avg_price * stopLuse
strategy.exit("Take Profit", "long", limit=profitTarget)
// strategy.exit("Take Profit", "short", limit=profitTarget)

Mehr