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

Estrategia de reversión de la media del RSI de varios niveles con ajuste de volatilidad dinámica

El autor:¿ Qué pasa?, Fecha: 2024-06-21 14:16:31
Las etiquetas:RSI, PIVOT

Resumen general

Esta estrategia es un sistema de negociación de reversión media de varios niveles basado en el indicador RSI y la volatilidad de precios. Utiliza valores extremos de RSI y fluctuaciones de precios anormalmente grandes como señales de entrada, mientras emplea escalado de posición de estilo pirámide y niveles dinámicos de toma de ganancias para gestionar el riesgo y optimizar los rendimientos. La idea central de esta estrategia es entrar en el mercado durante la volatilidad extrema y obtener ganancias cuando los precios regresan a niveles normales.

Principios de estrategia

Condiciones de entrada:
- Se utiliza el RSI de 20 períodos (RSI20) como indicador principal.
- Se determinan los límites de los índices de volatilidad de las posiciones de riesgo y las posiciones de las posiciones de riesgo.
- Se activa la señal de entrada cuando el RSI alcanza un umbral y el tamaño del cuerpo de la vela actual excede el umbral de volatilidad correspondiente.
- Condición adicional: el precio debe superar el reciente nivel de soporte alto/bajo en un cierto porcentaje
Mecanismo de escalado de posición:
- Permite hasta 5 entradas (entrada inicial + 4 entradas adicionales)
- Cada entrada adicional requiere el cumplimiento de condiciones de RSI y volatilidad más estrictas
Mecanismo de salida:
- Establece 5 niveles diferentes de puntos de ganancia
- Los puntos de ganancia se calculan dinámicamente en función de los niveles de soporte/resistencia en la entrada
- Los objetivos de rentabilidad disminuyen gradualmente a medida que aumenta el número de posiciones abiertas
Control de riesgos:
- Utiliza un modelo de riesgo porcentual, en el que cada operación corre un riesgo fijo del 20% del valor de la cuenta
- Establece un máximo permitido de posiciones abiertas simultáneas a 5, limitando la exposición al riesgo global

Ventajas estratégicas

Entrada de varios niveles: al establecer múltiples umbrales de RSI y volatilidad, la estrategia puede capturar diferentes grados de extremos del mercado, aumentando las oportunidades comerciales.
Dinámico Take-Profit: Los puntos de Take-Profit calculados en función de los niveles de soporte/resistencia pueden adaptarse a la estructura del mercado, protegiendo las ganancias sin salir demasiado pronto.
Escalación de posiciones de tipo piramidal: el aumento de las posiciones a medida que continúan las tendencias puede aumentar significativamente el potencial de ganancia.
Gestión del riesgo: el riesgo porcentual fijo y los límites máximos de posición controlan eficazmente el riesgo para cada operación y en general.
Flexibilidad: los numerosos parámetros ajustables permiten que la estrategia se adapte a diferentes entornos de mercado e instrumentos de negociación.
Reversión media + Seguimiento de tendencias: Combina las ventajas de la reversión media y el seguimiento de tendencias, capturando reversiones a corto plazo sin perderse las tendencias principales.

Riesgos estratégicos

Exceso de negociación: puede desencadenar frecuentes señales de negociación en mercados altamente volátiles, lo que conduce a comisiones excesivas.
Falsos Breakouts: Los mercados pueden experimentar una breve volatilidad extrema seguida de rápidas reversiones, causando señales falsas.
Pérdidas consecutivas: los movimientos continuos unidireccionales del mercado pueden dar lugar a pérdidas significativas después de múltiples aumentos de la posición.
Sensibilidad de parámetros: el rendimiento de la estrategia puede ser muy sensible a la configuración de parámetros, con riesgo de sobreajuste.
Impacto del deslizamiento: puede sufrir un deslizamiento severo durante períodos de volatilidad intensa, lo que afecta al rendimiento de la estrategia.
Dependencia del entorno del mercado: La estrategia puede tener un rendimiento inferior en ciertos entornos de mercado, como mercados de baja volatilidad o de fuerte tendencia.

Direcciones para la optimización de la estrategia

Ajuste dinámico de parámetros: introducir mecanismos adaptativos para ajustar dinámicamente los umbrales de RSI y volatilidad en función de las condiciones del mercado.
Análisis de marcos de tiempo múltiples: Incorporar juicios de tendencias de mercado a más largo plazo para mejorar la calidad de la entrada.
Optimización del stop-loss: añadir stop-loss de seguimiento o stop-loss dinámicos basados en ATR para un mayor control del riesgo.
Filtración del estado del mercado: Incluir la fuerza de la tendencia, el ciclo de volatilidad y otras condiciones de filtración para evitar la negociación en entornos de mercado inadecuados.
Optimización de la gestión de capital: Implementar una gestión de posiciones más detallada, como ajustar el tamaño de las operaciones en función de los diferentes niveles de señal.
Integración de aprendizaje automático: utilizar algoritmos de aprendizaje automático para optimizar los procesos de selección de parámetros y generación de señales.
Análisis de correlación: Incorporar el análisis de correlación con otros activos para mejorar la estabilidad y la diversidad de la estrategia.

