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

Estratégia de paragem de perdas de atraso de vários prazos

Autora:ChaoZhang, Data: 2024-01-08 11:24:24
Tags:

Resumo

Esta estratégia é uma versão multi-temporal da minha estratégia anterior simples de stop loss. A estratégia anterior só usava stop loss básico para entrar em posições. Funcionou muito bem, então tentei melhorá-lo. Pensei o que aconteceria se eu usasse o mesmo ATR em diferentes prazos e combiná-los em um sinal.

Nesta estratégia, você só pode usar paradas ATR e escolher 3 outros prazos mais altos além do seu prazo atual. A perda de parada de trail de todos esses prazos será traçada no gráfico. Entre em posição longa se todos os 4 prazos concordarem com o sinal longo. Feche posições longas quando pelo menos 2 prazos discordam com o sinal longo. A lógica para posições curtas é a mesma.

Estratégia lógica

O núcleo desta estratégia reside em trailing stop loss e trend following. Trailing stop loss é usado para definir o nível de stop loss com base no valor ATR, o que pode efetivamente evitar que o stop loss seja atingido.

Especificamente, a estratégia primeiro calcula o valor ATR em diferentes prazos e define a distância de stop loss. Em seguida, gera sinais longos / curtos quando o preço atravessa o nível de stop loss. Se os sinais de vários prazos concordarem, a posição será tomada. Depois disso, continue rastreando o nível de stop loss por direção da tendência. Se os sinais de uma certa porcentagem de prazos se inverterem, feche a posição.

Ao combinar o julgamento da tendência em diferentes períodos, as faltas falsas podem ser filtradas de forma eficaz.

Vantagens

Usar vários prazos ajuda a filtrar o ruído e identificar a direção da tendência
O ATR trailing stop ajusta a distância de parada dinamicamente, diminuindo a probabilidade de ser parado
Combinando tendência seguindo e gestão stop loss, você pode seguir a tendência e parar fora no tempo
Poucos parâmetros, fáceis de compreender e otimizar

Análise de riscos

A parada ATR pode estar muito próxima ou muito longe se os parâmetros não forem definidos corretamente, propensa a ser atingida ou a uma distância de parada muito grande
A combinação de vários prazos pode não funcionar de forma eficaz ou julgar erroneamente se os parâmetros não forem definidos corretamente
Precisa configurar os parâmetros de stop loss e timeframe corretamente, caso contrário pode não alcançar os melhores resultados

Soluções:

Teste diferentes conjuntos de parâmetros e produtos para encontrar o ideal
Otimizar o rácio e o número de prazos para garantir um julgamento confiável da tendência
Ajustar o multiplicador ATR para equilibrar entre não ser atingido e a distância adequada

Orientações de otimização

A estratégia pode ser otimizada nos seguintes aspectos:

Adicionar/reduzir o número de prazos para encontrar as melhores combinações para o julgamento da tendência
Ensaiar diferentes multiplicadores ATR para determinar a distância de parada ideal
Adicionar mecanismo de reentrada para construir mais posições à medida que a tendência persistir
Incorporar outros filtros nos sinais de entrada, por exemplo, indicadores de volume, etc.
Ajuste de parâmetros para diferentes produtos

Conclusão

Esta estratégia combina o seguimento da tendência e o controle de risco através de paradas de tração ATR de vários prazos. Em comparação com a parada única, ela identifica a direção da tendência mais claramente; em comparação com o período de tempo único, ela filtra muito ruído. A configuração adequada nos parâmetros de parada e prazos é fundamental para alcançar melhores resultados. É adequado para investidores que podem tolerar certas reduções e fornece retornos constantes. Há também mais espaço de aprimoramento e expansão.

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

//@version=4
strategy(title="MTF Trailing SL Strategy [QuantNomad]", shorttitle = "MTF TrailingSL [QN]", overlay = true, default_qty_type = strategy.percent_of_equity, default_qty_value = 100)

////////////
// Inputs //

