Tendencia de la matriz de divergencia siguiendo la estrategia

El autor:¿ Qué pasa?, Fecha: 2023-12-12 17:05:27
Las etiquetas:

Resumen general

La estrategia de seguimiento de tendencia de la matriz de divergencia es una estrategia de negociación cuantitativa que combina el análisis de tendencia, divergencia y promedio móvil. Esta estrategia utiliza indicadores duales de RSI para juzgar la dirección de la tendencia del mercado y promedios móviles de matriz para generar señales de entrada.

Estrategia lógica

La estrategia de seguimiento de la tendencia de la matriz de divergencia consta de las siguientes partes principales:

Indicador de rentabilidad doble para la evaluación de tendencias

Cuando el RSI rápido muestra niveles de sobrecompra o sobreventa, revise el RSI lento para determinar la dirección de la tendencia.
Promedio móvil de matriz para señales de negociación

Configure un grupo de medias móviles de matriz basado en el precio de entrada. Cuando el precio toca una línea de media móvil, ajuste la posición en consecuencia. Esto permite capturar más ganancias en las tendencias.
Negociación bidireccional

El trading por defecto es bidireccional.

La lógica de negociación específica es:

Utilice el RSI rápido para detectar los niveles de sobrecompra / sobreventa temporales en el mercado.
Utilice el RSI lento para determinar la dirección de tendencia a medio y largo plazo del mercado.
Cuando el RSI rápido muestra extremos y el RSI lento señala una reversión de tendencia, tome posiciones basadas en la tendencia larga/corta por RSI lento.
Después de ingresar posiciones, configure un grupo de medias móviles de matriz. Estas líneas de matriz se basan en el precio de entrada, con el tamaño del intervalo definido en el parámetro Matrix Interval %.
Cuando el precio toque una línea de la matriz, ajuste el tamaño de la posición en consecuencia.
Cuando el precio ve grandes ajustes, las posiciones se restablecerán a los niveles iniciales.

Lo anterior describe la lógica comercial principal de esta estrategia. El mecanismo de matriz permite obtener más ganancias de tendencia.

Ventajas

La estrategia de seguimiento de la tendencia de la matriz de divergencia tiene las siguientes ventajas:

Las señales de RSI dobles son más confiables, el RSI rápido evita fallas y el RSI lento asegura que la tendencia principal sea correcta.
El ajuste del tamaño de la posición basado en la divergencia de precios permite capturar beneficios sostenidos.
Apoya el comercio bidireccional. Por defecto es el comercio bidireccional, pero también puede ir largo sólo. Esto se adapta a más entornos de mercado.
El mecanismo de restablecimiento de posición controla los riesgos.
Configuración de parámetros flexible: los usuarios pueden seleccionar las combinaciones óptimas de parámetros basadas en datos históricos, instrumentos de negociación, etc.
Una clara separación de responsabilidades hace que el código sea fácil de entender, optimizar y extender.

En resumen, la mayor ventaja de esta estrategia es mejorar la calidad de la señal a través de múltiples mecanismos mientras se persigue mayores rendimientos bajo riesgos controlados.

Los riesgos

La estrategia de seguimiento de la tendencia de la matriz de divergencia también presenta algunos riesgos, principalmente en las siguientes áreas:

El riesgo de fallo de las señales RSI duales. Cuando el mercado está limitado al rango, el RSI a menudo da señales falsas. Se necesita intervención manual para ajustar los parámetros o suspender la negociación.
Si los parámetros de la matriz no se establecen correctamente, los ajustes de posición pueden ser demasiado agresivos, lo que aumenta las pérdidas.
El riesgo de posiciones sobreapalancadas. Los ajustes excesivos de tamaño de posición también aumentarán las pérdidas. El parámetro de tamaño máximo de posición debe fijarse con prudencia.
Si no se cierran posiciones rápidamente cuando la tendencia se invierte, pueden producirse grandes pérdidas. Esto requiere el seguimiento de los indicadores de tendencia a más largo plazo.
El riesgo de espacio de optimización limitado. Esta estrategia ya es bastante madura. El potencial de optimización continua es limitado. Se pueden necesitar actualizaciones importantes si los regímenes del mercado cambian drásticamente.

