Die Ressourcen sind geladen. Beförderung...

RSI-Divergenz-Handelsstrategie

Schriftsteller:ChaoZhang, Datum: 2023-10-25 16:47:14
Tags:

Übersicht

Die RSI Divergence-Handelsstrategie erzeugt Kauf- und Verkaufssignale, indem sie Abweichungen zwischen dem RSI-Indikator und der Preisbewegung identifiziert.

Grundsätze

Diese Strategie verwendet hauptsächlich Abweichungen im RSI-Indikator, um Handelsmöglichkeiten zu identifizieren. Insbesondere berechnet die Strategie zuerst die RSI-Werte über einen bestimmten Zeitraum, und zeichnet dann die Trendlinien für den RSI-Indikator und den Preis. Wenn die RSI-Linie von der Preislinie abweicht, d.h. der RSI steigt, während der Preis fällt, oder der RSI fällt, während der Preis steigt, nimmt die Strategie dies als Zeichen für eine bevorstehende Trendumkehr an und erzeugt Handelssignale.

Wenn die Strategie die RSI-Linie auf dem Boden erkennt, während die Preislinie die Spitze erreicht, wird ein Kaufsignal generiert. Wenn die RSI-Linie die Spitze erreicht, während die Preislinie den Boden erreicht, wird ein Verkaufssignal generiert. Sobald ein Handelssignal auftritt, kann die Strategie entsprechend der RSI-Wertgröße handeln.

Darüber hinaus verfügt die Strategie über Stop-Loss-, Take-Profit- und Trailing-Stop-Loss-Funktionen.

Vorteile

Die RSI-Divergenz-Handelsstrategie hat folgende Vorteile:

Durch die Erfassung von RSI-Divergenzen können Trendumkehrungen frühzeitig erkannt werden.
Der RSI ist weit verbreitet und auf den meisten Handelsplattformen verfügbar.
Die RSI-Parameter sind flexibel und können an unterschiedliche Marktbedingungen angepasst werden.
Die Stop-Loss-, Take-Profit- und Trailing-Stop-Loss-Kontrollen überwachen das Risiko effektiv.
Die Strategie hat eine moderate Signalfrequenz und vermeidet einen Überhandel.
Die Logik ist einfach und leicht zu programmieren für die Automatisierung.

Risiken

Die Strategie birgt auch einige Risiken:

RSI-Divergenzen sind nicht vollständig zuverlässig und können falsche Signale erzeugen.
Divergenzen können in stark entwickelten Märkten scheitern, was vermieden werden sollte.
Zu kurze Zeiten erhöhen die Häufigkeit und das Risiko.
Eine zu enge Stop-Loss-Einstellung verkürzt den Gewinn; eine zu lockere Einstellung begrenzt das Risiko nicht.
Der Trailing Stop kann bei volatilen Märkten vorzeitig gestoppt werden. Eine angemessene Trailing Breite ist aufgrund der Volatilität erforderlich.

Die Risiken können durch folgende Maßnahmen gemildert werden:

Zusätzliche Indikatoren wie MACD, Bollinger Bands, filtern Signale und reduzieren falsche Signale.
Verwenden Sie die Strategie nur während der seitlichen Märkte mit Bandbreite und vermeiden Sie starke Trends.
Optimierung der RSI-Parameter, Auswahl der optimalen Rückblendezeiten, Prüfung von Parametern für verschiedene Märkte.
Festlegung angemessener Stop-Loss- und Gewinnniveaus auf der Grundlage historischer Rückprüfung.
Anpassung der Hinterhaltdistanz auf der Grundlage von Marktvolatilität und Risikobereitschaft.

Optimierung

Die Strategie kann in folgenden Bereichen verbessert werden:

