O recurso está a ser carregado... Carregamento...

Tendência da Matriz de Divergência Seguindo a Estratégia

Autora:ChaoZhang, Data: 12 de dezembro de 2023 17:05:27
Tags:

Resumo

A estratégia de seguimento de tendência da matriz de divergência é uma estratégia de negociação quantitativa que combina tendência, divergência e análise média móvel. Esta estratégia usa indicadores duplos de RSI para julgar a direção da tendência do mercado e médias móveis da matriz para gerar sinais de entrada. As médias móveis da matriz ajustam o tamanho da posição com base no grau de divergência de preços.

Estratégia lógica

A estratégia de acompanhamento da tendência da matriz de divergência consiste nas seguintes partes principais:

Indicador de risco duplo para a avaliação da tendência

Quando o RSI rápido mostra níveis de sobrecompra ou sobrevenda, verifique o RSI lento para a direção da tendência.
Média móvel de matriz para sinais de negociação

Configure um grupo de médias móveis de matriz com base no preço de entrada. Quando o preço tocar uma linha média móvel, ajuste a posição em conformidade. Isso permite capturar mais lucros nas tendências.
Negociação bidirecional

O padrão é a negociação bidirecional.

A lógica específica de negociação é a seguinte:

Use o RSI rápido para detectar níveis temporários de sobrecompra/supervenda no mercado.
Utilize o RSI lento para determinar a direção da tendência do mercado a médio e longo prazo.
Quando o RSI rápido mostra extremos e o RSI lento sinaliza reversão de tendência, tome posições com base na tendência longa/curta pelo RSI lento.
Após a entrada de posições, configure um grupo de médias móveis de matriz.
Quando o preço tocar uma linha de matriz, ajuste o tamanho da posição em conformidade.
Quando o preço vê grandes ajustes, as posições serão reiniciadas aos níveis iniciais.

O que precede descreve a principal lógica de negociação desta estratégia.

Vantagens

A estratégia de seguimento da tendência da matriz de divergência tem as seguintes vantagens:

Os sinais de RSI duplo são mais confiáveis. RSI rápido evita falhas e RSI lento garante que a tendência principal seja correta.
A correção do tamanho da posição com base na divergência de preços permite capturar lucros sustentados.
Suporta negociação bidirecional. Default é negociação bidirecional, mas também pode ir longo apenas. Isso se adapta a mais ambientes de mercado.
O mecanismo de reinicialização de posição controla os riscos.
Configurações flexíveis de parâmetros: os utilizadores podem selecionar combinações óptimas de parâmetros com base em dados históricos, instrumentos de negociação, etc.
Estrutura de código limpa. Separação clara das responsabilidades torna o código fácil de entender, otimizar e estender.

Em resumo, a maior vantagem desta estratégia é melhorar a qualidade do sinal através de múltiplos mecanismos, enquanto se procura retornos mais elevados sob riscos controlados.

Riscos

A estratégia de acompanhamento da tendência da matriz de divergência apresenta também alguns riscos, principalmente nos seguintes domínios:

Risco de falha de sinais RSI duplos. Quando o mercado está limitado a um intervalo, o RSI geralmente dá sinais falsos. É necessária intervenção manual para ajustar parâmetros ou suspender a negociação.
Se os parâmetros da matriz não forem definidos corretamente, os ajustes de posição podem ser muito agressivos, aumentando assim as perdas.
O risco de posições com alavancagem excessiva. Os ajustamentos excessivos do tamanho da posição também irão aumentar as perdas. O parâmetro máximo de tamanho da posição deve ser definido com prudência.
Risco de inversão de tendência: se não se fecharem posições prontamente quando a tendência se inverter, podem ser incorridas grandes perdas.
Risco de espaço de otimização limitado. Esta estratégia já é bastante madura. O potencial de otimização contínua é limitado. Grandes atualizações podem ser necessárias se os regimes de mercado mudarem drasticamente.

A avaliação e a otimização da estratégia são fundamentais para mitigar estes riscos - o ajustamento dos parâmetros, o acompanhamento dos indicadores de longo prazo, etc., podem atenuar os riscos até certo ponto.

Oportunidades de melhoria

Há espaço para um maior reforço da Tendência da Matriz de Divergência na seguinte estratégia:

Otimize os parâmetros RSI duplos, teste mais combinações de parâmetros e selecione períodos RSI com a maior precisão.
Linhas de matriz personalizáveis. Permitem aos utilizadores parametrizar as configurações da matriz com base em diferentes instrumentos para melhor se adequarem às suas características.
Adicione mecanismos de stop loss, por exemplo, configure linhas de saída para parar posições se o preço quebrar essas linhas.
Adicionar mais regras científicas de dimensionamento de posições. Gerenciar os ajustes de tamanho de posição de forma mais gradual para evitar a alavancagem excessiva.
Incorporar outros indicadores. Introduzir indicadores adicionais como MACD, KD etc. para melhorar a precisão do sinal.
Otimizar a estrutura do código e melhorar ainda mais a extensão, a manutenção e a eficiência de execução do código.

Conclusão

A Divergência Matrix Trend Following Strategy é uma estratégia de negociação quantitativa sofisticada que combina múltiplos mecanismos - usando RSI duplo para a direção da tendência e linhas de matriz para lucrar com as tendências. Em comparação com as estratégias de indicador único, ela fornece sinais de negociação mais estáveis e eficientes. Com ajustes de parâmetros e extensões de otimização, essa estratégia pode se adaptar a mais condições e regimes de mercado, tornando-a altamente versátil.

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

Mais.