RSI-Indikator Doppelstrategie

Schriftsteller:ChaoZhang, Datum: 19.9.2023
Tags:

Übersicht

Diese Strategie verwendet den Relative Strength Index (RSI) Indikator, um Überkauf- und Überverkaufsniveaus für Shorts und Longs zu bestimmen.

Strategie Logik

Die Kernlogik umfaßt:

Berechnung des RSI-Wertes
Festlegung der oberen und unteren Grenzen des RSI
Kurzlauf, wenn der RSI über die Obergrenze geht
Verlängerung, wenn der RSI unter die untere Grenze geht
Festlegung der Gewinn- und Stop-Loss-Level
Ausgangspositionen, wenn sich der RSI umkehrt oder wenn ein Take-Profit-/Stop-Loss-System erreicht wird

Der RSI-Indikator zeigt Überkauf über 70 und Überverkauf unter 30 Marktbedingungen. Die Strategie nutzt diese klassische Logik, um Long/Short-Einträge basierend auf dem RSI-Wert gegen voreingestellte Limits zu bestimmen. Anpassbare Parameter ermöglichen auch die Optimierung von Limits, Stop Loss usw. für die Marktanpassung.

Vorteile

Der RSI identifiziert effektiv überkaufte/überverkaufte Marktzustände
Der RSI hat eine solide theoretische Grundlage
Anpassbare Parameter passen sich den unterschiedlichen Instrumenten und Bedingungen an
Risikopositionen, für die keine Risikopositionen gelten

Risiken und Minderung

Risiko für falsche RSI-Signale mit Verlusten
Erfordert eine kontinuierliche Optimierung der RSI-Werte
Stops können häufig während der unruhigen Kursbewegung erreicht werden

Abmilderung:

Zusätzliche Faktoren zur Bestätigung von Signalen und zur Vermeidung falscher
Optimierung der RSI-Levels anhand der Instrumenteneigenschaften
Anpassung der Stop-Loss-Platzierung zur Verringerung der Whipsaw-Risiken

Möglichkeiten zur Verbesserung

Die Strategie kann durch folgende Maßnahmen verbessert werden:

Maschinelles Lernen für die automatische Optimierung des RSI-Niveaus
Volumenbestätigung zur Vermeidung falscher Ausbrüche
Zusätzliche Faktoren wie gleitende Durchschnitte für die Mehrfaktorbestätigung
Anpassungsfähige Stopps basierend auf der Marktvolatilität
Volumenanalyse zur Messung von Fondszu-/Ausflüssen
Kombination mit nicht korrelierten Strategien zur Verringerung der Portfolioentziehung

Schlussfolgerung

Dies ist eine einfache und praktische Mittelumkehrstrategie, bei der der RSI zur Erkennung von Überkauf/Überverkauf verwendet wird. Anpassbare Parameter ermöglichen die Anpassung an sich ändernde Märkte. Verbesserungen wie adaptive Stopps, Multi-Faktor-Bestätigung und Parameteroptimierung können die Strategie robuster machen.

/*backtest
start: 2023-08-19 00:00:00
end: 2023-09-18 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=3
strategy("4All V3", shorttitle="Strategy", overlay=true)

/////////////// Component Code Start ///////////////
testStartYear = input(2011, "Backtest Start Year") 
testStartMonth = input(8, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)

testStopYear = input(2018, "Backtest Stop Year")
testStopMonth = input(9, "Backtest Stop Month")
testStopDay = input(29, "Backtest Stop Day")
// testStopDay = testStartDay + 1
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)

// A switch to control background coloring of the test period
testPeriodBackground = input(title="Color Background?", type=bool, defval=true)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)

testPeriod() => true
/////////////// Component Code Stop ///////////////

src = close
len = input(4, minval=1, title="Length")

up = rma(max(change(src), 0), len)
down = rma(-min(change(src), 0), len)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))

rsin = input(5)
sn = 100 - rsin
ln = 0 + rsin

/////////////// STRATEGY ///////////////
ts = input(99999, "Trailing Stop") / 10000
tp = input(15, "Take Profit") / 10000
sl = input(23, "Stop Loss") / 10000

pyr = input(1, "Pyramiding")

short = crossover(rsi, sn)
long = crossunder(rsi, ln)

totalLongs = 0
totalLongs := nz(totalLongs[1])
totalShorts = 0
totalShorts := nz(totalShorts[1])

totalLongsPrice = 0
totalLongsPrice := nz(totalLongsPrice[1])
totalShortsPrice = 0
totalShortsPrice := nz(totalShortsPrice[1])

sectionLongs = 0
sectionLongs := nz(sectionLongs[1])
sectionShorts = 0
sectionShorts := nz(sectionShorts[1])

if long
    sectionLongs := sectionLongs + 1
    sectionShorts := 0

if short
    sectionLongs := 0
    sectionShorts := sectionShorts + 1

longCondition = long and sectionLongs >= pyr
shortCondition = short and sectionShorts >= pyr

last_long = na
last_short = na
last_long := longCondition ? time : nz(last_long[1])
last_short := shortCondition ? time : nz(last_short[1])

long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)

last_open_long_signal = na
last_open_short_signal = na
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])

last_long_signal = na
last_short_signal = na
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])

in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal

last_high = na
last_low = na
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])

long_ts = not na(last_high) and high <= (last_high - ts) //and high >= last_open_long_signal
short_ts = not na(last_low) and low >= (last_low + ts) //and low <= last_open_short_signal

long_tp = high >= (last_open_long_signal + tp)
short_tp = low <= (last_open_short_signal - tp)

long_sl = low <= (last_open_long_signal - sl)
short_sl = high >= (last_open_short_signal + sl)

leverage = input(1, "Leverage")
long_call = last_open_long_signal - (0.8 + 0.2 * (1/leverage)) / leverage * last_open_long_signal
short_call = last_open_short_signal + (0.78 + 0.2 * (1/leverage)) / leverage * last_open_short_signal
long_call_signal = low <= long_call
short_call_signal = high >= short_call

if testPeriod()
    strategy.entry("Long", strategy.long, when=longCondition)
    strategy.entry("Short", strategy.short, when=shortCondition)
    
    strategy.close("Long", when=long_call_signal)
    strategy.close("Short", when=short_call_signal)
    strategy.close("Long", when=long_tp)
    strategy.close("Short", when=short_tp)
    strategy.close("Long", when=long_sl)
    strategy.close("Short", when=short_sl)
    strategy.close("Long", when=long_ts)
    strategy.close("Short", when=short_ts)

Mehr