La evaluación y optimización de la estrategia es clave para mitigar estos riesgos: el ajuste de los parámetros, el seguimiento de los indicadores a más largo plazo, etc., pueden aliviar los riesgos hasta cierto punto.

Oportunidades de mejora

Hay margen para mejorar aún más la Tendencia de la Matriz de Divergencia:

Optimice los parámetros RSI duales, pruebe más combinaciones de parámetros y seleccione los períodos de RSI con la mayor precisión.
Líneas de matriz personalizables. Permiten a los usuarios parametrizar la configuración de la matriz en función de diferentes instrumentos para adaptarse mejor a sus características.
Por ejemplo, configure líneas de salida para detener las posiciones si el precio rompe esas líneas.
Añadir más reglas científicas para el tamaño de las posiciones y gestionar los ajustes de tamaño de las posiciones de manera más gradual para evitar el apalancamiento excesivo.
Incorporar otros indicadores. Introducir indicadores adicionales como MACD, KD, etc. para mejorar la precisión de la señal.
Optimizar la estructura del código y mejorar aún más la extensibilidad, el mantenimiento y la eficiencia de ejecución del código.

Conclusión

La estrategia de seguimiento de tendencias de la matriz de divergencia es una estrategia de negociación cuantitativa sofisticada que combina múltiples mecanismos - utilizando RSI dual para la dirección de la tendencia y líneas de matriz para beneficiarse de las tendencias. En comparación con las estrategias de un solo indicador, proporciona señales comerciales más estables y eficientes. Con ajustes de parámetros y extensiones de optimización, esta estrategia puede adaptarse a más condiciones y regímenes de mercado, lo que la hace altamente versátil. En general, esta estrategia alcanza un buen equilibrio entre riesgo y retorno, y merece una aplicación activa y una mejora continua por parte de los inversores.

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

//@version=3
strategy("The Matrix 7.0 Strategy", overlay=false)

//Matrix Settings 
entry_size = input(title="Entry Size", defval = 1)
max_size = input(title="Max Size", defval = 10000)
matrix = input(title="Matrix Interval %", defval = 2)
matrix_price_overwrite = input(title="Matrix Overwrite $", defval = 0.0)
adjustment = input(title="Adjustment Size", defval = 1000)
trade_short = input(title="Trade Short", type=bool, defval = true)

//RSI Settings
periods = input(title="RSI Periods", defval = 14)
overbought_short = input(title="RSI Overbought", defval = 65)
oversold_short = input(title="RSI Oversold", defval = 30)

//RSI Trend Settings
resolution_long = input(title="Resolution Trend", defval = "D")
periods_long = input(title="RSI Trend Periods", defval = 14)
overbought_long = input(title="RSI Trend Overbought", defval = 64)
oversold_long = input(title="RSI Trend Oversold", defval = 30)

//Round Off to 2 decimals
round2(x) =>
    a = x * 10 * 10
    a := floor(a + 0.5)
    a := a / 10 / 10
    a

//RSI Function
RSI = rsi(close, periods)

//RSI Market Function
rsi_oversold = RSI < oversold_short
rsi_overbought = RSI > overbought_short

market_rsi = 0.0
market_rsi := if (rsi_oversold)
    RSI - oversold_short
else
    if (rsi_overbought)
        RSI - overbought_short
    else
        0

//RSI Trend Function
rsi_long = request.security(syminfo.tickerid,resolution_long,rsi(close,periods_long))
trend_rsi_long = rsi_long < oversold_long
trend_rsi_short = rsi_long > overbought_long
trend_rsi = 0
trend_rsi := if (trend_rsi_short)
    -1
else
    if (trend_rsi_long)
        1
    else
        trend_rsi[1] 

