RSI-Indikator Long- und Short-Strategie
ChaoZhang
Überblick
Die Strategie basiert auf einem relativ starken Index (RSI) und ist eine typische RSI-Umkehr-Handelsstrategie. Die Strategie bietet gleichzeitig Funktionen wie Parameteroptimierung und Stop-Loss-Strategie und kann durch Anpassung der Parameter an verschiedene Marktbedingungen angepasst werden.
Strategieprinzip
Die Kernlogik der Strategie besteht aus:
- Berechnung des RSI-Wertes
- RSI-Ober- und Untergrenzen
- Die RSI-Kursgrenze ist ein gutes Beispiel für eine schlechte Eintrittsrate.
- Der RSI-Wachstumsschnitt ist der niedrigste Wert, den man je beobachten kann.
- Setzen Sie die Stop-Loss-Bedingungen
- Der RSI schließt, wenn er wieder in die Spanne eintritt oder die Stop-Loss-Bedingungen auslöst
Der RSI-Indikator zeigt an, ob ein Markt überkauft oder überverkauft ist. Wenn der RSI über 70 liegt, wird er als überkauft angesehen, und wenn der RSI unter 30 liegt, wird er als überverkauft angesehen. Die Handelsstrategie besteht darin, eine Leer- oder Mehrheitsposition zu erstellen.
Die Strategie nutzt die klassische Logik des RSI-Indikators, um die Positionsrichtung anhand der Beziehung zwischen dem RSI-Wert und der vorgegebenen oberen und unteren Grenze zu bestimmen. Die Strategie verfügt außerdem über einstellbare Parameter, mit denen die oberen und unteren Grenzen des RSI, die Stop-Loss-Marge usw. optimiert werden können, um sich an Veränderungen des Marktes anzupassen.
Strategische Vorteile
- Der RSI-Indikator ist ein guter Indikator für Überkauf und Überverkauf.
- RSI-Indikatoren basieren auf der Theorie der breiten Akzeptanz
- Strategieparameter sind anpassbar für verschiedene Sorten und Marktumgebungen
- Integrierte Stop-Loss-Mechanismen, um Risiken zu kontrollieren
Strategische Risiken und Maßnahmen
- Der RSI könnte falsche Signale geben, die zu unnötigen Verlusten führen
- Die RSI-Parameter-Bereiche müssen ständig optimiert werden
- Schwingungen und Störungen können durch Frequent ausgelöst werden.
Gegenmaßnahmen:
- Multi-Faktor-Bestätigung in Verbindung mit anderen Indikatoren, um falsche Signale zu vermeiden
- Optimierung des RSI-Parameterbereichs für verschiedene Sorten
- Anpassung der Stop-Loss-Position zur Verringerung der Risikoverminderung
Richtung der Strategieoptimierung
Die Strategie kann in folgenden Bereichen erweitert und optimiert werden:
Automatische Optimierung des RSI-Parameterbereichs mit Hilfe von maschinellem Lernen
Erhöhung der Bestätigung von Transaktionen und Vermeidung von Falschmeldungen
Multi-Faktor-Verifizierung in Verbindung mit Moving Averages und anderen Indikatoren
Setzen Sie eine anpassungsfähige Stop-Loss-Strategie, um die Stop-Loss-Grenze an Marktbewegungen anzupassen
Das ist eine sehr wichtige Frage, die wir uns stellen müssen.
Kombination mit anderen nicht relevanten Strategien zur Verringerung der Gesamtrückziehung
Zusammenfassen
Die Strategie verwendet die RSI-Anzeige, um Überkauf und Überverkauf zu beurteilen. Die Strategie ist eine einfache und praktische Umkehrstrategie. Die Strategie kann die Parameter an Marktveränderungen anpassen, aber auch in mehreren Dimensionen erweitert und optimiert werden. Verbesserungen wie Parameteroptimierung, Multi-Faktor-Verifizierung und Anpassung an Stop Loss können die Strategie stabiler und zuverlässiger 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)