L'idée principale de cette stratégie est d'utiliser l'indicateur RSI pour juger des conditions de marché surachetées et survendues, et d'obtenir un calendrier d'entrée plus précis en retardant l'entrée en fonction de ce jugement.
Cette stratégie utilise un indicateur RSI de 21 périodes pour déterminer les conditions de surachat et de survente. Lorsque l'indicateur RSI dépasse le niveau de surachat défini par l'utilisateur (défaut 60), le marché est considéré comme suracheté. Lorsque l'indicateur RSI dépasse le niveau de survente défini par l'utilisateur (défaut 40), le marché est considéré comme survendu.
Après avoir identifié les signaux de surachat ou de survente, la stratégie n'entre pas immédiatement sur le marché. Au lieu de cela, elle commence à compter la période de retard. Lorsque la période de retard (défaut 15 barres) est atteinte, elle entre en short basé sur le signal de surachat et en long basé sur le signal de survente.
La stratégie permet aux utilisateurs d'ajuster la période de retard pour atteindre des temps d'entrée différents. Une période de retard plus longue peut éviter plus de fausses fuites, mais peut également manquer de meilleures opportunités d'entrée. Les utilisateurs doivent ajuster le paramètre de la période de retard en fonction des caractéristiques de produits spécifiques.
En outre, la stratégie implémente également des options telles que le stop loss, le take profit, le reverse trading, etc. Les utilisateurs peuvent choisir le stop loss fixe, le trailing stop loss, le fixed take profit, etc. pour gérer les positions.
Utilisez l'indicateur RSI pour identifier avec précision les conditions de surachat/survente et saisir les opportunités d'inversion.
L'entrée retardée évite les pertes causées par de fausses évasions.
Les utilisateurs peuvent optimiser la période de retard en fonction des caractéristiques du produit pour une meilleure entrée.
La stratégie offre de multiples façons comme la SL/TP fixe, la SL de suivi, etc. pour gérer les risques.
L'option de trading inverse s'adapte à différents produits. Les utilisateurs peuvent choisir la logique normale ou inverse pour couvrir les incertitudes.
Les signaux RSI peuvent ne pas toujours être exacts et peuvent parfois donner de faux signaux.
Le risque de manquer des opportunités si le délai est trop long.
Augmentation du risque de perte lié à la négociation inverse.
Le risque que SL soit trop proche et qu'il soit arrêté prématurément.
Profit insuffisant dû à une TP fixe inexacte. La TP fixe ne peut pas réaliser un profit maximal et nécessite une prévision raisonnable.
Pour faire face à ces risques, les suggestions d'optimisation sont les suivantes:
Filtrer les signaux RSI avec d'autres indicateurs tels que KDJ, MACD, etc. pour améliorer la fiabilité.
Test de retour avec des données historiques pour trouver la période de retard optimale pour chaque produit.
Utilisez la logique inverse avec prudence, de préférence en combinant avec la tendance suivante.
Gardez un large tampon pour la SL afin d'éviter que les prix ne se rapprochent trop.
Testez différents ratios de TP pour trouver l'optimum.
La stratégie peut être encore optimisée dans les aspects suivants:
Combiner plusieurs indicateurs pour filtrer les signaux d'entrée, par exemple KDJ, MACD avec RSI pour obtenir des signaux plus robustes.
Ajustez dynamiquement la période de retard en fonction de la volatilité du marché.
Optimiser les stratégies SL/TP, telles que la SL dynamique, le ratio de retracement des bénéfices SL, la SL basée sur le temps, etc., les rendant mieux adaptées aux fluctuations du marché.
Incorporer la tendance. Mesurer si la direction de la rupture s'aligne avec la tendance principale. Ajuster également la période de retard en fonction de la dynamique de la rupture.
Utilisez l'apprentissage automatique pour trouver des combinaisons optimales de paramètres.
En conclusion, la stratégie offre une large marge d'optimisation par le biais de combinaisons d'indicateurs, de réglage dynamique des paramètres, d'intégration des tendances, etc. L'apprentissage automatique est également une direction prometteuse pour l'avenir.
La stratégie RSI retardée utilise globalement le RSI pour identifier les conditions de surachat/survente, et retarde l'entrée pendant une période après que le signal se produise pour éviter les pertes inutiles de faux-sacs. La stratégie présente des avantages tels que l'identification précise du signal, l'entrée retardée pour éviter les fausses ruptures, la période de retard réglable, la mise en œuvre SL/TP, etc. Mais des risques tels que des signaux RSI peu fiables, des opportunités manquées de retard excessif existent. Ceux-ci peuvent être améliorés en optimisant la précision du signal via des combinaisons d'indicateurs, un réglage dynamique de la période de retard, de meilleures stratégies SL/TP, etc. La stratégie présente de larges opportunités d'optimisation et vaut la peine d'être explorée.
/*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)