Verzögerte RSI-Handelsstrategie
ChaoZhang
Überblick
Die RSI-Trading-Strategie verwendet die üblichen RSI-Indikatoren, um Überkauf-Überverkauf zu erkennen, und die Eintrittssignale werden nach einer bestimmten Periode verzögert, um unnötige Verluste durch falsche Durchbrüche zu vermeiden. Die Hauptidee der Strategie ist, die RSI-Indikatoren zu verwenden, um die Überkauf-Überverkauf-Erscheinung des Marktes zu beurteilen, und auf der Grundlage dieser Beurteilung, um durch die Verzögerung des Eintritts eine genauere Eintrittszeit zu erlangen.
Strategieprinzip
Die Strategie nutzt den RSI mit einer Länge von 21 Zyklen, um Überkäufe und Überverkäufe zu beurteilen. Wenn der RSI über die vom Benutzer gesetzte Überkauflinie (Default 60) liegt, wird als überkauft angesehen. Wenn der RSI unter die vom Benutzer gesetzte Überverkauflinie (Default 40) liegt, wird als überverkauft angesehen.
Die Strategie beginnt nicht sofort mit der Berechnung der Verzögerungszyklen, nachdem ein Überkauf-Überverkauf-Signal angezeigt wurde. Wenn die Anzahl der Verzögerungszyklen (die Standard 15-Zyklen) erfüllt ist, wird nach dem Überkauf-Signal eine Leerstellung und ein Überverkauf-Signal durchgeführt.
Diese Strategie erlaubt es dem Benutzer, die Anzahl der Verzögerungszyklen anzupassen, um verschiedene Einstiegszeiten zu erreichen. Je länger die Verzögerungszyklen sind, desto mehr Falschbrüche werden vermieden, aber auch bessere Einstiegspunkte können verpasst werden. Benutzer müssen die Verzögerungszyklusparameter je nach Sorte anpassen.
Darüber hinaus bietet die Strategie Optionen wie Stop-Loss, Stop-Stop und Reverse-Trading. Benutzer können ihre Positionen mit Fixed-Stop, Tracking-Stop und Fixed-Stop verwalten. Sie können auch die Reverse-Trading-Logik auswählen, d. h. nach Überkauf-Signalen zu handeln und nach Überverkauf-Signalen zu handeln.
Strategische Vorteile
Der RSI ist ein ausgereifter Überkauf-Überverkauf-Indikator, der die Umkehrmöglichkeiten effektiv identifiziert.
Durch die Verzögerung des Eintritts können falsche Durchbrüche verhindert werden. Viele Durchbrüche sind nicht unbedingt eine wesentliche Umkehrung, und die Verzögerung des Eintritts kann die Wirksamkeit der Durchbrüche überprüfen.
Die Anzahl der Verzögerungszyklen kann angepasst werden, um die genaue Eintrittszeit zu erfassen. Der Benutzer kann die Verzögerungszyklen an die Eigenschaften der verschiedenen Sorten anpassen, um den optimalen Eintrittspunkt zu erreichen.
Stop-Loss-Management und Risikokontrolle. Die Strategie bietet verschiedene Stop-Loss-Methoden, die in Kombination mit einem verzögerten Einstieg eingesetzt werden können, um Risiken zu kontrollieren.
Es bietet eine umgekehrte Handelsoption, die sich an die Eigenschaften der verschiedenen Sorten anpasst. Benutzer können eine positive oder umgekehrte Handelslogik wählen, um Unsicherheit abzudecken.
Strategisches Risiko
RSI-Signale sind nicht immer wirksam und können in bestimmten Marktsituationen falsch sein.
Verzögerung ist ein Risiko, den richtigen Zeitpunkt für die Einreise zu verpassen.
Reverse Trading erhöht das Risiko von Verlusten. Reverse Trading kann zwar Unsicherheiten abdecken, aber auch die Gesamtverluste ausweiten.
Die Verfolgung von Stop Losses wird durch die Gefahr der Absicherung beeinträchtigt. Die Verfolgung von Stop Losses kann bei starken Preisveränderungen zu nahe am aktuellen Preis sein, um die Absicherung zu durchbrechen.
Die Stempelvorhersage darf nicht zu einem unzureichenden Gewinn führen. Die festgelegte Stempelvorhersage kann nicht zum maximalen Gewinn führen und muss mit einer vernünftigen Vorhersage eingestellt werden.
Im Hinblick auf diese Risiken wurden folgende Optimierungsvorschläge gemacht:
In Kombination mit anderen Indikatoren filtern RSI-Signal, um die Zuverlässigkeit zu erhöhen.
Die optimale Verzögerungs-Periode-Parameter werden anhand von historischen Daten verschiedener Sorten getestet.
Die Rückwärts-Trading-Funktion sollte vorsichtig genutzt werden, vorzugsweise in Kombination mit Trend-Trading.
Setze bei der Verfolgung von Stopps einen breiten Abstand, um zu vermeiden, dass du zu nahe am aktuellen Preis bist.
Verschiedene Stopp-Multiplikatoren werden getestet, um die optimalen Parameter zu finden. Dynamische Stopps können ebenfalls berücksichtigt werden.
Optimierungsrichtung
Die Strategie kann in folgenden Bereichen weiter optimiert werden:
In Kombination mit mehreren Indikatoren filtern Sie die Einstiegssignale. Indikatoren wie KDJ, MACD und andere können in Kombination mit dem RSI zu einem zuverlässigeren Handelssignal führen.
Dynamische Anpassung der Anzahl der Verzögerungszyklen. Die Anzahl der Verzögerungszyklen kann dynamisch angepasst werden, je nachdem, wie stark der Markt schwankt. Dies erhöht die Eintrittsgenauigkeit und verhindert einen falschen Durchbruch.
Optimierung der Stop-Loss-Strategie. Man kann Dynamische Stop-Loss-Strategien, Stop-Loss-Strategien, Stop-Loss-Strategien und Stop-Loss-Strategien untersuchen, um die Stop-Loss-Strategien besser an die Marktschwankungen anzupassen.
In Kombination mit Trendfaktoren kann die Übereinstimmung der Breakout-Richtung mit der Richtung des großen Trends beurteilt werden, um einen Gegenhandel zu vermeiden. Die Anzahl der Verzögerungszyklen kann auch an die Breakout-Stärke angepasst werden.
Mit Hilfe von maschinellem Lernen wird die optimale Parameterkombination gefunden. Durch eine große Menge an Training und Rückmeldung von Daten kann das Maschinelle Lernen die Parameter automatisch anpassen, um die optimale Parameterkombination zu erhalten.
Insgesamt gibt es noch viel Optimierungsmöglichkeiten für diese Strategie, die durch Kennzahlenkombinationen, dynamische Komponentierung und Trendbeurteilung robuster und zuverlässiger gemacht werden kann. Die Anwendung von maschinellem Lernen ist eine weitere Optimierungsrichtung.
Zusammenfassen
Verzögerung der RSI-Strategie overall Die Verwendung des RSI-Indikators, um Überkauf-Überverkauf zu beurteilen, und die Verzögerung eines bestimmten Zyklus nach dem Auftreten eines Signals kann einen unnötigen Verlust verhindern. Die Strategie hat Vorteile wie die Genauigkeit der Kennzahlen, die Verzögerung des Eintritts, die Vermeidung von Falschbrüchen, die Anpassung der Verzögerungsphase und die Durchführung von Stop-Loss-Management.
/*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)