En la carga de los recursos... Cargando...

Estrategia de negociación de la divergencia RSI

El autor:¿ Qué pasa?, Fecha: 2023-10-25 16:47:14
Las etiquetas:

Resumen general

La estrategia de negociación RSI Divergencia genera señales de compra y venta mediante la identificación de divergencias entre el indicador RSI y el movimiento del precio.

Principio

Esta estrategia utiliza principalmente divergencias en el indicador RSI para identificar oportunidades comerciales. Específicamente, la estrategia primero calcula los valores del RSI durante un cierto período, luego traza las líneas de tendencia tanto para el indicador RSI como para el precio.

Si la estrategia detecta el fondo de la línea RSI mientras que la línea de precios supera, se genera una señal de compra. Si la línea RSI supera mientras la línea de precios baja, se genera una señal de venta. Una vez que ocurre una señal de negociación, la estrategia puede operar de acuerdo con el tamaño del valor del RSI.

Además, la estrategia tiene características de stop loss, take profit y trailing stop loss. El stop loss controla los riesgos a la baja, bloquea los beneficios en los beneficios y el trailing stop permite que los beneficios se ejecuten.

Ventajas

La estrategia de negociación de la divergencia RSI tiene las siguientes ventajas:

La captura de las divergencias del RSI puede detectar temprano las inversiones de tendencia.
El RSI es ampliamente utilizado y disponible en la mayoría de las plataformas de negociación.
Los parámetros del RSI son flexibles y pueden ajustarse a las diferentes condiciones del mercado.
Los controles de stop loss, take profit y trailing controlan el riesgo de manera efectiva.
La estrategia tiene una frecuencia de señal moderada, evitando el exceso de negociación.
La lógica es simple y fácil de programar para automatización.

Los riesgos

La estrategia también tiene algunos riesgos:

Las divergencias del RSI no son completamente fiables y pueden generar señales falsas.
Las divergencias pueden fracasar en mercados con tendencias fuertes, lo que debe evitarse.
Los parámetros de RSI incorrectos pueden afectar el rendimiento.
Si el stop loss está demasiado ajustado, las ganancias disminuirán; si está demasiado suelto, el riesgo no se limitará.
El trailing stop puede detenerse prematuramente durante los mercados volátiles. Se requiere un ancho de trailing razonable teniendo en cuenta la volatilidad.

Los riesgos pueden mitigarse mediante:

Añadiendo otros indicadores como MACD, Bandas de Bollinger para filtrar las señales y reducir las señales falsas.
Utilizando la estrategia solo durante los mercados laterales de rango, evitando tendencias fuertes.
Optimización de los parámetros del RSI, selección de los periodos óptimos de retroalimentación, pruebas de parámetros para diferentes mercados.
Establecer niveles razonables de stop loss y tomar ganancias basados en pruebas históricas.
Ajuste de la distancia de detención posterior en función de la volatilidad del mercado y el apetito por el riesgo.

Optimización

La estrategia puede mejorarse en los siguientes aspectos:

Incorporar otros indicadores para filtrar las señales y mejorar la confiabilidad.
Utilice el aprendizaje automático para optimizar automáticamente los parámetros de RSI.
Diseñar algoritmos de stop loss dinámicos de acuerdo con los regímenes del mercado.
Construir un modelo dinámico de posicionamiento basado en la volatilidad para ajustar los tamaños de las posiciones.
Introduzca volatilidad en el trailing stop para establecer la distancia de trail basada en las oscilaciones de precios.
Implementar estrategias en otros mercados como divisas y criptomonedas.
Desarrollar un sistema de comercio cuantitativo para la automatización.

Conclusión

La estrategia de negociación de divergencia del RSI genera señales identificando divergencias entre el RSI y el precio. La lógica es simple y fácil de automatizar. El stop loss, take profit y trailing stop controla eficazmente los riesgos. Sin embargo, la estrategia tiene limitaciones en la precisión y los mercados de tendencia. Se pueden hacer mejoras mediante la optimización de parámetros, la adición de filtros y paradas dinámicas. Como estrategia técnica, puede servir como complemento durante los mercados de rango cuando se sistematiza.

