A estratégia de negociação do RSI atrasado utiliza o indicador RSI convencional para identificar condições de sobrecompra e sobrevenda, e atrasos na entrada no mercado por um certo período após o sinal para evitar perdas desnecessárias por fugas falsas.
Esta estratégia usa um indicador RSI de 21 períodos para determinar condições de sobrecompra e sobrevenda. Quando o indicador RSI cruza acima do nível de sobrecompra definido pelo usuário (default 60), o mercado é considerado sobrecomprado. Quando o RSI cruza abaixo do nível de sobrevenda definido pelo usuário (default 40), o mercado é considerado sobrevendo.
Após identificar sinais de sobrecompra ou sobrevenda, a estratégia não entra no mercado imediatamente. Em vez disso, começa a contar o período de atraso. Quando o período de atraso (default 15 bares) é atingido, entra em curto com base no sinal de sobrecompra e longo com base no sinal de sobrevenda.
A estratégia permite aos usuários ajustar o período de atraso para alcançar diferentes tempos de entrada. Um período de atraso mais longo pode evitar mais falhas falsas, mas também pode perder melhores oportunidades de entrada. Os usuários precisam ajustar o parâmetro do período de atraso com base nas características de produtos específicos.
Além disso, a estratégia também implementa opções como stop loss, take profit, reverse trading, etc. Os usuários podem escolher stop loss fixo, trailing stop loss, fixed take profit e assim por diante para gerenciar posições.
Utilize o indicador RSI para identificar condições de sobrecompra/supervenda com precisão e capturar oportunidades de reversão.
A entrada atrasada evita perdas de fugas falsas. Muitas fugas não levam necessariamente a reversões reais. A entrada atrasada verifica a validade.
O período de atraso ajustável permite um tempo de entrada preciso. Os usuários podem otimizar o período de atraso com base nas características do produto para melhor entrada.
Implementar stop loss e take profit para controlar os riscos. A estratégia oferece várias maneiras como SL/TP fixo, SL traseiro etc para gerenciar riscos.
A opção de negociação reversa adapta-se a diferentes produtos. Os usuários podem escolher a lógica normal ou inversa para cobrir incertezas.
Risco de sinais falsos de RSI Os sinais RSI podem nem sempre ser precisos e podem dar sinais falsos às vezes.
Risco de oportunidades perdidas se o atraso for demasiado longo Um atraso excessivo pode resultar em pontos de entrada perdidos.
Aumentar o risco de perdas decorrentes da negociação reversa.
Risco de seguir o SL muito perto e ser parado prematuramente.
Lucro insuficiente devido a TP fixo impreciso. O TP fixo não pode atingir o lucro máximo e necessita de previsões razoáveis.
Para enfrentar estes riscos, as sugestões de otimização são:
Filtre os sinais do RSI com outros indicadores como KDJ, MACD etc. para melhorar a confiabilidade.
Repetir o teste com dados históricos para encontrar o período de atraso ideal para cada produto.
Use a lógica inversa com cautela, de preferência combinando com a tendência.
Manter um amplo buffer para a SL para evitar que os preços se aproximem demais.
Teste diferentes proporções de TP para encontrar o ideal.
A estratégia pode ser ainda melhorada nos seguintes aspectos:
Combinar vários indicadores para filtrar sinais de entrada, por exemplo, KDJ, MACD com RSI para sinais mais robustos.
Ajustar dinamicamente o período de atraso com base na volatilidade do mercado, mantendo a prevenção de falhas de ruptura e melhorando a precisão de entrada.
Otimizar as estratégias SL/TP, tais como SL dinâmicas, SL de retracement de lucro, SL baseada no tempo, etc., tornando-as mais adaptáveis às oscilações do mercado.
Incorporar a tendência. Medir se a direção de ruptura se alinha com a tendência principal. Também ajustar o período de atraso com base no momento de ruptura.
Usar aprendizado de máquina para encontrar combinações ótimas de parâmetros. ML pode ajustar automaticamente parâmetros com base em grandes conjuntos de dados de treinamento e backtest.
Em conclusão, a estratégia tem amplo espaço para otimização através de combinações de indicadores, ajuste dinâmico de parâmetros, integração de tendências, etc.
A estratégia RSI atrasada usa RSI para identificar condições de sobrecompra/supervenda, e atrasos de entrada por um período após o sinal ocorrer para evitar perdas desnecessárias de falsificações. A estratégia tem vantagens como identificação precisa de sinal, entrada atrasada para evitar falhas, período de atraso ajustável, implementação SL/TP etc. Mas existem riscos como sinais RSI não confiáveis, oportunidades perdidas por atraso excessivo. Estes podem ser melhorados ainda mais através da otimização da precisão do sinal através de combinações de indicadores, sintonização de período de atraso dinâmico, melhores estratégias SL/TP etc. A estratégia tem amplas oportunidades de otimização e vale a pena explorar.
/*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)