Estratégia de negociação RSI atrasada
ChaoZhang
Visão geral
A estratégia de negociação de RSI de atraso usa o indicador RSI convencional para identificar situações de sobrevenda e sobrevenda e, após o surgimento do sinal de entrada, atrasa a entrada em mercado após um determinado período, para evitar que a falsa ruptura cause perdas desnecessárias. A principal idéia da estratégia é usar o indicador RSI para julgar o fenômeno de sobrevenda e sobrevenda do mercado e, com base nesse julgamento, obter uma oportunidade de entrada mais precisa por meio do atraso na entrada.
Princípio da estratégia
A estratégia usa o indicador RSI de 21 ciclos de comprimento para julgar a sobrevenda. Quando o indicador RSI atravessa a linha de supervenda definida pelo usuário (default 60), considera-se que o mercado está sobrevendido; Quando o indicador RSI atravessa a linha de supervenda definida pelo usuário (default 40), considera-se que o mercado está sobrevendido.
A estratégia não entra em jogo imediatamente após o surgimento de um sinal de sobrevenda, mas começa a calcular o ciclo de atraso. Quando o número de ciclos de atraso (o padrão de 15 ciclos) for satisfeito, faça um vazio de acordo com o sinal de sobrevenda e faça mais.
A estratégia permite que o usuário ajuste o número de ciclos de atraso para atingir diferentes momentos de entrada. Quanto maior o período de atraso, mais falsas brechas são evitadas, mas também é possível perder melhores pontos de entrada. O usuário precisa ajustar os parâmetros do ciclo de atraso de acordo com a variedade específica.
Além disso, a estratégia também permite opções de stop loss, stop-loss e reversão. Os usuários podem optar por controlar suas posições de forma fixa de stop loss, tracking stop loss, stop-loss fixo e assim por diante. Também é possível optar pela lógica de negociação reversa, ou seja, fazer mais de acordo com o sinal de sobrecompra e fazer zero com o sinal de sobrevenda.
Vantagens estratégicas
O RSI é um indicador mais maduro de overbought e oversold que pode ser usado para identificar oportunidades de reversão.
O mecanismo de admissão retardada evita que as falsas brechas causem prejuízos. Muitas brechas não representam necessariamente uma reversão substancial, e a admissão retardada pode verificar a eficácia das brechas.
Pode-se ajustar o número de ciclos de atraso, para ter uma visão precisa do momento de entrada. O usuário pode ajustar o ciclo de atraso de acordo com as características de diferentes variedades, para obter o melhor ponto de entrada.
Implementar stop loss, gestão de paradas e controle de riscos. A estratégia oferece várias formas de stop loss e paradas, que podem ser combinadas com o atraso no ingresso para controlar os riscos.
Oferece opções de negociação reversa, adaptando-se às características de diferentes variedades. O usuário pode escolher a lógica de negociação positiva ou inversa, para cobrir a incerteza.
Risco estratégico
O RSI pode emitir sinais falsos. Os sinais do RSI nem sempre são eficazes e podem ocorrer sinais errados em algumas situações de mercado.
Demora demais e corre o risco de perder o ponto de entrada.
A negociação reversa aumenta o risco de perda. Embora possa cobrir a incerteza, a negociação reversa também pode aumentar a perda total.
O tracking stop é um risco de defesa. O tracking stop pode se aproximar muito do preço atual, quando o preço muda drasticamente, e o preço pode ser quebrado.
A estimativa de paragem não deve causar lucro insuficiente. A paragem fixa não pode alcançar o máximo de lucro e precisa ser razoavelmente estimada para ser configurada.
As recomendações de otimização para esses riscos são:
Em combinação com outros indicadores de filtragem de sinais RSI, para aumentar a confiabilidade. Por exemplo, KDJ, MACD e outros indicadores.
Para obter os melhores parâmetros de ciclo de atraso de acordo com os testes de dados históricos de diferentes variedades. Não é recomendável generalizar.
A função de negociação inversa deve ser usada com cautela, de preferência em combinação com a negociação de tendências.
Quando você rastrear um stop loss, defina um intervalo mais largo para evitar ficar muito perto do preço atual.
Teste diferentes parâmetros de impedância para encontrar o parâmetro ideal. Também pode ser considerado o parâmetro de impedância dinâmica.
Direção de otimização
A estratégia pode ser melhorada em alguns aspectos:
A combinação de vários indicadores filtra os sinais de entrada. Indicadores como KDJ, MACD e outros, combinados com o RSI, podem formar sinais de negociação mais confiáveis.
Ajuste dinâmico do número de ciclos de atraso. O número de ciclos de atraso pode ser alterado dinamicamente de acordo com a volatilidade do mercado, garantindo a prevenção de brechas falsas e, ao mesmo tempo, aumentando a precisão de entrada.
Optimizar a estratégia de stop loss. Pode-se estudar o stop loss dinâmico, o stop loss da taxa de retirada de lucro, o stop loss de tempo, etc., para que o stop loss seja mais adequado às características de flutuação do mercado.
Combinando fatores de tendência, pode-se determinar a coincidência da direção da ruptura com a direção da grande tendência, evitando a negociação de contrapartida. Também pode-se ajustar o número de ciclos de atraso de acordo com a intensidade da ruptura.
Usando o aprendizado de máquina para encontrar a melhor combinação de parâmetros. Com um grande número de treinamento e dados de retorno, o aprendizado de máquina pode ajustar automaticamente os parâmetros para obter a melhor combinação de parâmetros.
Em suma, a estratégia ainda tem muito espaço para otimização, podendo ser mais robusta e confiável por meio de combinações de indicadores, modelagem dinâmica e discernimento de tendências. A aplicação de aprendizado de máquina também é uma direção de otimização a ser esperada no futuro.
Resumir
A estratégia de atraso do RSI global usa o indicador RSI para julgar a sobrevenda e a sobrevenda e, após o surgimento do sinal, atrasa um certo ciclo de reentrada, para evitar que a falsa ruptura cause perdas desnecessárias. A estratégia tem vantagens como a precisão da determinação do indicador, o atraso da entrada para evitar a falsa ruptura, o ciclo de atraso pode ser ajustado e a gestão de stop loss pode ser implementada.
/*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)