atr_length = input(14,    title = "ATR Length")
atr_mult   = input(2,     title = "ATR Mult",    type = input.float)

tf2 = input('120', title = "TF2", type = input.string)
tf3 = input('180', title = "TF3", type = input.string)
tf4 = input('240', title = "TF4", type = input.string)

// BACKTESTING RANGE
// From Date Inputs
fromDay   = input(defval = 1,    title = "From Day",   minval = 1, maxval = 31)
fromMonth = input(defval = 1,    title = "From Month", minval = 1, maxval = 12)
fromYear  = input(defval = 2016, title = "From Year",  minval = 1970)
 
// To Date Inputs
toDay   = input(defval = 1,    title = "To Day",   minval = 1, maxval = 31)
toMonth = input(defval = 1,    title = "To Month", minval = 1, maxval = 12)
toYear  = input(defval = 2100, title = "To Year",  minval = 1970)
 
// Calculate start/end date and time condition
startDate  = timestamp(fromYear, fromMonth, fromDay, 00, 00)
finishDate = timestamp(toYear,   toMonth,   toDay,   00, 00)

time_cond = time >= startDate and time <= finishDate

//////////////////
// CALCULATIONS //


tsl() => 
    // SL values
    sl_val = atr_mult * atr(atr_length)
     
    // Init Variables
    pos         = 0
    trailing_sl = 0.0
    
    // Signals
    long_signal  = nz(pos[1]) !=  1 and high > nz(trailing_sl[1])
    short_signal = nz(pos[1]) != -1 and low  < nz(trailing_sl[1]) 
    
    // Calculate SL
    trailing_sl := short_signal     ? high + sl_val : 
                   long_signal      ? low  - sl_val : 
                   nz(pos[1]) ==  1 ? max(low  - sl_val, nz(trailing_sl[1])) :  
                   nz(pos[1]) == -1 ? min(high + sl_val, nz(trailing_sl[1])) : 
                   nz(trailing_sl[1])
                   
    // Position var               
    pos := long_signal  ? 1 : short_signal ? -1 : nz(pos[1]) 
    trailing_sl
    
    
trailing_sl1 = tsl()
trailing_sl2 = security(syminfo.tickerid, tf2, tsl())
trailing_sl3 = security(syminfo.tickerid, tf3, tsl())
trailing_sl4 = security(syminfo.tickerid, tf4, tsl())

pos1 = 0
pos1 := low <= trailing_sl1 ? -1 : high >= trailing_sl1 ? 1 : nz(pos1[1])

pos2 = 0
pos2 := low <= trailing_sl2 ? -1 : high >= trailing_sl2 ? 1 : nz(pos2[1])

pos3 = 0
pos3 := low <= trailing_sl3 ? -1 : high >= trailing_sl3 ? 1 : nz(pos3[1])

pos4 = 0
pos4 := low <= trailing_sl4 ? -1 : high >= trailing_sl4 ? 1 : nz(pos4[1])

total_pos = pos1 + pos2 + pos3 + pos4

//////////////
// PLOTINGS //

plot(trailing_sl1, linewidth = 2 , color = pos1 == 1 ? color.green : color.red, title = "TSL TF1")
plot(trailing_sl2, linewidth = 2 , color = pos2 == 1 ? color.green : color.red, title = "TSL TF2", transp = 25)
plot(trailing_sl3, linewidth = 2 , color = pos3 == 1 ? color.green : color.red, title = "TSL TF3", transp = 50)
plot(trailing_sl4, linewidth = 2 , color = pos4 == 1 ? color.green : color.red, title = "TSL TF4", transp = 75)

//////////////
// STRATEGY //

//strategy.entry("long",  true,  stop = trailing_sl1)
//strategy.entry("short", false, stop = trailing_sl1)

strategy.entry("long",    true, when = total_pos ==  4)
strategy.entry("short",  false, when = total_pos == -4)

strategy.close("long",  when = total_pos <= 0)
strategy.close("short", when = total_pos >= 0)

Mais.