Die verzögerte RSI-Handelsstrategie verwendet den konventionellen RSI-Indikator, um überkaufte und überverkaufte Bedingungen zu identifizieren, und verzögert den Markteintritt für einen bestimmten Zeitraum, nachdem das Signal erscheint, um unnötige Verluste durch gefälschte Ausbrüche zu vermeiden.
Diese Strategie verwendet einen 21-Perioden-RSI-Indikator, um Überkauf- und Überverkaufszustände zu bestimmen. Wenn der RSI-Indikator über das vom Benutzer definierte Überkaufniveau (Standard 60) überschreitet, gilt der Markt als überkauft. Wenn der RSI unter das vom Benutzer definierte Überkaufniveau (Standard 40) überschreitet, gilt der Markt als überverkauft.
Nach der Identifizierung von überkauften oder überverkauften Signalen tritt die Strategie nicht sofort in den Markt ein. Stattdessen beginnt sie mit der Berechnung der Verzögerungszeit. Wenn die Verzögerungszeit (Standard 15-Bars) erreicht ist, tritt sie auf der Grundlage des überkauften Signals kurz und auf der Grundlage des überverkauften Signals lang ein.
Die Strategie ermöglicht es Benutzern, die Verzögerungszeit anzupassen, um unterschiedliche Eintrittszeiten zu erreichen. Eine längere Verzögerungszeit kann mehr gefälschte Ausbrüche vermeiden, kann aber auch bessere Eintrittsmöglichkeiten verpassen. Benutzer müssen den Verzögerungszeitraumparameter basierend auf den Eigenschaften bestimmter Produkte anpassen.
Darüber hinaus implementiert die Strategie auch Optionen wie Stop-Loss, Take-Profit, Reverse-Trading usw. Benutzer können Fixed-Stop-Loss, Trailing-Stop-Loss, Fixed-Take-Profit usw. wählen, um Positionen zu verwalten.
Der RSI ist ein ausgereifter Oszillator, der häufig zur Identifizierung von Umkehrungen verwendet wird.
Eine verzögerte Einreise vermeidet Verluste durch gefälschte Ausbrüche.
Die verstellbare Verzögerungsdauer ermöglicht eine genaue Eintrittszeit.
Die Strategie bietet mehrere Möglichkeiten wie Fixed SL/TP, Trailing SL usw. zum Risikomanagement.
Umgekehrte Handelsoption passt sich an verschiedene Produkte an. Benutzer können normale oder umgekehrte Logik wählen, um Unsicherheiten abzusichern.
Risiko für gefälschte Signale von RSI. RSI-Signale sind möglicherweise nicht immer genau und können manchmal falsche Signale geben.
Eine zu lange Verzögerung kann zu verpassten Einstiegspunkten führen.
Erhöhtes Verlustrisiko durch Reverse Trading Obwohl Reverse Trading Unsicherheiten absichert, kann es auch den Gesamtverlust verstärken.
Es besteht die Gefahr, dass SL zu nahe kommt und vorzeitig gestoppt wird.
Unzureichender Gewinn aufgrund eines ungenauen festen TP. Fester TP kann keinen maximalen Gewinn erzielen und erfordert eine angemessene Prognose.
Um diesen Risiken entgegenzuwirken, werden folgende Optimierungsvorschläge gemacht:
Filtern Sie RSI-Signale mit anderen Indikatoren wie KDJ, MACD usw., um die Zuverlässigkeit zu verbessern.
Backtest mit historischen Daten, um die optimale Verzögerungszeit für jedes Produkt zu finden.
Verwenden Sie umgekehrte Logik vorsichtig, vorzugsweise kombiniert mit dem Trend folgen.
Beibehalten Sie einen breiten Puffer für SL, um zu vermeiden, dass die Preise zu nahe kommen.
Testen Sie verschiedene TP-Verhältnisse, um das optimale zu finden.
Die Strategie kann in folgenden Bereichen weiter optimiert werden:
Kombination mehrerer Indikatoren zur Filterung von Einstiegssignalen, z. B. KDJ, MACD mit RSI, um robustere Signale zu erhalten.
Dynamische Anpassung der Verzögerungsdauer basierend auf der Marktvolatilität, um einen falschen Ausbruch zu vermeiden und gleichzeitig die Eingangsgenauigkeit zu verbessern.
Optimierung von SL/TP-Strategien wie dynamische SL, Gewinnrückführungsquote SL, zeitbasierte SL usw., damit sie sich besser an die Marktschwankungen anpassen.
Einbeziehen des Trends. Messen, ob die Breakout-Richtung mit dem Haupttrend übereinstimmt. Auch die Verzögerungszeit anhand der Breakout-Dynamik anpassen.
Verwenden Sie maschinelles Lernen, um optimale Parameterkombinationen zu finden. ML kann Parameter automatisch anpassen, basierend auf großen Trainings- und Backtest-Datensätzen.
Abschließend kann die Strategie durch Indikatorenkombinationen, dynamische Anpassung von Parametern, Trendintegration usw. weitreichend optimiert werden.
Die verzögerte RSI-Strategie nutzt insgesamt den RSI, um Überkauf/Überverkaufszustände zu identifizieren, und verzögert den Einstieg für einen Zeitraum nach dem Auftreten des Signals, um unnötige Verluste durch Fakeouts zu vermeiden. Die Strategie hat Vorteile wie genaue Signalidentifizierung, verzögerte Eintritt, um falsche Bruch zu vermeiden, anpassbare Verzögerungszeit, SL/TP-Implementierung usw. Aber Risiken wie unzuverlässige RSI-Signale, verpasste Chancen durch übermäßige Verzögerung bestehen. Diese können durch Optimierung der Signalgenauigkeit über Indikatorkombinationen, dynamische Verzögerungszeit-Tuning, bessere SL/TP-Strategien usw. weiter verbessert werden. Die Strategie bietet breite Optimierungsmöglichkeiten und lohnt sich zu erforschen.
/*backtest
start: 2023-01-01 00:00:00
end: 2023-10-06 00:00:00
period: 1d
basePeriod: 1h
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/
// © tweakerID and © BacktestRookies
// This strategy uses a 21 period RSI with an overbought (RSI indicator
// is greater than) level of 60 (user defined) to determines long entries and an oversold
// (RSI indicator is less than) level of 40 (user defined) for shorts. It introduces a bar delay that starts
// counting when the RSI < Oversold or RSI > Overbought conditions are true, delaying the entry with
// the amount of bars determined by the user. The trading logic can be reversed, which seems to work better.
//@version=4
strategy("Delayed RSI Strategy",
overlay=false,
default_qty_type=strategy.percent_of_equity,
default_qty_value=100,
initial_capital=10000,
commission_value=0.04,
calc_on_every_tick=false,
slippage=0)
direction = input(0, title = "Strategy Direction", type=input.integer, minval=-1, maxval=1)
strategy.risk.allow_entry_in(direction == 0 ? strategy.direction.all :
(direction < 0 ? strategy.direction.short : strategy.direction.long))
// Bought and Sold Boolean Signal
bought = strategy.position_size > strategy.position_size[1]
or strategy.position_size < strategy.position_size[1]
/////////////////////// STRATEGY INPUTS ////////////////////////////////////////
title1=input(true, "-----------------Strategy Inputs-------------------")
rsiLen=input(21, title="RSI Length")
i_OB = input(60, title="Overbought")
i_OS = input(40, title="Oversold")
i_delay = input(15, title="Entry Delay (# of Bars)")
i_Close= input(false, title="Use Strategy Close")
/////////////////////// BACKTESTER /////////////////////////////////////////////
title2=input(true, "-----------------General Inputs-------------------")
// Backtester General Inputs
i_SL=input(true, title="Use Stop Loss and Take Profit")
TS=input(false, title="Use Trailing Stop")
i_SLType=input(defval="ATR Stop", title="Type Of Stop", options=["Strategy Stop", "Swing Lo/Hi", "ATR Stop"])
i_SPL=input(defval=10, title="Swing Point Lookback")
i_PercIncrement=input(defval=3, step=.1, title="Swing Point SL Perc Increment")*0.01
i_ATR = input(14, title="ATR Length")
i_ATRMult = input(3, step=.1, title="ATR Multiple")
i_TPRRR = input(2, step=.1, title="Take Profit Risk Reward Ratio")
DPR=input(false, "Allow Direct Position Reverse")
reverse=input(true, "Reverse Trades")
// Swing Points Stop and Take Profit
SwingStopProfit() =>
LL=(lowest(i_SPL))*(1-i_PercIncrement)
HH=(highest(i_SPL))*(1+i_PercIncrement)
LL_price = valuewhen(bought, LL, 0)
HH_price = valuewhen(bought, HH, 0)
entry_LL_price = strategy.position_size > 0 ? LL_price : na
entry_HH_price = strategy.position_size < 0 ? HH_price : na
tp=strategy.position_avg_price + (strategy.position_avg_price - entry_LL_price)*i_TPRRR
stp=strategy.position_avg_price - (entry_HH_price - strategy.position_avg_price)*i_TPRRR
[entry_LL_price, entry_HH_price, tp, stp]
// ATR Stop
ATRStop() =>
ATR=atr(i_ATR)*i_ATRMult
ATRLong = ohlc4 - ATR
ATRShort = ohlc4 + ATR
ATRLongStop = valuewhen(bought, ATRLong, 0)
ATRShortStop = valuewhen(bought, ATRShort, 0)
LongSL_ATR_price = strategy.position_size > 0 ? ATRLongStop : na
ShortSL_ATR_price = strategy.position_size < 0 ? ATRShortStop : na
ATRtp=strategy.position_avg_price + (strategy.position_avg_price - LongSL_ATR_price)*i_TPRRR
ATRstp=strategy.position_avg_price - (ShortSL_ATR_price - strategy.position_avg_price)*i_TPRRR
[LongSL_ATR_price, ShortSL_ATR_price, ATRtp, ATRstp]
// Strategy Stop
StrategyStop(bought) =>
float LongStop = na
float ShortStop = na
float StratTP = na
float StratSTP = na
[LongStop, ShortStop, StratTP, StratSTP]
//TrailingStop
TrailingStop(SL,SSL) =>
dif=(valuewhen(strategy.position_size>0 and strategy.position_size[1]<=0, high,0))
-strategy.position_avg_price
trailOffset = strategy.position_avg_price - SL
var tstop = float(na)
if strategy.position_size > 0
tstop := high- trailOffset - dif
if tstop<tstop[1]
tstop:=tstop[1]
else
tstop := na
StrailOffset = SSL - strategy.position_avg_price
var Ststop = float(na)
Sdif=strategy.position_avg_price-(valuewhen(strategy.position_size<0
and strategy.position_size[1]>=0, low,0))
if strategy.position_size < 0
Ststop := low+ StrailOffset + Sdif
if Ststop>Ststop[1]
Ststop:=Ststop[1]
else
Ststop := na
[tstop, Ststop]
//Stop Loss & Take Profit Switches
SLTPLogic(LongStop, ShortStop, StratTP, StratSTP, LongSL_ATR_price, ShortSL_ATR_price, ATRtp, ATRstp,
entry_LL_price, entry_HH_price, tp, stp) =>
SL= i_SLType == "Swing Lo/Hi" ? entry_LL_price : i_SLType == "ATR Stop" ? LongSL_ATR_price : LongStop
SSL= i_SLType == "Swing Lo/Hi" ? entry_HH_price : i_SLType == "ATR Stop" ? ShortSL_ATR_price : ShortStop
TP= i_SLType == "Swing Lo/Hi" ? tp : i_SLType == "ATR Stop" ? ATRtp : StratTP
STP= i_SLType == "Swing Lo/Hi" ? stp : i_SLType == "ATR Stop" ? ATRstp : StratSTP
[SL, SSL, TP, STP]
/////////////////////// STRATEGY LOGIC /////////////////////////////////////////
rsi = rsi(close, rsiLen)
isOB= rsi > i_OB
isOS= rsi < i_OS
BarsSinceOB = barssince(not isOB)
BarsSinceOS = barssince(not isOS)
BUY = BarsSinceOS == i_delay
SELL = BarsSinceOB == i_delay
/////////////////////// FUNCTION CALLS /////////////////////////////////////////
// Stops and Profits
[entry_LL_price, entry_HH_price, tp, stp] = SwingStopProfit()
[LongSL_ATR_price, ShortSL_ATR_price, ATRtp, ATRstp] = ATRStop()
[LongStop, ShortStop, StratTP, StratSTP] = StrategyStop(bought)
[SL, SSL, TP, STP] = SLTPLogic(LongStop, ShortStop, StratTP, StratSTP,
LongSL_ATR_price, ShortSL_ATR_price, ATRtp, ATRstp, entry_LL_price, entry_HH_price, tp, stp)
[tstop, Ststop] = TrailingStop(SL,SSL)
// Entries
if reverse
if not DPR
strategy.entry("long", strategy.long, when=SELL and strategy.position_size == 0)
strategy.entry("short", strategy.short, when=BUY and strategy.position_size == 0)
else
strategy.entry("long", strategy.long, when=SELL)
strategy.entry("short", strategy.short, when=BUY)
else
if not DPR
strategy.entry("long", strategy.long, when=BUY and strategy.position_size == 0)
strategy.entry("short", strategy.short, when=SELL and strategy.position_size == 0)
else
strategy.entry("long", strategy.long, when=BUY)
strategy.entry("short", strategy.short, when=SELL)
// Exits
if i_SL
strategy.exit("TP & SL", "long", limit=TP, stop=TS? tstop : SL)
strategy.exit("TP & SL", "short", limit=STP, stop=TS? Ststop : SSL)
if i_Close
strategy.close_all(when=cross(rsi, 50))
/////////////////////// PLOTS //////////////////////////////////////////////////
//Plots
rsiplot = plot(rsi, "RSI", color=#7E57C2)
band1 = hline(i_OB, "Upper Band", color=#787B86)
bandm = hline(50, "Middle Band", color=color.new(#787B86, 50))
band0 = hline(i_OS, "Lower Band", color=#787B86)
fill(band1, band0, color=color.rgb(126, 87, 194, 90), title="Background")
plot(rsi, "RSI", color=#7E57C2)
// OSOBCount = plot(isOB ? BarsSinceOB : isOS ? BarsSinceOS : na, transp=100)
// OSOBColor = color.from_gradient(isOB ? BarsSinceOB : BarsSinceOS, 0, 20, color.black, isOB ? color.red : isOS ? color.green : na)
// OBP = plot(rsi > i_OB ? rsi : na, color=color.white, display=display.none)
// fill(plot(i_OB, display=display.none), OBP, color=OSOBColor, transp=0, fillgaps=false)
// OSP = plot(rsi < i_OS ? rsi : na, color=color.white, display=display.none)
// fill(plot(i_OS, display=display.none), OSP, color=OSOBColor, transp=0, fillgaps=false)
// plotshape(BUY ? 1 : na, style=shape.arrowdown, location=location.bottom,
// color=color.green, title="Bullish Setup", size=size.normal)
// plotshape(SELL ? 1 : na, style=shape.arrowup, location=location.top,
// color=color.red, title="Bearish Setup", size=size.normal)