El RSI combinado con las bandas de Bollinger y la estrategia cuantitativa de soporte/resistencia dinámica

El autor:¿ Qué pasa?, Fecha: 2024-01-24 15:19:22
Las etiquetas:

Resumen general

Esta estrategia utiliza el indicador RSI para juzgar los niveles de sobrecompra / sobreventa en el mercado, combinado con bandas de Bollinger para determinar el rango de fluctuación de precios. Además, se generan soporte / resistencia dinámicos basados en precios altos / bajos para activar órdenes de compra / venta solo cuando el precio está cerca de los niveles de soporte / resistencia. Los usuarios pueden establecer una condición de filtro de tendencia, como una media móvil simple, para garantizar que la tendencia del precio se alinee con las direcciones comerciales.

Estrategia lógica

La estrategia se compone de 3 componentes clave RSI, Bandas de Bollinger y S/R dinámico.

El componente RSI juzga los niveles de sobrecompra / sobreventa. Si el RSI cae por debajo de 30 sugiere una condición de sobreventa y desencadena una señal de compra. Si el RSI sube por encima de 70, sugiere una condición de sobrecompra y desencadena una señal de venta.

Las bandas de Bollinger son bandas superiores/inferiores calculadas a partir de la media móvil de precios y la desviación estándar, para determinar si el precio ha salido del rango de fluctuación normal.

El componente S/R utiliza un método de cálculo dinámico para generar niveles clave de S/R basados en precios históricos altos/bajos (o precios cerrados/abiertos) dentro de ciertos períodos de retroceso y rangos porcentuales, así como puntos históricos de reversión de precios.

En resumen, esta estrategia inicia operaciones de compra/venta solo cuando se cumplen los indicadores de sobrecompra/sobreventa del índice de rendimiento, la ruptura de precios de las bandas de Bollinger y la proximidad a los niveles dinámicos de S/R.

Ventajas

Indicador fundamental RSI combinado con el indicador de análisis técnico Bollinger Bands.
El cálculo dinámico de S/R se adhiere más a la S/R real que rige el movimiento de los precios.
La adición de un filtro de tendencia mejora aún más la precisión de la señal al filtrar el ruido cuando se combina con el RSI y las bandas de Bollinger.

Los riesgos

La configuración incorrecta de los parámetros del RSI puede causar errores de juicio. La longitud del RSI demasiado corta aumenta el ruido. La configuración incorrecta del umbral de sobrecompra / sobreventa también conduce a errores.
Los parámetros incorrectos de las bandas de Bollinger como la longitud, el multiplicador StdDev afectan la precisión del juicio.
Los usuarios deben optimizar los parámetros S/R para una mayor relevancia con el precio actual.
Esta estrategia tiene una lógica relativamente compleja con múltiples indicadores que pueden causar interferencias. Los usuarios deben probar parámetros para reducir el conflicto.

Direcciones de optimización

Prueba y optimiza los parámetros del RSI, incluida la longitud, los umbrales de sobrecompra/sobreventa.
Prueba y optimiza los parámetros de Bollinger Bands, incluida la longitud y el multiplicador StdDev.
Optimizar los parámetros dinámicos de S/R para alinear los niveles de S/R más cerca del precio, por ejemplo, utilizando períodos de retroalimentación más cortos o menos precios históricos altos/bajos.
Para mejorar la precisión, ensayar indicadores auxiliares adicionales en combinación con el RSI, como KDJ, MACD, etc.
Prueba y optimización de los parámetros del filtro de tendencia, en particular de la longitud del filtro, para prolongar el período de espera y reducir las órdenes inversas innecesarias.

Conclusión

Esta estrategia aprovecha los puntos fuertes de múltiples indicadores como RSI, Bollinger Bands y Dynamic S/R, con una amplia verificación cruzada para una precisión de señal robusta. La adición de un filtro de tendencia reduce aún más el ruido. Con el ajuste flexible de parámetros, los usuarios pueden optimizar esta estrategia para que se adapte mejor a sus necesidades.

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

Más.