// // Shorter time resolution to make "close" crosses give faster positives.
// short_resolution = security(tickerid, "1", close)
// quick = round2(short_resolution) //ROUND OFF TO 2 DECIMAL PLACES.

//Declare Other Variables
entry_price = 0.0
entry_price := nz(entry_price[1])

position_size = 0.0
position_size := nz(position_size[1])

last_traded_price = 0.0
last_traded_price := nz(last_traded_price[1])


matrix_price = 0.0
if matrix_price_overwrite > 0.0
    matrix_price := matrix_price_overwrite
else
    matrix_price := round2((matrix/100) * entry_price)

level = 0
level := nz(level[1])

level_price = entry_price
if not na(level_price[1])
    level_price := level_price[1]

// Calculate Level
if close > level_price 
    level_change = floor((high - level_price)/matrix_price)
    level := level + level_change
else
    if close < level_price 
        level_change = ceil((low - level_price)/matrix_price)
        level := level + level_change
        
// Calculate Level Price   
level_price := (level * matrix_price) + entry_price

// Calculate Matrix Position
matrix_position = 0.0

if position_size > 0
    matrix_position :=  ((-1 * level) * adjustment) + entry_size
else
    if position_size < 0
        matrix_position :=  ((-1 * level) * adjustment) - entry_size
    
//Trend Entry or Reversal Conditions
trend_reversal_up = trend_rsi == 1 and (trend_rsi[1] == -1 or trend_rsi == 0) and position_size <= 0
trend_reversal_down = trend_rsi == -1 and (trend_rsi[1] == 1 or trend_rsi == 0) and position_size >= 0 and trade_short == true
flatten_position = trend_rsi == -1 and (trend_rsi[1] == 1 or trend_rsi == 0) and position_size >= 0 and trade_short == false

//Reset Conditions
reset_long = (position_size > 0) and (close - entry_price > matrix_price) and (market_rsi < 0) and (position_size != entry_size) 
reset_short = (position_size < 0) and (entry_price - close > matrix_price) and (market_rsi > 0) and (position_size != (-1 * entry_size)) 

//Adjustment Conditions
increase_long = (position_size > 0) and (matrix_position > position_size) and (market_rsi < 0) and (matrix_position <= max_size) 
decrease_long = (position_size > 0) and (matrix_position < position_size) and (market_rsi > 0) 
increase_short = (position_size < 0) and (matrix_position < position_size) and (market_rsi > 0) and (matrix_position >= (-1 * max_size)) 
decrease_short = (position_size < 0) and (matrix_position > position_size) and (market_rsi < 0)  

//Transactions
//Trend Reversals
if trend_reversal_up
    strategy.entry("OL", strategy.long, qty=entry_size)
    position_size := entry_size
    matrix_position := entry_size
    level := 0
else
    if trend_reversal_down 
        strategy.entry("OS", strategy.short, qty=entry_size)
        position_size := -1 * entry_size
        matrix_position := -1 * entry_size   
        level := 0
        
    //Reset Positions    
    else
        if reset_long
            order = entry_size - position_size[1]
            strategy.order("RL", strategy.long, qty=order)
            position_size := entry_size
            matrix_position := entry_size
            level := 0
        else
            if reset_short
                order = position_size[1] - (-1* entry_size)
                strategy.order("RS", strategy.short, qty=order)
                position_size := -1 * entry_size
                matrix_position := -1 * entry_size
                level := 0

    //Position Adjustments
            else    
                if increase_long
                    order = matrix_position - position_size[1]
                    strategy.order("IL", strategy.long, qty=order)
                    position_size := position_size[1] + order
                else
                    if decrease_long
                        order = position_size[1] - matrix_position
                        strategy.order("DL", strategy.short, qty=order)
                        position_size := position_size[1] - order
                    else
                        if increase_short
                            order = position_size[1] - matrix_position
                            strategy.order("IS", strategy.short, qty=order)
                            position_size := position_size[1] - order
                        else
                            if decrease_short
                                order = matrix_position - position_size[1]
                                strategy.order("DS", strategy.long, qty=order)
                                position_size := position_size[1] + order
                            else 
                                if flatten_position
                                    strategy.close_all()
                                    position_size := 0.0
                                    matrix_position := 0.0
                                    level := 0

