Estratégia de reversão de tendência RSI

RSI ATR
Data de criação: 2024-04-28 13:33:19 última modificação: 2024-04-28 13:33:19
cópia: 1 Cliques: 546
1
focar em
1617
Seguidores

Estratégia de reversão de tendência RSI

Visão geral

A estratégia de reversão de tendência do RSI é uma estratégia de negociação quantitativa baseada em índices relativamente fracos (RSI) e amplitude real média (ATR). A estratégia se adapta à rápida oscilação do mercado, capturando oportunidades de reversão de tendência através do ajuste dinâmico do stop loss (TP / SL). A estratégia tem o RSI como centro, combina a oscilação do ATR e constrói os dois bandos de dinâmica de adaptação seguintes como base para abrir posições.

Princípio da estratégia

O núcleo da estratégia de reversão de tendência do RSI é a construção de uma faixa de stop loss dinâmica. Primeiro, use as funções customizadas de highest_custom e lowest_custom para encontrar o preço mais alto e o preço mais baixo desde o último cruzamento, formando uma base de faixa. Em seguida, calcule o RSI e o ATR de comprimento, respectivamente, e faça o seguinte cálculo:

  1. Baixo = preço máximo ×[1 - (ATR/preço + 1/(RSI subtraído × multiplicador))
  2. Subida = preço mínimo ×[1 + (ATR/preço + 1/(RSI em andamento × multiplicador))

O multiplicador aumenta o fator de amplificação para os bandos personalizados pelo usuário. Se o preço sobe para cima, ele aumenta. Se o preço desce para baixo, ele diminui.

Vantagens estratégicas

  1. A banda de suspensão de prejuízos é auto-adaptável e pode se ajustar automaticamente à flutuação dos preços, respondendo às mudanças de mercado em tempo hábil.
  2. Os parâmetros são ajustáveis, e a sensibilidade da estratégia pode ser controlada com flexibilidade, ajustando parâmetros como o comprimento, o multiplicador, etc.
  3. A lógica é clara, a estrutura do código é razoável, fácil de entender e de reutilizar.
  4. É muito versátil, pode ser usado independentemente da sua estratégia, ou pode ser adicionado para outras estratégias.
  5. Eficiência computacional, evitando o grande número de cálculos repetidos causados pelo uso do tipo de série, por meio de funções personalizadas, como o highestest_custom.

Risco estratégico

  1. A escolha inadequada de parâmetros pode trazer riscos adicionais, como um comprimento muito pequeno pode levar a negociações frequentes, e um multiplicador muito grande pode levar a um stop loss muito relaxado.
  2. Em determinadas circunstâncias do mercado, o efeito pode ser fraco, como a correção frequente e a falsa ruptura em mercados turbulentos, que podem produzir mais transações perdedoras.
  3. A estratégia em si não tem função de discernimento de tendências e precisa ser usada em conjunto com outros sinais.

Direção de otimização da estratégia

  1. Pode-se considerar a inclusão de indicadores de tendência, como a média móvel, para negociar apenas em pontos de reversão na direção da grande tendência.
  2. Os parâmetros podem ser otimizados para encontrar a melhor combinação de parâmetros como length, multiplier e outros.
  3. Pode ser combinado com outros indicadores técnicos ou de sentimento de mercado para melhorar a precisão de posições abertas.
  4. A entrada de risco de cada transação pode ser controlada rigorosamente com a adição de gerenciamento de posição.

Resumir

A estratégia de reversão de tendência do RSI usa o RSI e o ATR para construir bandas de adaptação que permitem ajustar dinamicamente os pontos de parada e perda em tempo hábil para as mudanças no mercado. A lógica da estratégia é clara e tem uma ampla gama de aplicações, podendo ser uma ferramenta poderosa para os comerciantes de quantificação.

Código-fonte da estratégia
/*backtest
start: 2023-04-22 00:00:00
end: 2024-04-27 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=5
strategy("RSI Trend Reversal", overlay=true, max_bars_back = 4999, calc_on_every_tick = false)


//INPUTS 
rsi_length = input.int(title = "Lenght", defval = 8)
rsi_mult = input.float(title = "Multiplier", defval = 1.5, step = .05)
lookback = input.int(title = "Delay to prevent idealization", defval = 1)
sltp = input.float(title = "Minimum Difference", defval = 10)
src = input.source(title = "Source Input", defval = close)

//PARAMETERS INITILIZATION
hclose = request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, src)
//FUNCTION INITILIZATION
highest_custom(src, length) =>
    x = src
    for i = 0 to length
        if src[i] > x
            x := src[i]
    x
lowest_custom(src, length) => 
    x = src
    for i = 0 to length
        if src[i] < x
            x := src[i]
    x
rsilev(src, length, mult, sltp) =>
    sl = (100 - sltp) / 100
    tp = (100 + sltp) / 100
    var bool crossup = na
    var bool crossdown = na
    var float dir = na
    dir_change = ta.change(dir)
    var float BearGuy = 0
    BullGuy = ta.barssince(crossup or crossdown)
    if na(BullGuy)
        BearGuy += 1
    else
        BearGuy := BullGuy
    var float upper = na
    var float lower = na
    rsilower = ta.rsi(src, length)
    rsiupper = math.abs(ta.rsi(src, length) - 100)
    atr = ta.atr(length) / src
    lower := highest_custom(math.max(highest_custom(highest_custom(src, BearGuy) * (1 - (atr + ((1 / (rsilower) * mult)))), BearGuy), src * sl), BearGuy)
    upper := lowest_custom(math.min(lowest_custom(lowest_custom(src, BearGuy) * (1 + (atr + ((1 / (rsiupper) * mult)))), BearGuy), src * tp), BearGuy)
    var float thresh = na
    if na(thresh)
        thresh := lower
    if na(dir)
        dir := 1
    if crossdown
        dir := -1
    if crossup
        dir := 1
    if dir == 1
        thresh := lower
    if dir == -1
        thresh := upper
    crossup := ta.crossover(src, thresh)
    crossdown := ta.crossunder(src, thresh)
    thresh

rsiclose = rsilev(hclose, rsi_length, rsi_mult, sltp)

//PLOTTING
var color col = color.lime
if hclose > rsiclose
    col := color.lime
if hclose < rsiclose
    col := color.red
plot(rsiclose, linewidth = 2, color = col)

//STRATEGY
buy = ta.crossover(hclose, rsiclose)
sell = ta.crossunder(hclose, rsiclose)

if buy[lookback]
    strategy.entry("long", strategy.long)
if sell[lookback]
    strategy.entry("Short", strategy.short)