Einbeziehung anderer Indikatoren zur Filterung von Signalen und Verbesserung der Zuverlässigkeit.
Verwenden Sie maschinelles Lernen, um die RSI-Parameter automatisch zu optimieren.
Entwerfen dynamischer Stop-Loss-Algorithmen nach Marktregimen.
Aufbau eines dynamischen Positionsgrößenmodells auf Basis von Volatilität zur Anpassung der Positionsgrößen.
Einführung von Volatilität in Trailing Stop, um die Strecke auf Basis von Kursschwankungen festzulegen.
Strategie auf andere Märkte wie Forex und Kryptowährungen einsetzen.
Entwicklung eines quantitativen Handelssystems für die Automatisierung.

Schlussfolgerung

Die RSI-Divergenz-Handelsstrategie erzeugt Signale durch die Identifizierung von Divergenzen zwischen RSI und Preis. Die Logik ist einfach und einfach zu automatisieren. Der Stop-Loss, Take-Profit und Trailing-Stop kontrollieren die Risiken effektiv. Die Strategie hat jedoch Einschränkungen in Bezug auf Genauigkeit und Trending-Märkte. Verbesserungen können durch Optimierung von Parametern, Hinzufügen von Filtern und dynamischen Stops erzielt werden. Als technische Strategie kann sie als Ergänzung während von Bereichsmärkten dienen, wenn sie systematisiert wird.

