Stratégie de trading RSI différée
ChaoZhang
Aperçu
La stratégie de négociation RSI de retard utilise l’indicateur RSI classique pour identifier les cas de survente et de survente et retarde l’entrée après un certain laps de temps après l’apparition du signal d’entrée afin d’éviter les pertes inutiles causées par une fausse rupture. L’idée principale de la stratégie est d’utiliser l’indicateur RSI pour juger du phénomène de survente et de survente du marché et, sur la base de ce jugement, de saisir plus précisément les opportunités d’entrée en bourse en retardant l’entrée.
Principe de stratégie
La stratégie utilise le RSI de 21 cycles pour juger si un cours est en hausse ou en hausse. Il est considéré comme en hausse lorsque le RSI traverse la ligne de survente définie par l’utilisateur (par défaut 60). Il est considéré comme en hausse lorsque le RSI traverse la ligne de survente définie par l’utilisateur (par défaut 40).
Une fois que le signal de surachat et de survente a été détecté, la stratégie n’entre pas immédiatement en jeu, mais commence à calculer le cycle de retard. Lorsque le nombre de cycles de retard (le cycle 15 par défaut) est satisfait, le signal de surachat et de survente est suivi.
Cette stratégie permet à l’utilisateur d’ajuster le nombre de cycles de retard pour réaliser différents moments d’entrée. Plus le cycle de retard est long, plus de faux-pas peut être évité, mais il est également possible de manquer de meilleurs points d’entrée.
En outre, la stratégie implique des options telles que les arrêts de perte, les arrêts de vente et les transactions inverses. Les utilisateurs peuvent choisir de gérer leurs positions de manière à fixer les arrêts de vente, suivre les arrêts de vente et les arrêts de vente.
Avantages stratégiques
L’indicateur RSI est utilisé pour déterminer les situations de survente et de survente et saisir avec précision les occasions de reprise. L’indicateur RSI est un indicateur de survente et de survente plus mature qui permet d’identifier efficacement les occasions de reprise.
Le mécanisme de retard d’entrée permet d’éviter les faux percées qui entraînent des pertes. Beaucoup de percées ne représentent pas nécessairement une inversion substantielle, et le retard d’entrée peut vérifier l’efficacité de la percée.
Le nombre de cycles de retard peut être ajusté pour déterminer précisément le moment de l’entrée. L’utilisateur peut ajuster le cycle de retard en fonction des caractéristiques des différentes variétés pour atteindre le meilleur point d’entrée.
La stratégie fournit plusieurs méthodes de stop loss qui peuvent être combinées avec des délais d’entrée pour contrôler les risques.
Offre des options de négociation inversées adaptées aux caractéristiques des différentes variétés. L’utilisateur peut choisir une logique de négociation positive ou inverse pour couvrir l’incertitude.
Risque stratégique
Les signaux RSI ne sont pas toujours efficaces et peuvent être erronés dans certaines conditions de marché.
Le risque de rater l’heure d’arrivée est trop élevé.
Les opérations inverses augmentent le risque de pertes. Bien que les opérations inverses couvrent l’incertitude, elles peuvent également augmenter les pertes globales.
Le stop tracking risque d’être bloqué. Le stop tracking risque d’être bloqué si le prix change fortement et s’approche trop près du prix actuel.
Le stop estimé ne doit pas entraîner de profits insuffisants. Le stop fixe ne peut pas atteindre le maximum de profits et nécessite une estimation raisonnable pour le régler.
Les recommandations d’optimisation pour ces risques sont les suivantes:
En combinaison avec d’autres indicateurs de filtrage RSI, améliorer la fiabilité. Par exemple, KDJ, MACD et autres indicateurs.
Il est préférable de déterminer les paramètres optimaux de la période de retard en fonction des données historiques des différentes variétés. Il est préférable de ne pas généraliser.
Utilisez prudemment les fonctionnalités de trading inversé, de préférence en combinaison avec des méthodes telles que le trading de tendance.
Lorsque vous suivez les arrêts, définissez une distance plus large pour éviter d’être trop près du prix actuel.
Testez différents multiplicateurs d’arrêt pour trouver le paramètre optimal. Vous pouvez également considérer l’arrêt dynamique.
Direction d’optimisation
Cette stratégie peut être optimisée dans les domaines suivants:
La combinaison de plusieurs indicateurs de filtrage des signaux d’entrée. Par exemple, KDJ, MACD et autres indicateurs combinés avec le RSI peuvent former un signal de négociation plus fiable.
Le nombre de cycles de retard peut être modifié en fonction de la volatilité du marché, ce qui permet d’améliorer l’exactitude de l’entrée tout en évitant les fausses percées.
Optimiser les stratégies de stop-loss. On peut étudier les stop-loss dynamiques, les stop-loss de taux de rétractation des bénéfices, les stop-loss temporels, etc., afin de rendre les stop-loss plus adaptés aux caractéristiques de la volatilité du marché.
Il est possible d’évaluer la corrélation entre la direction de la rupture et la direction de la tendance générale, en évitant les transactions à contre-courant. Il est également possible d’ajuster le nombre de cycles de retard en fonction de la force de la rupture.
L’apprentissage automatique permet de trouver les combinaisons optimales de paramètres. Grâce à une grande quantité de données d’entraînement et de rétroaction, l’apprentissage automatique peut ajuster automatiquement les paramètres pour obtenir la meilleure combinaison de paramètres.
Dans l’ensemble, la stratégie a encore beaucoup de possibilités d’optimisation, et peut être rendue plus stable et plus fiable par la combinaison d’indicateurs, la modulation dynamique et la perception des tendances. L’application de l’apprentissage automatique est également une direction d’optimisation envisageable à l’avenir.
Résumer
La stratégie de retard RSI overall L’utilisation de l’indicateur RSI pour juger de la situation de survente et de survente, et le retard d’un certain cycle de réentrée après l’apparition d’un signal, peut éviter efficacement les fausses ruptures entraînant des pertes inutiles. Cette stratégie présente des avantages tels que l’exactitude de la détermination de l’indicateur, le retard d’entrée pour éviter les fausses ruptures, l’ajustement du cycle de retard et la gestion des arrêts et des arrêts.
/*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)