Eine Hochfrequenz-Handelsstrategie für Kryptowährungen, die den TrippleMACD-Gleitenden Durchschnitt mit dem Relative-Stärke-Index kombiniert
ChaoZhang
Überblick
In diesem Artikel wird eine hochfrequente Kryptowährungs-Handelsstrategie vorgestellt, die auf einer Triple MACD-Gehaltslinie in Kombination mit einem relativ starken RSI basiert. Die Strategie nutzt MACD-Indikatoren mit drei Gruppen von verschiedenen Parametern und vergleicht ihre Signallinien, während die RSI-Indikatoren kombiniert werden, um die besten Kauf- und Verkaufszeiten zu ermitteln. Die Strategie ist speziell für den automatisierten Handel in einem 1-Minuten-Zeitrahmen konzipiert und berücksichtigt nur mehrköpfige Geschäfte.
Strategieprinzip
Der Kern der Strategie besteht darin, Trendsignale auf verschiedenen Zeitskalen mit drei Gruppen von MACD-Indikatoren mit unterschiedlichen Parametern zu erfassen. Durch die Mittelung der Signallinien dieser drei Gruppen von MACD-Indikatoren kann der Lärm wirksam ausgeglichen und ein zuverlässigeres Handelssignal bereitgestellt werden. Gleichzeitig wird der RSI-Indikator verwendet, um die Stärke eines mehrköpfigen Trends zu bestätigen.
Darüber hinaus nutzt die Strategie die lineare Regression, um die Bilanzierungsphase des Marktes zu identifizieren. Durch die Berechnung des Verhältnisses zwischen den Unter- und Unterlinien auf dem Diagramm kann beurteilt werden, ob sich der aktuelle Markt in einer Bilanzierungsphase befindet. Wenn die Länge der Unter- und Unterlinie mehr als das Doppelte der Länge der Entität beträgt, wird der Markt als in einer Bilanzierungsphase betrachtet, wobei die Strategie den Handel vermeiden wird.
Analyse der Stärken
Multi-Zeitskala-Analyse: Durch die Verwendung von MACD-Indikatoren mit drei Gruppen von verschiedenen Parametern kann die Strategie Trendsignale auf verschiedenen Zeitskalen erfassen, was die Genauigkeit und Zuverlässigkeit des Handels erhöht.
Signal-Gleichung: Durch die Mittelung der Signalleitung von drei Gruppen von MACD-Indikatoren kann der Lärm wirksam ausgeglichen werden, wodurch ein irreführendes Signal vermieden wird, das von einem einzigen Indikator erzeugt werden könnte.
Trendbestätigung: Die Bestätigung der Stärke von Mehrkopftrends in Kombination mit dem RSI kann die Zuverlässigkeit von Handelssignalen weiter verbessern.
Bilanzierungs-Identifizierung: Die Bilanzierungsphase des Marktes wird durch die Verwendung einer linearen Regression identifiziert, wodurch der Handel in einem wackligen Umfeld vermieden und das Risiko der Strategie verringert wird.
Automatischer Handel: Die Strategie ist für den automatisierten Handel im 1-Minuten-Zeitrahmen konzipiert, um schnell auf Marktveränderungen zu reagieren und Geschäfte zu tätigen, was die Effizienz des Handels erhöht.
Risikoanalyse
Parameteroptimierung: Die Strategie beinhaltet mehrere Parameter, wie z. B. die schnelle und langsame Linie-Periode für drei Gruppen von MACD-Indikatoren, die Periode für den RSI-Indikator. Die Auswahl dieser Parameter hat einen wichtigen Einfluss auf die Strategie-Performance, und wenn die Parameter nicht richtig optimiert werden, kann dies zu einer Verringerung der Strategie-Performance führen.
Risiko der Überpassung: Die Strategie kann bei bestimmten historischen Daten gut funktionieren, kann sich jedoch in der praktischen Anwendung nicht an Marktveränderungen anpassen und führt zu einer Nichteinhaltung der Strategie.
Black Swan-Ereignisse: Die Strategie basiert hauptsächlich auf technischen Indikatoren und kann auf einige wichtige grundlegende Ereignisse nicht reagieren, was dazu führen kann, dass die Strategie in extremen Marktbedingungen nicht gut funktioniert.
Optimierungsrichtung
Dynamische Anpassung der Parameter: Anpassung der Parameter in der Strategie, wie z. B. der schnelle und langsame Liniezyklus des MACD-Indikators oder der RSI-Indikator, an die Veränderungen der Marktbedingungen, um sie an unterschiedliche Marktbedingungen anzupassen.
Hinzufügen weiterer Indikatoren: Aufbauend auf den bestehenden MACD- und RSI-Indikatoren können andere technische Indikatoren wie Brin-Bands, Moving Averages usw. in Betracht gezogen werden, um die Genauigkeit und Zuverlässigkeit der Handelssignale weiter zu verbessern.
Optimierung des Risikomanagements: Die Integration von besseren Risikomanagementmaßnahmen in die Strategie, wie beispielsweise dynamische Stop-Losses, Positionsmanagement usw., um das Gesamtrisiko der Strategie zu senken.
Optimierung des maschinellen Lernens: Die Optimierung der Parameter und der Handelsregeln der Strategie mit Hilfe von maschinellen Lernalgorithmen wie Neural Networks und Support Vector Machines verbessert die Anpassungsfähigkeit und Stabilität der Strategie.
Zusammenfassen
Dieser Artikel beschreibt eine Hochfrequenz-Kryptowährungs-Trading-Strategie, die auf einer Triple MACD-Gleichgewichtskreuzung in Kombination mit RSI-Indikatoren basiert. Die Strategie nutzt drei verschiedene Parameter des MACD-Indikators und des RSI-Indikators, um zuverlässige Handelssignale zu erzeugen, und nutzt lineare Regression, um die Ausgleichsphase des Marktes zu identifizieren, um den Handel in der Erschütterung zu vermeiden. Die Vorteile der Strategie liegen in der Analyse von Signalen über mehrere Zeitskalen, der Beseitigung von Signalen, der Bestätigung von Trends, der Identifizierung und Automatisierung von Geschäften, aber auch in Risiken wie Parameteroptimierung, Überarbeitung und Black Swan-Ereignisse.
/*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)