O recurso está a ser carregado... Carregamento...

RSI Divergência Estratégia de negociação

Autora:ChaoZhang, Data: 2023-10-25 16:47:14
Tags:

Resumo

A estratégia de negociação RSI Divergência gera sinais de compra e venda identificando divergências entre o indicador RSI e o movimento dos preços.

Princípio

Esta estratégia usa principalmente divergências no indicador RSI para identificar oportunidades de negociação. Especificamente, a estratégia primeiro calcula os valores do RSI durante um determinado período, em seguida, traça as linhas de tendência tanto para o indicador RSI quanto para o preço. Quando a linha RSI diverge da linha de preço, ou seja, o RSI sobe enquanto o preço cai, ou o RSI cai enquanto o preço sobe, a estratégia toma isso como um sinal de reversão iminente da tendência e gera sinais de negociação.

Se a estratégia detecta o fundo da linha RSI enquanto a linha de preço supera, um sinal de compra é gerado. Se a linha RSI supera enquanto a linha de preço supera, um sinal de venda é gerado. Uma vez que um sinal de negociação ocorre, a estratégia pode negociar de acordo com o tamanho do valor do RSI.

Além disso, a estratégia possui características de stop loss, take profit e trailing stop loss.

Vantagens

A estratégia de negociação da divergência RSI tem as seguintes vantagens:

A captura das divergências do RSI pode detectar precocemente inversões de tendência.
O RSI é amplamente utilizado e disponível na maioria das plataformas de negociação.
Os parâmetros do RSI são flexíveis e podem ser ajustados para diferentes condições de mercado.
Os controles de stop loss, take profit e trailing stop loss controlam o risco de forma eficaz.
A estratégia tem uma frequência de sinal moderada, evitando excesso de negociação.
A lógica é simples e fácil de programar para automação.

Riscos

A estratégia apresenta também alguns riscos:

As divergências do RSI não são completamente fiáveis e podem gerar sinais falsos.
As divergências podem falhar em mercados de forte tendência, o que deve ser evitado.
Parâmetros de RSI inadequados podem afetar o desempenho.
A fixação do stop loss demasiado apertada reduz os lucros; a fixação demasiado frouxa não limita o risco.
O trailing stop pode ser interrompido prematuramente durante os mercados voláteis.

Os riscos podem ser mitigados através de:

Adicionando outros indicadores como MACD, Bollinger Bands para filtrar sinais e reduzir falsos sinais.
Usar a estratégia apenas durante os mercados laterais de intervalo, evitando tendências fortes.
Otimizar os parâmetros do RSI, selecionar os períodos de retrospecção ideais, testar parâmetros para diferentes mercados.
Definir níveis razoáveis de stop loss e de lucro baseados em backtesting histórico.
Ajuste da distância de parada traseira com base na volatilidade do mercado e no apetite pelo risco.

Optimização

A estratégia pode ser melhorada nos seguintes aspectos:

Incorporar outros indicadores para filtrar os sinais e melhorar a fiabilidade.
Utilize o aprendizado de máquina para otimizar automaticamente os parâmetros do RSI.
Projetar algoritmos de stop loss dinâmicos de acordo com os regimes de mercado.
Construir um modelo dinâmico de dimensionamento das posições baseado na volatilidade para ajustar os tamanhos das posições.
Introduzir a volatilidade no trailing stop para definir a distância do trail com base nas oscilações de preços.
Implementar estratégias para outros mercados como forex e criptomoedas.
Desenvolver um sistema quantitativo de negociação para automação.

Conclusão

A estratégia de negociação de divergência do RSI gera sinais identificando divergências entre o RSI e o preço. A lógica é simples e fácil de automatizar. O stop loss, take profit e trailing stop efetivamente controlam os riscos. No entanto, a estratégia tem limitações na precisão e tendência dos mercados. Melhorias podem ser feitas através da otimização de parâmetros, adição de filtros e paradas dinâmicas.

/*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)

Mais.