RSI combinado com bandas de Bollinger e estratégia quantitativa de suporte/resistência dinâmica

Autora:ChaoZhang, Data: 2024-01-24 15:19:22
Tags:

Resumo

Esta estratégia usa o indicador RSI para julgar os níveis de sobrecompra/supervenda no mercado, combinado com as Bandas de Bollinger para determinar a faixa de flutuação de preços. Além disso, o suporte/resistência dinâmicos são gerados com base em preços altos/baixos para desencadear ordens de compra/venda apenas quando o preço está perto dos níveis de suporte/resistência. Os usuários podem definir uma condição de filtro de tendência, como média móvel simples, para garantir que a tendência de preços se alinhe com as direções comerciais. Esta estratégia integra vários indicadores técnicos para precisão robusta do sinal e captura oportunidades de mercado de forma eficaz.

Estratégia lógica

A estratégia consiste em três componentes principais RSI, Bandas de Bollinger e S/R dinâmico.

O componente RSI julga os níveis de sobrecompra / sobrevenda. RSI abaixo de 30 sugere condição de sobrevenda e desencadeia sinal de compra. RSI acima de 70 sugere condição de sobrecompra e desencadeia sinal de venda.

As bandas de Bollinger são bandas superior/inferior calculadas a partir da média móvel do preço e do desvio padrão, para determinar se o preço saiu da faixa de flutuação normal.

O componente S/R usa um método de cálculo dinâmico para gerar níveis chave de S/R com base em preços históricos altos/baixos (ou preços de fechamento/abertura) dentro de determinados períodos de retrospectiva e intervalos percentuais, bem como pontos históricos de reversão de preços.

Em resumo, esta estratégia inicia transacções de compra/venda somente quando o RSI é supercomprado/supervendido, o preço quebrando as Bandas de Bollinger, bem como a proximidade dos níveis dinâmicos de S/R são atingidos.

Vantagens

Indicador fundamental RSI combinado com o indicador de análise técnica Bollinger Bands.
O cálculo dinâmico do S/R adere mais ao S/R real que rege o movimento dos preços.
A adição de um filtro de tendência melhora ainda mais a precisão do sinal, filtrando o ruído quando combinado com o RSI e as Bandas de Bollinger.

Riscos

A configuração incorreta dos parâmetros do RSI pode causar um julgamento errado. A duração do RSI muito curta aumenta o ruído. A configuração incorreta do limiar de sobrecompra / sobrevenda também leva a erros.
Parâmetros incorretos de Bollinger Bands como comprimento, multiplicador StdDev afetam a precisão do julgamento.
Os usuários devem otimizar os parâmetros S/R para maior relevância para o preço atual.
Esta estratégia tem uma lógica relativamente complexa com vários indicadores potencialmente causando interferência. Os usuários devem testar parâmetros para reduzir conflitos.

Orientações de otimização

Teste e otimize os parâmetros do RSI, incluindo o comprimento e os limiares de sobrecompra/supervenda.
Teste e otimize os parâmetros das Bandas de Bollinger, incluindo comprimento e multiplicador StdDev.
Otimizar os parâmetros dinâmicos de S/R para alinhar os níveis de S/R mais próximo do preço, como por exemplo, utilizar períodos de revisão mais curtos ou menos preços históricos altos/baixos.
Teste indicadores auxiliares adicionais em combinação com o RSI, tais como KDJ, MACD, etc., para melhorar a precisão.
Testar e otimizar os parâmetros do filtro de tendência, em especial a comprimento do filtro, a fim de prolongar o período de retenção e reduzir as ordens invertidas desnecessárias.

Conclusão

Esta estratégia aproveita os pontos fortes de vários indicadores como RSI, Bollinger Bands e Dynamic S/R, com ampla verificação cruzada para precisão robusta do sinal. A adição de um filtro de tendência reduz ainda mais o ruído. Com ajuste flexível de parâmetros, os usuários podem otimizar esta estratégia para melhor atender às suas necessidades.

