Estratégia de parada deslizante
ChaoZhang
Visão geral
A estratégia usa o filtro de Kalman para rastrear o preço e usa a linha de parada para ajustar dinamicamente o ponto de parada, permitindo um stop-loss deslizante.
Princípios
A estratégia usa o filtro de Kármán para rastrear os preços em tempo real. O filtro de Kármán contém duas equações:
Equação de previsão:
smooth = kf[1] + dk * sqrt(gain / 10000 * 2)
Atualização:
kf = smooth + velo
Dk é o erro de previsão, gain é o ganho de Kalman, e a decisão de seguir a sensibilidade.
Além disso, a estratégia usa uma linha de stop-loss deslizante para bloquear o lucro. A distância de stop-loss inicial é um valor definido como o percentual de stop-loss, como 2%.
Ao fazer mais, se o preço sobe, a linha de parada também sobe gradualmente para se aproximar da linha de Kalman, o passo é downStep, como 0,5%. Se o preço cair, a parada é reaberta e a distância de parada inicial é definida.
Não se preocupe.
Desta forma, a estratégia pode bloquear os lucros de acordo com as tendências, com uma melhor gestão de risco.
Vantagens
O filtro de Kalman é usado para acompanhar os preços em tempo real e responder rapidamente.
O uso de uma linha de parada de deslizamento para bloquear o lucro e gerenciar o risco é muito eficaz. A distância de parada de perda pode ser personalizada.
Pode optar por fazer mais ou apenas mais/mais tempo livre.
Pode ser uma parada ativa ou uma parada conservadora, dependendo da tendência.
A paragem pode ser ajustada de acordo com a necessidade.
Riscos
A configuração incorreta dos parâmetros do filtro de Kalman pode causar instabilidade de rastreamento.
O ponto de deslizamento pode causar que o ponto de parada seja acionado primeiro. A distância de parada pode ser relaxada adequadamente.
Os mercados de tendências fortes não devem adotar estratégias de stop loss deslizantes, e devem seguir a tendência.
Os pontos de parada de mercado de choque podem ser acionados com frequência. A distância de parada pode ser relaxada adequadamente ou não pode ser usada.
Otimização
A introdução de mais indicadores para determinar a direção da tendência e otimizar a hora de abrir uma posição.
A duração da linha de stop loss pode ser ajustada de acordo com a volatilidade do mercado.
O melhor parâmetro de estenção pode ser combinado com treinamento em técnicas de aprendizagem de máquina.
Pode ser combinado com mais indicadores de risco e gestão de posições de ajuste dinâmico.
Resumir
A estratégia de parada de deslizamento usa o filtro de Kalman para rastrear as mudanças de preço e usa a linha de parada de deslizamento para bloquear os lucros, controlando o risco e garantindo a lucratividade, é uma estratégia confiável e fácil de otimizar. Combiná-la com o julgamento de tendências e a tecnologia de gerenciamento de posições dinâmicas pode ter um efeito estratégico superior.
/*backtest
start: 2023-09-06 00:00:00
end: 2023-10-06 00:00:00
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © BigCoinHunter
//@version=5
// strategy(title='Loft Strategy V1', overlay=true,
// pyramiding=0, default_qty_type=strategy.fixed,
// default_qty_value=100, initial_capital=100000,
// currency=currency.USD, commission_value=0.05,
// commission_type=strategy.commission.percent,
// process_orders_on_close=true)
//-------------- fetch user inputs ------------------
gain = input.float(title="Kalman Gain:", defval=1.0, minval=1.0, maxval=5000.0, step=100.0)
src = input(defval=close, title='Source:')
stopPercentMax = input.float(title='Beginning Approach(%):', defval=2.0, minval=0.1, maxval=30.0, step=0.1)
stopPercentMin = input.float(title='Final Approach(%): ', defval=0.5, minval=0.1, maxval=30.0, step=0.1)
downStep = input.float(title='Approach Decrease Step:', defval=0.005, minval=0.0, maxval = 5, step=0.005)
tp = input.float(title="Take Profit:", defval=1.5, minval=0.0, maxval=100.0, step=0.1) * 0.01
sl = input.float(title="Stop Loss: ", defval=0.0, minval=0.0, maxval=100.0, step=0.1) * 0.01
longEntry = input.bool(defval=true, title= 'Long Entry', inline="11")
shortEntry = input.bool(defval=true, title='Short Entry', inline="11")
//---------- backtest range setup ------------
fromDay = input.int(defval = 1, title = "From Day", minval = 1, maxval = 31)
fromMonth = input.int(defval = 1, title = "From Month", minval = 1, maxval = 12)
fromYear = input.int(defval = 2021, title = "From Year", minval = 2010)
toDay = input.int(defval = 30, title = "To Day", minval = 1, maxval = 31)
toMonth = input.int(defval = 12, title = "To Month", minval = 1, maxval = 12)
toYear = input.int(defval = 2022, title = "To Year", minval = 2010)
//------------ time interval setup -----------
start = timestamp(fromYear, fromMonth, fromDay, 00, 00) // backtest start window
finish = timestamp(toYear, toMonth, toDay, 23, 59) // backtest finish window
window() => true // create function "within window of time"
//------- define the global variables ------
enterLongComment = "ENTER LONG"
exitLongComment = "EXIT LONG"
enterShortComment = "ENTER SHORT"
exitShortComment = "EXIT SHORT"
longTPSL = "Long TP/SL"
longTP = "Long TP"
longSL = "Long SL"
shortTPSL = "Short TP/SL"
shortTP = "Short TP"
shortSL = "Short SL"
var bool long = true
var bool stoppedOutLong = false
var bool stoppedOutShort = false
var float kf = 0.0
var float velo = 0.0
//------ kalman filter calculation --------
dk = src - nz(kf[1], src)
smooth = nz(kf[1], src) + dk * math.sqrt(gain / 10000 * 2)
velo := nz(velo[1], 0) + gain / 10000 * dk
kf := smooth + velo
//--------- calculate the loft stopLoss line ---------
var stopPercent = stopPercentMax
var stopLoss = kf - kf * (stopPercent /100)
if long == true
stopLoss := kf - (kf * (stopPercent / 100))
if long[1] == true and stopLoss <= stopLoss[1]
stopLoss := stopLoss[1]
else if (long[1] == true)
stopPercent := stopPercent - downStep
if(stopPercent < stopPercentMin)
stopPercent := stopPercentMin
if(kf < stopLoss)
long := false
stopPercent := stopPercentMax
stopLoss := kf + (kf * (stopPercent / 100))
else
stopLoss := kf + (kf * (stopPercent / 100))
if long[1] == false and stopLoss >= stopLoss[1]
stopLoss := stopLoss[1]
else if(long[1] == false)
stopPercent := stopPercent - downStep
if(stopPercent < stopPercentMin)
stopPercent := stopPercentMin
if(kf > stopLoss)
long := true
stopPercent := stopPercentMax
stopLoss := kf - (kf * (stopPercent / 100))
//--------- calculate the input/output points -----------
longProfitPrice = strategy.position_avg_price * (1 + tp) // tp -> take profit percentage
longStopPrice = strategy.position_avg_price * (1 - sl) // sl -> stop loss percentage
shortProfitPrice = strategy.position_avg_price * (1 - tp)
shortStopPrice = strategy.position_avg_price * (1 + sl)
//------------------- determine buy and sell points ---------------------
buySignall = window() and long and (not stoppedOutLong)
sellSignall = window() and (not long) and (not stoppedOutShort)
//---------- execute the strategy -----------------
if(longEntry and shortEntry)
if long
strategy.entry("LONG", strategy.long, when = buySignall, comment = enterLongComment)
stoppedOutLong := true
stoppedOutShort := false
else
strategy.entry("SHORT", strategy.short, when = sellSignall, comment = enterShortComment)
stoppedOutLong := false
stoppedOutShort := true
else if(longEntry)
strategy.entry("LONG", strategy.long, when = buySignall, comment = enterLongComment)
strategy.close("LONG", when = sellSignall, comment = exitLongComment)
if long
stoppedOutLong := true
else
stoppedOutLong := false
else if(shortEntry)
strategy.entry("SHORT", strategy.short, when = sellSignall, comment = enterShortComment)
strategy.close("SHORT", when = buySignall, comment = exitShortComment)
if not long
stoppedOutShort := true
else
stoppedOutShort := false
//----------------- take profit and stop loss -----------------
if(tp>0.0 and sl>0.0)
if ( strategy.position_size > 0 )
strategy.exit(id="LONG", limit=longProfitPrice, stop=longStopPrice, comment = longTPSL)
else if ( strategy.position_size < 0 )
strategy.exit(id="SHORT", limit=shortProfitPrice, stop=shortStopPrice, comment = shortTPSL)
else if(tp>0.0)
if ( strategy.position_size > 0 )
strategy.exit(id="LONG", limit=longProfitPrice, comment = longTP)
else if ( strategy.position_size < 0 )
strategy.exit(id="SHORT", limit=shortProfitPrice, comment = shortTP)
else if(sl>0.0)
if ( strategy.position_size > 0 )
strategy.exit(id="LONG", stop=longStopPrice, comment = longSL)
else if ( strategy.position_size < 0 )
strategy.exit(id="SHORT", stop=shortStopPrice, comment = shortSL)
//------------- plot charts ---------------------
lineColor1 = long ? color.green : color.red
lineColor2 = long ? color.aqua : color.fuchsia
kalmanLine = plot(kf, color=lineColor1, linewidth=3, title = "Kalman Filter")
stopLine = plot(stopLoss, color=lineColor2, linewidth=2, title = "Stop Loss Line")