Conclusión

Esta estrategia de negociación de reversión media de RSI de varios niveles es un sistema de negociación cuantitativo cuidadosamente diseñado que combina inteligentemente el análisis técnico, la gestión dinámica del riesgo y las técnicas de escalado de posiciones de estilo pirámide. Al capturar la volatilidad extrema del mercado y obtener ganancias cuando los precios se invierten, la estrategia demuestra un fuerte potencial de ganancias. Sin embargo, también enfrenta desafíos como el sobrecomercio y la dependencia del entorno del mercado. La optimización futura debe centrarse en mejorar la adaptabilidad de la estrategia y las capacidades de control de riesgos para adaptarse a diferentes entornos del mercado. En general, este es un marco de estrategia con una base sólida que, a través de una mayor optimización y backtesting, tiene el potencial de desarrollarse en un sistema de negociación robusto.

/*backtest
start: 2024-05-01 00:00:00
end: 2024-05-31 23:59:59
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=5
strategy('Retorno_Pivots_5min_Novo_v3.3')

// Input variables
bars_left1 = input(1, title = "Entry - Pivot Left Bars")
bars_right1 = input(1, title = "Entry - Pivot Right Bars")
rsi20_longentry0 = input(35, title = "Entry 1 - RSI20 Long")
rsi20_shortentry0 = input(65, title = "Entry 1 - RSI20 Short")
bar_size_entry0 = input.float(1, title="Entry 1 - Bar Size")
rsi20_longentry1 = input(30, title = "Entry 2 - RSI20 Long")
rsi20_shortentry1 = input(70, title = "Entry 2 - RSI20 Short")
bar_size_entry1 = input.float(0.8, title="Entry 2 - Bar Size")
rsi20_longentry2 = input(25, title = "Entry 3 - RSI20 Long")
rsi20_shortentry2 = input(75, title = "Entry 3 - RSI20 Short")
bar_size_entry2 = input.float(0.7, title="Entry 3 - Bar Size")
rsi20_longentry3 = input(20, title = "Entry 4 - RSI20 Long")
rsi20_shortentry3 = input(80, title = "Entry 4 - RSI20 Short")
bar_size_entry3 = input.float(0.5, title="Entry 4 - Bar Size")
limit_perc1 = input.float(0.60, title="Profit Range 1")
limit_perc2 = input.float(0.40, title="Profit Range 2")
limit_perc3 = input.float(0.20, title="Profit Range 3")
limit_perc4 = input.float(0.00, title="Profit Range 4")
limit_perc5 = input.float(0.00, title="Profit Range 5")
minimum_pivot_distance = input.float(0, title="Minimum Pivot Distance %")
barsize_1h_input = input(288, title="Highest Bar Lookback")
rsi20 = ta.rsi(close, 20)
rsi200 = ta.rsi(close, 200)
Pivot_High_Last1 = ta.valuewhen(ta.pivothigh(high, bars_left1, bars_right1), ta.pivothigh(high, bars_left1, bars_right1), 0)
Pivot_Low_Last1 = ta.valuewhen(ta.pivotlow(low, bars_left1, bars_right1), ta.pivotlow(low, bars_left1, bars_right1), 0)

barsize = math.abs(close - open)
barsize_1h = ta.highest(barsize, barsize_1h_input)

Bar0Long = rsi20 < rsi20_longentry0 and barsize >= (barsize_1h * bar_size_entry0)
Bar1Long = rsi20 < rsi20_longentry1 and barsize >= (barsize_1h * bar_size_entry1)
Bar2Long = rsi20 < rsi20_longentry2 and barsize >= (barsize_1h * bar_size_entry2)
Bar3Long = rsi20 < rsi20_longentry3 and barsize >= (barsize_1h * bar_size_entry3)

// Long Entries
Long_Entry1 = strategy.opentrades == 0 and rsi20 < rsi20[1] and ((rsi20 < rsi20_longentry0 and barsize >= (barsize_1h * bar_size_entry0)) or (rsi20 < rsi20_longentry1 and barsize >= (barsize_1h * bar_size_entry1)) or (rsi20 < rsi20_longentry2 and barsize >= (barsize_1h * bar_size_entry2)) or (rsi20 < rsi20_longentry3 and barsize >= (barsize_1h * bar_size_entry3))) and close < (Pivot_Low_Last1 * (1 - (minimum_pivot_distance / 100)))
Long_Entry2 = strategy.opentrades == 1 and strategy.position_size > 0 and rsi20 < rsi20[1] and (Bar0Long or Bar1Long or Bar2Long or Bar3Long)
Long_Entry3 = strategy.opentrades == 2 and strategy.position_size > 0 and rsi20 < rsi20[1] and (Bar0Long or Bar1Long or Bar2Long or Bar3Long)
Long_Entry4 = strategy.opentrades == 3 and strategy.position_size > 0 and rsi20 < rsi20[1] and (Bar0Long or Bar1Long or Bar2Long or Bar3Long)
Long_Entry5 = strategy.opentrades == 4 and strategy.position_size > 0 and rsi20 < rsi20[1] and (Bar0Long or Bar1Long or Bar2Long or Bar3Long)
if Long_Entry1 or Long_Entry2 or Long_Entry3 or Long_Entry4 or Long_Entry5
    strategy.entry("Long", strategy.long, comment = "ENTER-LONG_BINANCE-FUTURES_BTCBUSD_Bot-BTC-1min_1M_970d2ee265390c27")
// Longs Exits
Long_Exit1 = strategy.opentrades == 1 and close > (strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc1))
Long_Exit2 = strategy.opentrades == 2 and close > (strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc2))
Long_Exit3 = strategy.opentrades == 3 and close > (strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc3))
Long_Exit4 = strategy.opentrades == 4 and close > (strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc4))
Long_Exit5 = strategy.opentrades == 5 and close > (strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc5))
if Long_Exit1 or Long_Exit2 or Long_Exit3 or Long_Exit4 or Long_Exit5
    strategy.close("Long", comment = "EXIT-LONG_BINANCE-FUTURES_BTCBUSD_Bot-BTC-1min_1M_970d2ee265390c27")

Bar0Short = rsi20 > rsi20_shortentry0 and barsize >= (barsize_1h * bar_size_entry0)
Bar1Short = rsi20 > rsi20_shortentry1 and barsize >= (barsize_1h * bar_size_entry1)
Bar2Short = rsi20 > rsi20_shortentry2 and barsize >= (barsize_1h * bar_size_entry2)
Bar3Short = rsi20 > rsi20_shortentry3 and barsize >= (barsize_1h * bar_size_entry3)

// Short Entries
Short_Entry1 = strategy.opentrades == 0 and rsi20 > rsi20[1] and ((rsi20 > rsi20_shortentry0 and barsize >= (barsize_1h * bar_size_entry0)) or (rsi20 > rsi20_shortentry1 and barsize >= (barsize_1h * bar_size_entry1)) or (rsi20 > rsi20_shortentry2 and barsize >= (barsize_1h * bar_size_entry2)) or (rsi20 > rsi20_shortentry2 and barsize >= (barsize_1h * bar_size_entry2))) and close > (Pivot_High_Last1 * (1 + (minimum_pivot_distance / 100)))
Short_Entry2 = strategy.opentrades == 1 and strategy.position_size < 0 and rsi20 > rsi20[1] and (Bar0Short or Bar1Short or Bar2Short or Bar3Short)
Short_Entry3 = strategy.opentrades == 2 and strategy.position_size < 0 and rsi20 > rsi20[1] and (Bar0Short or Bar1Short or Bar2Short or Bar3Short)
Short_Entry4 = strategy.opentrades == 3 and strategy.position_size < 0 and rsi20 > rsi20[1] and (Bar0Short or Bar1Short or Bar2Short or Bar3Short)
Short_Entry5 = strategy.opentrades == 4 and strategy.position_size < 0 and rsi20 > rsi20[1] and (Bar0Short or Bar1Short or Bar2Short or Bar3Short)
if Short_Entry1 or Short_Entry2 or Short_Entry3 or Short_Entry4 or Short_Entry5
    strategy.entry("Short", strategy.short, comment = "ENTER-SHORT_BINANCE-FUTURES_BTCBUSD_Bot-BTC-1min_1M_970d2ee265390c27")
// Short Exits
Short_Exit1 = strategy.opentrades == 1 and close < (strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc1))
Short_Exit2 = strategy.opentrades == 2 and close < (strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc2))
Short_Exit3 = strategy.opentrades == 3 and close < (strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc3))
Short_Exit4 = strategy.opentrades == 4 and close < (strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc4))
Short_Exit5 = strategy.opentrades == 5 and close < (strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc5))
if Short_Exit1 or Short_Exit2 or Short_Exit3 or Short_Exit4 or Short_Exit5
    strategy.close("Short", comment = "EXIT-SHORT_BINANCE-FUTURES_BTCBUSD_Bot-BTC-1min_1M_970d2ee265390c27")

// Plots
plot(rsi20, color=color.new(#fbff00, 0), linewidth=2)
plot(((strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc1))), color=color.new(#00ff2a, 0), linewidth=2)
plot(((strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc2))), color=color.new(#00ff2a, 50), linewidth=2)
plot(((strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc3))), color=color.new(#00ff2a, 80), linewidth=2)
plot(((strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc4))), color=color.new(#00ff2a, 100), linewidth=2)
plot((strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc1)), color=color.new(#ff0000, 0), linewidth=2)
plot((strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc2)), color=color.new(#ff0000, 50), linewidth=2)
plot((strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc3)), color=color.new(#ff0000, 80), linewidth=2)
plot((strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc4)), color=color.new(#ff0000, 100), linewidth=2)
plot(strategy.position_avg_price, color=color.new(#ffc400, 0), linewidth=2)
plot(strategy.opentrades * (strategy.position_size / math.abs(strategy.position_size)), color=color.new(#ff00bb, 0), linewidth=2)
plot(((barsize / barsize_1h) * 100), color=color.new(#0000ff, 0), linewidth=2)

Relacionados

Más.