La estrategia de negociación RSI con retraso utiliza el indicador RSI convencional para identificar condiciones de sobrecompra y sobreventa, y retrasos en la entrada al mercado durante un cierto período después de que la señal parece evitar pérdidas innecesarias por rupturas falsas.
Esta estrategia utiliza un indicador RSI de 21 períodos para determinar las condiciones de sobrecompra y sobreventa. Cuando el indicador RSI cruza por encima del nivel de sobrecompra definido por el usuario (default 60), el mercado se considera sobrecomprado. Cuando el RSI cruza por debajo del nivel de sobreventa definido por el usuario (default 40), el mercado se considera sobrevendido.
Después de identificar las señales de sobrecompra o sobreventa, la estrategia no entra en el mercado de inmediato. En su lugar, comienza a contar el período de retraso. Cuando se cumple el período de retraso (default 15 bares), entra corto basado en la señal de sobrecompra, y largo basado en la señal de sobreventa.
La estrategia permite a los usuarios ajustar el período de retraso para lograr diferentes tiempos de entrada. Un período de retraso más largo puede evitar más breakouts falsos, pero también puede perder mejores oportunidades de entrada. Los usuarios necesitan ajustar el parámetro del período de retraso basado en las características de productos específicos.
Además, la estrategia también implementa opciones como stop loss, take profit, reverse trading, etc. Los usuarios pueden elegir stop loss fijo, trailing stop loss, take profit fijo y así sucesivamente para gestionar posiciones.
Utilice el indicador RSI para identificar con precisión las condiciones de sobrecompra / sobreventa y captar oportunidades de reversión.
El retraso en la entrada evita pérdidas por fugas falsas. Muchas fugas no necesariamente conducen a reversiones reales.
El período de retraso ajustable permite un tiempo de entrada preciso. Los usuarios pueden optimizar el período de retraso basado en las características del producto para una mejor entrada.
Implementar stop loss y tomar ganancias para controlar los riesgos. La estrategia ofrece múltiples formas como SL / TP fijo, SL trasero, etc. para gestionar los riesgos.
La opción de negociación inversa se adapta a diferentes productos. Los usuarios pueden elegir la lógica normal o inversa para cubrir incertidumbres.
El riesgo de señales falsas del RSI Las señales del RSI pueden no ser siempre precisas y a veces pueden dar señales falsas.
El riesgo de perder oportunidades si el retraso es demasiado largo.
Aumento del riesgo de pérdidas por operaciones inversas Aunque las operaciones inversas cubren incertidumbres, también pueden amplificar la pérdida total.
El riesgo de que SL se acerque demasiado y sea detenido prematuramente.
Ganancia insuficiente debido a un TP fijo inexacto. El TP fijo no puede alcanzar el beneficio máximo y necesita una previsión razonable.
Para hacer frente a estos riesgos, las sugerencias de optimización son:
Filtrar las señales RSI con otros indicadores como KDJ, MACD, etc. para mejorar la confiabilidad.
Prueba de retroceso con datos históricos para encontrar el período de retraso óptimo para cada producto.
Utilice la lógica inversa con precaución, preferiblemente combinado con la tendencia siguiente.
Mantenga un amplio amortiguador para que los precios sigan a SL para evitar que se acerquen demasiado.
Prueba diferentes ratios de TP para encontrar el óptimo.
La estrategia se puede optimizar aún más en los siguientes aspectos:
Combinar múltiples indicadores para filtrar las señales de entrada, por ejemplo, KDJ, MACD con RSI para obtener señales más sólidas.
Ajuste dinámico del período de demora basado en la volatilidad del mercado, manteniendo así la evitación de falsas rupturas y mejorando la precisión de entrada.
Optimizar las estrategias SL/TP, tales como SL dinámicas, SL de ratio de retracción de ganancias, SL basada en el tiempo, etc., haciéndolas adaptarse mejor a las oscilaciones del mercado.
Incorporar tendencia. Medir si la dirección de la ruptura se alinea con la tendencia principal. También ajustar el período de retraso basado en el impulso de la ruptura.
Utilice el aprendizaje automático para encontrar combinaciones óptimas de parámetros.
En conclusión, la estrategia tiene un amplio margen de optimización a través de combinaciones de indicadores, ajuste dinámico de parámetros, integración de tendencias, etc. El aprendizaje automático también es una dirección prometedora para el futuro.
La estrategia de RSI retrasado en general utiliza RSI para identificar condiciones de sobrecompra / sobreventa, y retrasa la entrada por un período después de que ocurra la señal para evitar pérdidas innecesarias por falsificaciones. La estrategia tiene ventajas como la identificación precisa de la señal, la entrada tardía para evitar roturas falsas, el período de retraso ajustable, la implementación SL / TP, etc. Pero existen riesgos como señales RSI poco confiables, oportunidades perdidas por retraso excesivo. Estos pueden mejorarse aún más mediante la optimización de la precisión de la señal a través de combinaciones de indicadores, ajuste dinámico del período de retraso, mejores estrategias SL / TP, etc. La estrategia tiene amplias oportunidades de optimización y vale la 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)