/*backtest
start: 2023-09-24 00:00:00
end: 2023-10-24 00:00:00
period: 4h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © faytterro

//@version=5
// strategy("RSI Divergence Strategy", overlay=true, scale = scale.none)
rsilen=input.int(14, title="rsi length")
rsisrc=input(close, title="source")
x=ta.rsi(rsisrc,rsilen)
len=input.int(14, title="RSI Divergence length", maxval=500)
tpb = input.float(25, title="take profit", group = "buy", step = 0.5)
sb = input.float(5, title="stop", group = "buy", step = 0.5)
tsb = input.float(0.25, title="trailing stop", group = "buy", step = 0.5)
tps = input.float(25, title="take profit", group = "sell", step = 0.5)
ss =input.float(5, title="stop", group = "sell", step = 0.5)
tss = input.float(0.25, title="trailing stop", group = "sell", step = 0.5)
src=close
extrapolation=0
zoom=input.int(0, title="zoom", maxval=27, minval=-27)
hline(300-zoom*10, color=color.rgb(54, 58, 69, 100))
hline(10, color=color.rgb(54, 58, 69, 100))
// for ax+b
xo=0.0
yo=0.0
xyo=0.0
xxo=0.0
for i=0 to len-1
    xo:= xo + i/(len)
    yo:= yo + x[len-1-i]/(len)
    xyo:= xyo + i*x[len-1-i]/(len)
    xxo:= xxo + i*i/(len)
dnm=ta.lowest(low,200)
dizi=array.new_float(len*2+1+extrapolation)
// linedizi=array.new_line()
a=(xo*yo-xyo)/(xo*xo-xxo)
b=yo-a*xo
for i=0 to len-1+extrapolation
    array.set(dizi,i,a*i+b)
//// for src
// for ax+b
xo2=0.0
yo2=0.0
xyo2=0.0
xxo2=0.0
for i=0 to len-1
    xo2:= xo2 + i/(len)
    yo2:= yo2 + src[len-1-i]/(len)
    xyo2:= xyo2 + i*src[len-1-i]/(len)
    xxo2:= xxo2 + i*i/(len)

dizi2=array.new_float(len*2+1+extrapolation)
// linedizi2=array.new_line()
a2=(xo2*yo2-xyo2)/(xo2*xo2-xxo2)
b2=yo2-a*xo2
for i=0 to len-1+extrapolation
    array.set(dizi2,i,a2*i+b2)
ttk=((array.get(dizi,0)<array.get(dizi,1)) and (array.get(dizi2,0)>array.get(dizi2,1)))? 1 : 
 ((array.get(dizi,0)>array.get(dizi,1)) and (array.get(dizi2,0)<array.get(dizi2,1)))? -1 : 0
cg=((array.get(dizi,0)<array.get(dizi,1)) and (array.get(dizi2,0)>array.get(dizi2,1)))// and ta.highest(ttk[1],len/2)<1)
cr=((array.get(dizi,0)>array.get(dizi,1)) and (array.get(dizi2,0)<array.get(dizi2,1)))// and ta.lowest(ttk[1],len/2)>-1)
bgcolor(color=(cg and ta.highest(ttk[1],len/2)<1)? color.rgb(76, 175, 79, 50) : 
 (cr and ta.lowest(ttk[1],len/2)>-1)? color.rgb(255, 82, 82, 50) : na, offset=0, display=display.none)
plot(x)

// for ax+b
xo3=0.0
yo3=0.0
xyo3=0.0
xxo3=0.0
for i=0 to len-1
    xo3:= xo3 + i/(len)
    yo3:= yo3 + x[len-1-i+(ta.barssince(cg))]/(len)
    xyo3:= xyo3 + i*x[len-1-i+(ta.barssince(cg))]/(len)
    xxo3:= xxo3 + i*i/(len)

dizi3=array.new_float(len*2+1+extrapolation)
// linedizi3=array.new_line()
a3=(xo3*yo3-xyo3)/(xo3*xo3-xxo3)
b3=yo3-a3*xo3
for i=0 to len-1+extrapolation
    array.set(dizi3,i,a3*i+b3)

// for ax+b
xo4=0.0
yo4=0.0
xyo4=0.0
xxo4=0.0
for i=0 to len-1
    xo4:= xo4 + i/(len)
    yo4:= yo4 + x[len-1-i+(ta.barssince(cr))]/(len)
    xyo4:= xyo4 + i*x[len-1-i+(ta.barssince(cr))]/(len)
    xxo4:= xxo4 + i*i/(len)

dizi4=array.new_float(len*2+1+extrapolation)
// linedizi4=array.new_line()
a4=(xo4*yo4-xyo4)/(xo4*xo4-xxo4)
b4=yo4-a4*xo4
for i=0 to len-1+extrapolation
    array.set(dizi4,i,a4*i+b4)

// line=line.new((last_bar_index-ta.barssince(cg)-len),
//  array.get(dizi3,0), 
//  last_bar_index-ta.barssince(cg),
//  array.get(dizi3,len-1), color=color.rgb(0,255,0), width=2)
// line2=line.new((last_bar_index-ta.barssince(cr)-len),
//  array.get(dizi4,0), 
//  last_bar_index-ta.barssince(cr),
//  array.get(dizi4,len-1), color=color.rgb(255, 0, 0, 0), width=2)
// line.delete(line[1])
// line.delete(line2[1])

alert=((array.get(dizi,0)<array.get(dizi,1)) and (array.get(dizi2,0)>array.get(dizi2,1)) and ta.highest(ttk[1],len/2)<1)
 or ((array.get(dizi,0)>array.get(dizi,1)) and (array.get(dizi2,0)<array.get(dizi2,1)) and ta.lowest(ttk[1],len/2)>-1)
alertcondition(alert)
hline(50)
rs=hline(30)
rss=hline(70)
fill(rs, rss, color=color.rgb(126, 87, 194, 90), title="RSI Background Fill")

longCondition = cg and ta.highest(ttk[1],len/2)<1 
if (longCondition)
    strategy.entry("Long", strategy.long)
    strategy.exit("exit long", "Long", limit = close*(100+tpb)/100 , stop =close*(100-sb)/100 , trail_price = close , trail_offset = close*tsb)

shortCondition = cr and ta.lowest(ttk[1],len/2)>-1 
if (shortCondition)
    strategy.entry("Short", strategy.short)
    strategy.exit("exit short", "Short", limit = close*(100-tps)/100, stop = close*(100+ss)/100, trail_price = close , trail_offset = close*tss)

Mehr