/*backtest
start: 2023-09-24 00:00:00
end: 2023-10-24 00:00:00
period: 4h
basePeriod: 15m
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/
// © faytterro

//@version=5
// strategy("RSI Divergence Strategy", overlay=true, scale = scale.none)
rsilen=input.int(14, title="rsi length")
rsisrc=input(close, title="source")
x=ta.rsi(rsisrc,rsilen)
len=input.int(14, title="RSI Divergence length", maxval=500)
tpb = input.float(25, title="take profit", group = "buy", step = 0.5)
sb = input.float(5, title="stop", group = "buy", step = 0.5)
tsb = input.float(0.25, title="trailing stop", group = "buy", step = 0.5)
tps = input.float(25, title="take profit", group = "sell", step = 0.5)
ss =input.float(5, title="stop", group = "sell", step = 0.5)
tss = input.float(0.25, title="trailing stop", group = "sell", step = 0.5)
src=close
extrapolation=0
zoom=input.int(0, title="zoom", maxval=27, minval=-27)
hline(300-zoom*10, color=color.rgb(54, 58, 69, 100))
hline(10, color=color.rgb(54, 58, 69, 100))
// for ax+b
xo=0.0
yo=0.0
xyo=0.0
xxo=0.0
for i=0 to len-1
    xo:= xo + i/(len)
    yo:= yo + x[len-1-i]/(len)
    xyo:= xyo + i*x[len-1-i]/(len)
    xxo:= xxo + i*i/(len)
dnm=ta.lowest(low,200)
dizi=array.new_float(len*2+1+extrapolation)
// linedizi=array.new_line()
a=(xo*yo-xyo)/(xo*xo-xxo)
b=yo-a*xo
for i=0 to len-1+extrapolation
    array.set(dizi,i,a*i+b)
//// for src
// for ax+b
xo2=0.0
yo2=0.0
xyo2=0.0
xxo2=0.0
for i=0 to len-1
    xo2:= xo2 + i/(len)
    yo2:= yo2 + src[len-1-i]/(len)
    xyo2:= xyo2 + i*src[len-1-i]/(len)
    xxo2:= xxo2 + i*i/(len)

dizi2=array.new_float(len*2+1+extrapolation)
// linedizi2=array.new_line()
a2=(xo2*yo2-xyo2)/(xo2*xo2-xxo2)
b2=yo2-a*xo2
for i=0 to len-1+extrapolation
    array.set(dizi2,i,a2*i+b2)
ttk=((array.get(dizi,0)<array.get(dizi,1)) and (array.get(dizi2,0)>array.get(dizi2,1)))? 1 : 
 ((array.get(dizi,0)>array.get(dizi,1)) and (array.get(dizi2,0)<array.get(dizi2,1)))? -1 : 0
cg=((array.get(dizi,0)<array.get(dizi,1)) and (array.get(dizi2,0)>array.get(dizi2,1)))// and ta.highest(ttk[1],len/2)<1)
cr=((array.get(dizi,0)>array.get(dizi,1)) and (array.get(dizi2,0)<array.get(dizi2,1)))// and ta.lowest(ttk[1],len/2)>-1)
bgcolor(color=(cg and ta.highest(ttk[1],len/2)<1)? color.rgb(76, 175, 79, 50) : 
 (cr and ta.lowest(ttk[1],len/2)>-1)? color.rgb(255, 82, 82, 50) : na, offset=0, display=display.none)
plot(x)

// for ax+b
xo3=0.0
yo3=0.0
xyo3=0.0
xxo3=0.0
for i=0 to len-1
    xo3:= xo3 + i/(len)
    yo3:= yo3 + x[len-1-i+(ta.barssince(cg))]/(len)
    xyo3:= xyo3 + i*x[len-1-i+(ta.barssince(cg))]/(len)
    xxo3:= xxo3 + i*i/(len)

dizi3=array.new_float(len*2+1+extrapolation)
// linedizi3=array.new_line()
a3=(xo3*yo3-xyo3)/(xo3*xo3-xxo3)
b3=yo3-a3*xo3
for i=0 to len-1+extrapolation
    array.set(dizi3,i,a3*i+b3)

// for ax+b
xo4=0.0
yo4=0.0
xyo4=0.0
xxo4=0.0
for i=0 to len-1
    xo4:= xo4 + i/(len)
    yo4:= yo4 + x[len-1-i+(ta.barssince(cr))]/(len)
    xyo4:= xyo4 + i*x[len-1-i+(ta.barssince(cr))]/(len)
    xxo4:= xxo4 + i*i/(len)

dizi4=array.new_float(len*2+1+extrapolation)
// linedizi4=array.new_line()
a4=(xo4*yo4-xyo4)/(xo4*xo4-xxo4)
b4=yo4-a4*xo4
for i=0 to len-1+extrapolation
    array.set(dizi4,i,a4*i+b4)

// line=line.new((last_bar_index-ta.barssince(cg)-len),
//  array.get(dizi3,0), 
//  last_bar_index-ta.barssince(cg),
//  array.get(dizi3,len-1), color=color.rgb(0,255,0), width=2)
// line2=line.new((last_bar_index-ta.barssince(cr)-len),
//  array.get(dizi4,0), 
//  last_bar_index-ta.barssince(cr),
//  array.get(dizi4,len-1), color=color.rgb(255, 0, 0, 0), width=2)
// line.delete(line[1])
// line.delete(line2[1])

alert=((array.get(dizi,0)<array.get(dizi,1)) and (array.get(dizi2,0)>array.get(dizi2,1)) and ta.highest(ttk[1],len/2)<1)
 or ((array.get(dizi,0)>array.get(dizi,1)) and (array.get(dizi2,0)<array.get(dizi2,1)) and ta.lowest(ttk[1],len/2)>-1)
alertcondition(alert)
hline(50)
rs=hline(30)
rss=hline(70)
fill(rs, rss, color=color.rgb(126, 87, 194, 90), title="RSI Background Fill")

longCondition = cg and ta.highest(ttk[1],len/2)<1 
if (longCondition)
    strategy.entry("Long", strategy.long)
    strategy.exit("exit long", "Long", limit = close*(100+tpb)/100 , stop =close*(100-sb)/100 , trail_price = close , trail_offset = close*tsb)

shortCondition = cr and ta.lowest(ttk[1],len/2)>-1 
if (shortCondition)
    strategy.entry("Short", strategy.short)
    strategy.exit("exit short", "Short", limit = close*(100-tps)/100, stop = close*(100+ss)/100, trail_price = close , trail_offset = close*tss)

Más.