Estrategia de trading con RSI retrasado
ChaoZhang
Descripción general
La estrategia de negociación RSI de retraso utiliza el indicador RSI convencional para identificar sobrecompras y sobreventas, y retrasa la entrada después de un período determinado después de la aparición de la señal de entrada, para evitar pérdidas innecesarias causadas por una falsa ruptura. La idea principal de la estrategia es usar el indicador RSI para juzgar el fenómeno de sobrecompra y sobreventa del mercado y, sobre la base de este juicio, obtener una oportunidad de entrada más precisa mediante el retraso en la entrada.
Principio de estrategia
La estrategia utiliza el indicador RSI de 21 ciclos de longitud para determinar sobrecompra y sobreventa. Cuando el indicador RSI atraviesa la línea de sobrecompra establecida por el usuario (default 60), se considera sobrecompra; cuando el indicador RSI atraviesa la línea de sobreventa establecida por el usuario (default 40), se considera sobreventa.
Una vez que se detecta una señal de sobreventa, la estrategia no entra en juego de inmediato, sino que comienza a calcular el ciclo de retraso. Cuando se cumple el número de ciclos de retraso (el ciclo 15 predeterminado), se vacía y se supera la señal de sobreventa.
Esta estrategia permite a los usuarios ajustar el número de ciclos de retardo para lograr diferentes tiempos de entrada. Los ciclos de retardo más largos evitan más brechas falsas, pero también pueden perder mejores puntos de entrada. Los usuarios necesitan ajustar los parámetros de ciclo de retardo según la variedad específica.
Además, la estrategia también permite opciones de stop loss, stop stop y reversión. El usuario puede elegir entre el stop fijo, el stop de seguimiento y el stop fijo para administrar su posición. También puede elegir la lógica de negociación inversa, es decir, hacer más de acuerdo con la señal de sobrecompra y la señal de sobreventa.
Ventajas estratégicas
El RSI es un indicador más maduro de la superación de la superación de la superación de la superación de la superación de la superación de la superación de la superación de la superación de la superación.
El mecanismo de entrada tardía evita que las falsas brechas causen pérdidas. Muchas brechas no necesariamente representan un cambio sustancial, y la entrada tardía puede verificar la efectividad de las brechas.
Se puede ajustar el número de ciclos de retardo para conocer el momento exacto de entrada. El usuario puede ajustar el ciclo de retardo según las características de las diferentes variedades para lograr el mejor punto de entrada.
Implementar la gestión de la parada y el control del riesgo. La estrategia ofrece varias formas de parada y control del riesgo que pueden combinarse con la entrada tardía.
Ofrece opciones de negociación inversa para adaptarse a las características de las diferentes variedades. El usuario puede elegir entre una lógica de negociación positiva o inversa para cubrir la incertidumbre.
Riesgo estratégico
El riesgo de que el RSI emita señales falsas. Las señales del RSI no siempre son efectivas, y en algunas situaciones del mercado pueden aparecer señales erróneas.
Demasiados retrasos con el riesgo de perder la hora de entrada. Si el ciclo de retraso es demasiado largo, se perderá el mejor punto de entrada.
Las inversiones inversas aumentan el riesgo de pérdidas. Si bien las inversiones inversas pueden cubrir la incertidumbre, también pueden ampliar las pérdidas generales.
El trazado de los estancamientos está cubierto por el riesgo. El trazado de los estancamientos puede estar demasiado cerca de los precios actuales cuando los precios cambian drásticamente y el precio se rompe.
Las previsiones de la parálisis no deben causar una ganancia insuficiente. Las previsiones fijas no pueden alcanzar la máxima ganancia y requieren una estimación razonable para establecerlas.
Para los riesgos mencionados, las recomendaciones de optimización son las siguientes:
En combinación con otros indicadores de filtración de señales RSI, mejora la fiabilidad. Por ejemplo, KDJ, MACD y otros indicadores.
Para obtener el mejor parámetro de ciclo de retardo de acuerdo con las pruebas de datos históricos de las diferentes variedades. No es conveniente hacer generalizaciones.
El uso de la función de inversiones debe ser prudente, preferiblemente en combinación con el comercio de tendencias.
Establezca un intervalo más amplio para el seguimiento de las paradas y evite acercarse demasiado al precio actual.
Prueba diferentes multiplicadores de frenado para encontrar el parámetro óptimo. También se puede considerar el frenado dinámico.
Dirección de optimización
La estrategia puede ser optimizada en los siguientes aspectos:
La combinación de varios indicadores filtra la señal de entrada. Indicadores como KDJ, MACD y otros se combinan con el RSI para formar una señal de negociación más confiable.
Ajuste dinámico del número de ciclos de retardo. Se puede cambiar dinámicamente el número de ciclos de retardo en función de la volatilidad del mercado, y al mismo tiempo se puede mejorar la precisión de la entrada, al tiempo que se garantiza la evitación de brechas falsas.
Optimización de las estrategias de stop loss. Se puede estudiar el stop loss dinámico, el stop loss de la tasa de retirada de ganancias, el stop loss de tiempo, etc., para que el stop loss se ajuste mejor a las características de la volatilidad del mercado.
Combinando los factores de tendencia, se puede determinar la coincidencia de la dirección de la ruptura con la dirección de la gran tendencia, evitando el comercio en contra. También se puede ajustar el número de ciclos de retardo en función de la fuerza de la ruptura.
Utiliza el aprendizaje automático para encontrar la combinación óptima de parámetros. A través de una gran cantidad de entrenamiento y datos de retroalimentación, el aprendizaje automático puede ajustar automáticamente los parámetros para obtener la combinación óptima de parámetros.
En resumen, la estrategia todavía tiene mucho espacio para ser optimizada, y puede ser más robusta y confiable a través de combinaciones de indicadores, modulación dinámica y discernimiento de tendencias. La aplicación de aprendizaje automático también es una dirección de optimización que se puede esperar en el futuro.
Resumir
La estrategia general de retraso del RSI utiliza el indicador RSI para juzgar la situación de sobreventa y sobreventa, y retrasar un cierto período de reingreso después de la aparición de la señal, para evitar pérdidas innecesarias. La estrategia tiene ventajas como la precisión de la determinación del indicador, la prevención de la retraso del retraso del retraso, la adaptabilidad del ciclo de retraso y la gestión de la parada de pérdidas.
/*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)