//Grouped Actions
if trend_reversal_up or trend_reversal_down or reset_short or reset_long
    entry_price := round2(close)
    last_traded_price := round2(close)

if increase_long or decrease_long or increase_short or decrease_short
    last_traded_price := round2(close)

// //RSI Trend & Adjustment Moments. (strategy)
p1 = plot(market_rsi, color = trend_rsi > 0 ? green : red, linewidth = 4, title='Market', transp =0)
p2 = plot(trend_rsi, color = trend_rsi > 0 ? green : red, linewidth = 4, title='Trend', transp = 0)
fill(p1,p2, color=trend_rsi > 0 ? green : red, transp=0)
p3 = plot((rsi_long - 50) *2, color = white, title="Trend Index")
fill(p2,p3, color=white)
hline((overbought_long -50) * 2)
hline((oversold_long -50) * 2)

//Position Plots (strategy)
plot(matrix_position / 100, title='Matrix', color=white, linewidth = 4)
plot(position_size / 100, title='Position', color=blue, linewidth = 4)
plot(strategy.position_size / 100, title='Strategy', color=orange, linewidth = 4)

// //Price Plots (study)
// plot(level_price, title="Matrix Level Price", linewidth=4)
// plot(last_traded_price, title="Last Traded Price", linewidth=2, color=orange)
// plot(entry_price + (4 * matrix_price), title='Adjustment 4', color=white, linewidth = 1)
// plot(entry_price + (3 * matrix_price), title='Adjustment 3', color=white, linewidth = 1)
// plot(entry_price + (2 * matrix_price), title='Adjustment 2', color=white, linewidth = 1)
// plot(entry_price + matrix_price, title='Adjustment 1', color=white, linewidth = 1)
// plot(entry_price, title='Entry Price', color=white, linewidth = 3)
// plot(entry_price - matrix_price, title='Adjustment -1', color=white, linewidth = 1)
// plot(entry_price - (2 * matrix_price), title='Adjustment -2', color=white, linewidth = 1)
// plot(entry_price - (3 * matrix_price), title='Adjustment -3', color=white, linewidth = 1)
// plot(entry_price - (4 * matrix_price), title='Adjustment -4', color=white, linewidth = 1)


// //Alerts (study only)
// alertcondition(trend_reversal_up, title='Trend Reversal Up', message='Market Oversold, Lets Buy')
// alertcondition(trend_reversal_down, title='Trend Reversal Down', message='Market Overbought, Lets Sell')
// alertcondition(reset_long, title='Reset Long', message='Higher Bottom, Lets Buy')
// alertcondition(reset_short, title='Reset Short', message='Lower Top, Lets Sell')
// alertcondition(increase_long, title='Increase Long', message='Price Dropped, Lets Buy')
// alertcondition(decrease_long, title='Decrease Long', message='Price Spiked, Lets Sell')
// alertcondition(increase_short, title='Increase Short', message='Price Spiked, Lets Sell')
// alertcondition(decrease_short, title='Decrease Short', message='Price Dropped, Lets Buy')

// //Grouped Conditions
// condition_buy = trend_reversal_up or increase_long or decrease_short or reset_long
// condition_sell = trend_reversal_down or decrease_long or increase_short or reset_short
// adjustment_matrix = trend_reversal_up or increase_long or decrease_short or trend_reversal_down or decrease_long or increase_short or reset_long or reset_short

// //Grouped Alerts
// alertcondition(condition_buy, title='Condition Buy', message='You Need to Buy')
// alertcondition(condition_sell, title='Condition Sell', message='You Need to Sell!')
// alertcondition(adjustment_matrix, title='Adjustment Matrix', message='You Need to Adjust')

Más.