Estrategia de trading con regresión RSI multinivel y ajuste dinámico de la volatilidad
RSI、PIVOT
ChaoZhang
Descripción general
Esta estrategia es un sistema de comercio de retorno de la media a niveles múltiples basado en el indicador RSI y la volatilidad de los precios. Utiliza los extremos del RSI y las fluctuaciones de precios inusualmente grandes como señales de entrada, mientras que utiliza la hipoteca piramidal y los paros dinámicos para administrar el riesgo y optimizar los beneficios. La idea central de la estrategia es entrar en el mercado cuando hay extrema volatilidad y obtener ganancias cuando los precios regresan a niveles normales.
Principio de estrategia
Condiciones de entrada:
- Utiliza el RSI de 20 períodos (RSI20) como indicador principal
- Configurar varios umbrales del RSI ((35⁄65, 30⁄70, 25⁄75, 20⁄80)) y sus correspondientes umbrales de fluctuación
- Cuando el RSI alcanza un umbral y el tamaño de la entidad de la línea K actual supera el umbral de fluctuación correspondiente, se activa una señal de entrada
- Condiciones adicionales: el precio necesita romper el punto de soporte más alto/más bajo más reciente en un determinado porcentaje
Mecanismo de acrecentamiento:
- Se permite un máximo de 5 entradas ((entrada inicial + 4 adiciones)
- Cada alza de posición requiere un RSI más estricto y condiciones de volatilidad
Mecanismo de salida:
- Configurar 5 puntos de parada de diferentes niveles
- Punto de parada basado en el cálculo de la dinámica de soporte/resistencia en la entrada
- El objetivo de la suspensión se reduce gradualmente a medida que aumenta el número de posiciones
Control de riesgos:
- Utilizando un modelo de riesgo porcentual, el riesgo de cada transacción se fija en el 20% del valor total de la cuenta
- Establecimiento de la máxima cantidad de posiciones simultáneas permitidas en 5 para limitar la apertura de riesgo general
Ventajas estratégicas
Entradas de varios niveles: mediante la configuración de varios RSI y oscilaciones de los umbrales, la estrategia puede capturar diferentes niveles de extremos del mercado y mejorar las oportunidades de negociación.
Paradas dinámicas: Paradas calculadas en base a puntos de soporte/resistencia, que se pueden ajustar de acuerdo con la estructura del mercado, protegiendo los beneficios y evitando la salida prematura.
Aumento de posiciones piramidal: Aumentar las posiciones durante la continuación de la tendencia puede aumentar significativamente el potencial de ganancias.
Gestión de riesgos: porcentaje fijo de riesgo y límite máximo de tenencia, control efectivo de riesgo por transacción y riesgo general.
Flexibilidad: La gran cantidad de parámetros ajustables permite que la estrategia se adapte a diferentes entornos de mercado y variedades de transacciones.
Regresión de la media + seguimiento de tendencias: combina las ventajas de la regresión de la media y el seguimiento de tendencias para capturar reveses a corto plazo y no perderse las grandes tendencias.
Riesgo estratégico
Exceso de transacciones: puede desencadenar señales de transacciones con frecuencia en mercados con alta volatilidad, lo que lleva a tarifas excesivas.
Falsa ruptura: el mercado puede reactivarse rápidamente después de una breve oscilación extrema, lo que causa una señal errónea.
Pérdidas continuas: si el mercado continúa en un solo sentido, puede causar grandes pérdidas después de varias adiciones.
Sensibilidad de parámetros: el rendimiento de la estrategia puede ser altamente sensible a la configuración de parámetros, con riesgo de sobreajuste.
Efecto de deslizamiento: En períodos de gran volatilidad, puede haber un deslizamiento grave que afecte el rendimiento de la estrategia.
Dependencia del entorno del mercado: la estrategia puede funcionar mal en ciertos entornos del mercado, como mercados con poca volatilidad o con una fuerte tendencia.
Dirección de optimización de la estrategia
Ajuste de parámetros dinámicos: Introducción de un mecanismo de adaptación que ajusta dinámicamente el RSI y el umbral de la volatilidad en función de la situación del mercado.
Análisis de ciclo múltiple: en combinación con el juicio de las tendencias del mercado a más largo plazo, mejora la calidad de entrada.
Optimización de stop loss: Aumentar el stop loss de seguimiento o el stop loss dinámico basado en ATR para controlar aún más el riesgo.
Filtración de estado de mercado: añade condiciones de filtración como la intensidad de la tendencia, el ciclo de la volatilidad, etc., para evitar la negociación en un entorno de mercado inadecuado.
Optimización de la gestión de fondos: permite una gestión de posiciones más minuciosa, como el ajuste de la escala de las operaciones en función de los diferentes niveles de señales.
Integración de aprendizaje automático: optimización de la selección de parámetros y el proceso de generación de señales utilizando algoritmos de aprendizaje automático.
Análisis de Correlación: se añade el análisis de correlación con otros activos para mejorar la estabilidad y diversidad de la estrategia.
Resumir
La estrategia de comercio de regresión RSI de múltiples niveles es un sistema de comercio cuantitativo bien diseñado que combina hábilmente el análisis técnico, la gestión de riesgos dinámicos y la técnica de alza de la pirámide. La estrategia muestra un fuerte potencial de ganancias al capturar las fluctuaciones extremas del mercado y obtener ganancias cuando los precios regresan. Sin embargo, también enfrenta desafíos como el exceso de comercio y la dependencia del entorno del mercado.
/*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)