/*backtest
start: 2023-01-17 00:00:00
end: 2024-01-23 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=5
strategy("RSI + BB + S/R Strategy with Trend Filter", shorttitle="RSI + BB + S/R + Trend Filter", overlay=true)

// RSI Settings
rsi_length = input.int(14, title="RSI Length")
overbought = input.int(70, title="Overbought Level")
oversold = input.int(30, title="Oversold Level")

// Bollinger Bands Settings
bb_length = input.int(20, title="BB Length")
bb_deviation = input.float(2.0, title="BB Deviation")

// Dynamic Support/Resistance Settings
pivot_period = input.int(10, title="Pivot Period")
pivot_source = input.string("High/Low", title="Pivot Source", options=["High/Low", "Close/Open"])
max_pivots = input.int(20, title="Maximum Number of Pivot", minval=5, maxval=100)
channel_width = input.int(10, title="Maximum Channel Width %", minval=1)
max_sr_levels = input.int(5, title="Maximum Number of S/R Levels", minval=1, maxval=10)
min_strength = input.int(2, title="Minimum Strength", minval=1, maxval=10)

// Trend Filter Settings
use_trend_filter = input.bool(false, title="Use Trend Filter")
trend_filter_length = input.int(50, title="Trend Filter Length")

// Calculate RSI and Bollinger Bands
rsi = ta.rsi(close, rsi_length)
basis = ta.sma(close, bb_length)
deviation = ta.stdev(close, bb_length)
upper_band = basis + bb_deviation * deviation
lower_band = basis - bb_deviation * deviation

// Plot Bollinger Bands on the chart
plot(upper_band, color=color.blue, title="Upper Bollinger Band")
plot(lower_band, color=color.red, title="Lower Bollinger Band")

// Dynamic Support/Resistance Calculation
float src1 = pivot_source == "High/Low" ? high : math.max(close, open)
float src2 = pivot_source == "High/Low" ? low : math.min(close, open)
float ph = ta.pivothigh(src1, pivot_period, pivot_period)
float pl = ta.pivotlow(src2, pivot_period, pivot_period)


// Calculate maximum S/R channel zone width
prdhighest = ta.highest(300)
prdlowest = ta.lowest(300)
cwidth = (prdhighest - prdlowest) * channel_width / 100

var pivotvals = array.new_float(0)

if ph or pl
    array.unshift(pivotvals, ph ? ph : pl)
    if array.size(pivotvals) > max_pivots
        array.pop(pivotvals)

get_sr_vals(ind) =>
    float lo = array.get(pivotvals, ind)
    float hi = lo
    int numpp = 0
    for y = 0 to array.size(pivotvals) - 1 by 1
        float cpp = array.get(pivotvals, y)
        float wdth = cpp <= lo ? hi - cpp : cpp - lo
        if wdth <= cwidth
            if cpp <= hi
                lo := math.min(lo, cpp)
            else
                hi := math.max(hi, cpp)
            numpp += 1
    [hi, lo, numpp]

var sr_up_level = array.new_float(0)
var sr_dn_level = array.new_float(0)
sr_strength = array.new_float(0)

find_loc(strength) =>
    ret = array.size(sr_strength)
    for i = ret > 0 ? array.size(sr_strength) - 1 : na to 0 by 1
        if strength <= array.get(sr_strength, i)
            break
        ret := i
    ret

check_sr(hi, lo, strength) =>
    ret = true
    for i = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
        if array.get(sr_up_level, i) >= lo and array.get(sr_up_level, i) <= hi or array.get(sr_dn_level, i) >= lo and array.get(sr_dn_level, i) <= hi
            if strength >= array.get(sr_strength, i)
                array.remove(sr_strength, i)
                array.remove(sr_up_level, i)
                array.remove(sr_dn_level, i)
            else
                ret := false
            break
    ret

if ph or pl
    array.clear(sr_up_level)
    array.clear(sr_dn_level)
    array.clear(sr_strength)
    for x = 0 to array.size(pivotvals) - 1 by 1
        [hi, lo, strength] = get_sr_vals(x)
        if check_sr(hi, lo, strength)
            loc = find_loc(strength)
            if loc < max_sr_levels and strength >= min_strength
                array.insert(sr_strength, loc, strength)
                array.insert(sr_up_level, loc, hi)
                array.insert(sr_dn_level, loc, lo)
                if array.size(sr_strength) > max_sr_levels
                    array.pop(sr_strength)
                    array.pop(sr_up_level)
                    array.pop(sr_dn_level)

// Calculate the Trend Filter
trend_filter = use_trend_filter ? ta.sma(close, trend_filter_length) : close

// Buy Condition (RSI + Proximity to Support + Trend Filter)
buy_condition = ta.crossover(rsi, oversold) and close <= ta.highest(high, max_sr_levels) and close >= ta.lowest(low, max_sr_levels) and (not use_trend_filter or close > trend_filter)

// Sell Condition (RSI + Proximity to Resistance + Trend Filter)
sell_condition = ta.crossunder(rsi, overbought) and close >= ta.lowest(low, max_sr_levels) and close <= ta.highest(high, max_sr_levels) and (not use_trend_filter or close < trend_filter)

// Strategy Orders
strategy.entry("Buy", strategy.long, when = buy_condition)
strategy.entry("Sell", strategy.short, when = sell_condition)

Mais.