Uma nova estratégia de negociação quantitativa baseada no padrão ABCD com stop loss e take profit trailing
ChaoZhang
Uma visão geral da estratégia
A estratégia é denominada como a melhor estratégia de negociação da forma ABCD (com rastreamento de stop loss e rastreamento de stop loss). É uma estratégia quantitativa para realizar operações de negociação com base em um modelo de forma de preço ABCD definido. A ideia principal é identificar o modelo de forma ABCD completo, fazer mais tomadas de posição de acordo com a direção da forma, e configurar o rastreamento de stop loss e stop loss para gerenciar as posições.
2. Princípios de estratégia
Usando a arbitragem auxiliada de Brin para identificar os pontos de classificação de topo e fundo do preço, obtém-se a curva ZigZag do preço.
Para identificar um modelo de forma ABCD completo na curva ZigZag, os quatro pontos A, B, C e D precisam atender a uma determinada relação proporcional. Depois de identificar uma forma ABCD compatível, faça mais ou menos.
Depois de fazer mais curto prazo, configure o rastreamento de stop loss para controlar o risco. Use stop loss fixo no início do stop loss e, quando o lucro atinge uma certa proporção, mude para stop loss móvel para bloquear parte do lucro.
Da mesma forma, a linha de paragem também é configurada para traçar a paragem em tempo hábil após obter um lucro suficiente, evitando o retorno dos lucros. A paragem de rastreamento também é dividida em duas fases, primeiro usando uma parada fixa para obter parte do lucro e depois se transformando em uma parada móvel para continuar a acompanhar o preço.
Quando o preço desencadeia um stop loss ou stop loss móvel, a posição é liquidada e um ciclo de negociação é concluído.
Terceiro, análise de estratégia.
O uso da técnica de julgamento auxiliado por Brin para identificar a curva ZigZag evita o problema de retrocesso da curva ZigZag tradicional, tornando o sinal de negociação mais confiável.
O modelo de negociação de forma ABCD é maduro e estável, com muitas oportunidades de negociação. A direção da forma ABCD é clara e fácil de determinar a direção da entrada no mercado.
A configuração de um stop loss de dois estágios permite um melhor controle do risco e obtenção de lucros. O stop loss móvel permite uma maior flexibilidade na estratégia.
O design dos parâmetros de estratégia é razoável, a porcentagem de parada de parada de perda e a porcentagem de inicialização móvel podem ser personalizadas, e a flexibilidade de uso é excelente.
A estratégia pode ser usada em qualquer variedade, incluindo divisas, criptomoedas e índices de ações.
Quatro, análise de risco estratégico
Embora o formato do ABCD seja mais claro, as oportunidades de negociação são relativamente limitadas e não garantem uma frequência de negociação suficiente.
Em situações de choque, pode ocorrer uma situação em que o travão de travão é acionado com frequência. Nesse caso, é necessário ajustar adequadamente os parâmetros para expandir o alcance do travão de travão.
É necessário prestar atenção à liquidez das próprias variedades de negociação. Os padrões de baixa liquidez, como o stop loss, são difíceis de executar com precisão.
A estratégia é sensível aos custos de transação e requer a escolha de corretores e contas com taxas baixas.
Alguns parâmetros podem ser continuamente otimizados, como as condições de inicialização de stop loss móvel e stop stop que podem ser testadas para obter mais valores e encontrar os melhores pontos.
Cinco, estratégias de otimização
Pode ser combinado com outros indicadores para definir mais condições de filtragem, evitando parte da forma HW. Isso pode reduzir a ocorrência de transações inválidas.
Aumentar o julgamento da estrutura de três segmentos do mercado, procurando oportunidades de negociação apenas no terceiro segmento. Isso pode aumentar a chance de vitória da estratégia.
Teste para otimizar o tamanho do capital inicial e encontre o melhor nível de capital inicial.
Pode-se testar dados extra-sampulares para verificar a robustez dos parâmetros. Isso é essencial para a estabilidade a longo prazo da estratégia.
Continuar a otimizar as condições móveis de stop/stop e o tamanho do ponto de deslizamento para aumentar a eficiência da execução da estratégia.
Seis, um resumo da estratégia
A estratégia depende principalmente do padrão de preço do ABCD para julgar e entrar no mercado. A estratégia é mais estável, mas a frequência de negociação pode ser baixa. Podemos obter oportunidades de negociação mais eficientes adicionando condições de filtragem. Além disso, continuar a otimizar os parâmetros e a escala de capital também pode melhorar a rentabilidade estável da estratégia.
/*backtest
start: 2024-02-11 00:00:00
end: 2024-02-18 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// @version=4
// @author=Daveatt - BEST
// ABCD Pattern Strat
StrategyName = "BEST ABCD Pattern Strategy (Trailing SL + TP)"
ShortStrategyName = "BEST ABCD Strategy (Trailing)"
strategy(title=StrategyName, shorttitle=ShortStrategyName, overlay=true )
filterBW = input(false, title="filter Bill Williams Fractals?")
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////// UTILITIES ///////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// ||-----------------------------------------------------------------------------------------------------||
// ||--- Fractal Recognition Functions: ---------------------------------------------------------------||
isRegularFractal(mode, _high, _low) =>
ret = mode == 1 ? _high[4] < _high[3] and _high[3] < _high[2] and _high[2] > _high[1] and _high[1] > _high[0] :
mode == -1 ? _low[4] > _low[3] and _low[3] > _low[2] and _low[2] < _low[1] and _low[1] < _low[0] : false
isBWFractal(mode, _high, _low) =>
ret = mode == 1 ? _high[4] < _high[2] and _high[3] <= _high[2] and _high[2] >= _high[1] and _high[2] > _high[0] :
mode == -1 ? _low[4] > _low[2] and _low[3] >= _low[2] and _low[2] <= _low[1] and _low[2] < _low[0] : false
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
////////////////////////////// ABCD PATTERN ///////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
f_abcd()=>
_r = timeframe.period
_g = barmerge.gaps_off
_l = barmerge.lookahead_on
_high = high
_low = low
filteredtopf = filterBW ? isRegularFractal(1, _high, _low) : isBWFractal(1, _high, _low)
filteredbotf = filterBW ? isRegularFractal(-1, _high, _low) : isBWFractal(-1, _high, _low)
// ||--- ZigZag:
istop = filteredtopf
isbot = filteredbotf
topcount = barssince(istop)
botcount = barssince(isbot)
zigzag = (istop and topcount[1] > botcount[1] ? _high[2] :
isbot and topcount[1] < botcount[1] ? _low[2] : na)
x = valuewhen(zigzag, zigzag, 4)
a = valuewhen(zigzag, zigzag, 3)
b = valuewhen(zigzag, zigzag, 2)
c = valuewhen(zigzag, zigzag, 1)
d = valuewhen(zigzag, zigzag, 0)
xab = (abs(b-a)/abs(x-a))
xad = (abs(a-d)/abs(x-a))
abc = (abs(b-c)/abs(a-b))
bcd = (abs(c-d)/abs(b-c))
// ABCD Part
_abc = abc >= 0.382 and abc <= 0.886
_bcd = bcd >= 1.13 and bcd <= 2.618
_bull_abcd = _abc and _bcd and d < c
_bear_abcd = _abc and _bcd and d > c
_bull = _bull_abcd and not _bull_abcd[1]
_bear = _bear_abcd and not _bear_abcd[1]
[_bull, _bear, zigzag]
lapos_x = timenow + round(change(time)*12)
[isLong, isShort, zigzag] = f_abcd()
plot(zigzag, title= 'ZigZag', color=color.black, offset=-2)
plotshape(isLong, style=shape.labelup, location=location.belowbar, color=color.new(color.green, 0), size=size.normal, text="ABCD", textcolor=color.white)
plotshape(isShort, style=shape.labeldown, location=location.abovebar, color=color.new(color.maroon, 0), size=size.normal, text="ABCD", textcolor=color.white)
long_entry_price = valuewhen(isLong, close, 0)
short_entry_price = valuewhen(isShort, close, 0)
sinceNUP = barssince(isLong)
sinceNDN = barssince(isShort)
buy_trend = sinceNDN > sinceNUP
sell_trend = sinceNDN < sinceNUP
change_trend = (buy_trend and sell_trend[1]) or (sell_trend and buy_trend[1])
entry_price = buy_trend ? long_entry_price : short_entry_price
///////////////////////////////
//======[ Trailing STOP ]======//
///////////////////////////////
// use SL?
useSL = input(true, "Use stop Loss")
// Configure trail stop level with input
StopTrailPerc = input(title="Trail Loss (%)", type=input.float, minval=0.0, step=0.1, defval=3) * 0.01
// Will trigger the take profit trailing once reached
use_SL_Trigger = input(true, "Use stop Loss Trigger")
StopTrailTrigger = input(2.0, "SL Trigger (%)",minval=0,step=0.5,type=input.float) * 0.01
StopLossPriceTrigger = 0.0
StopLossPriceTrigger := if (use_SL_Trigger)
if buy_trend
entry_price * (1 + StopTrailTrigger)
else
entry_price * (1 - StopTrailTrigger)
else
-1
var SL_Trigger_Long_HIT = false
SL_Trigger_Long_HIT := useSL and use_SL_Trigger and buy_trend and high >= StopLossPriceTrigger
? true : SL_Trigger_Long_HIT[1]
var SL_Trigger_Short_HIT = false
SL_Trigger_Short_HIT := useSL and use_SL_Trigger and sell_trend and low <= StopLossPriceTrigger
? true : SL_Trigger_Short_HIT[1]
display_long_SL_trigger = useSL and buy_trend and use_SL_Trigger
and SL_Trigger_Long_HIT == false and StopLossPriceTrigger != -1
display_short_SL_trigger = useSL and sell_trend and use_SL_Trigger
and SL_Trigger_Short_HIT == false and StopLossPriceTrigger != -1
display_SL_trigger = display_long_SL_trigger or display_short_SL_trigger
plot(display_SL_trigger ? StopLossPriceTrigger : na, title='SLPriceTrigger', transp=0,
color=color.maroon, style=plot.style_circles, linewidth=3)
// Determine trail stop loss prices
longStopPrice = 0.0, shortStopPrice = 0.0
longStopPrice := if useSL and buy_trend
stopValue = low * (1 - StopTrailPerc)
max(stopValue, longStopPrice[1])
else
0
shortStopPrice := if useSL and sell_trend
stopValue = high * (1 + StopTrailPerc)
min(stopValue, shortStopPrice[1])
else
999999
//////////////////////////////////////////////////////////////////////////////////////////
//*** STOP LOSS HIT CONDITIONS ***//
//////////////////////////////////////////////////////////////////////////////////////////
cond_long_stop_loss_hit = useSL and buy_trend and crossunder(low, longStopPrice[1])
and (SL_Trigger_Long_HIT or use_SL_Trigger == false)
cond_short_stop_loss_hit = useSL and sell_trend and crossover(high, shortStopPrice[1])
and (SL_Trigger_Short_HIT or use_SL_Trigger == false)
// Plot stop loss values for confirmation
plot(series=useSL and buy_trend and low >= longStopPrice
and (SL_Trigger_Long_HIT or use_SL_Trigger == false)
? longStopPrice : na,
color=color.fuchsia, style=plot.style_cross,
linewidth=2, title="Long Trail Stop")
plot(series=useSL and sell_trend and high <= shortStopPrice
and (SL_Trigger_Short_HIT or use_SL_Trigger == false)
? shortStopPrice : na,
color=color.fuchsia, style=plot.style_cross,
linewidth=2, title="Short Trail Stop")
///////////////////////////////
//======[ Take Profit ]======//
///////////////////////////////
// Use TP?
useTP = input(true, "Use take profit")
// TP trailing
ProfitTrailPerc = input(1.0, "Trailing Profit (%)",minval=0,step=0.5,type=input.float) * 0.01
use_TP_Trigger = input(true, "Use Take Profit Trigger")
// Will trigger the take profit trailing once reached
takeProfitTrigger = input(3.0, "Take Profit Trigger (%)",minval=0,step=0.5,type=input.float) * 0.01
// ttp := ttp>tp ? tp : ttp
takeprofitPriceTrigger = 0.0
takeprofitPriceTrigger := if (use_TP_Trigger)
if (buy_trend)
entry_price * (1 + takeProfitTrigger)
else
entry_price * (1 - takeProfitTrigger)
else
-1
//plot(entry_price, title='entry_price', transp=100)
var TP_Trigger_Long_HIT = false
TP_Trigger_Long_HIT := useTP and use_TP_Trigger and buy_trend and high >= takeprofitPriceTrigger
? true : TP_Trigger_Long_HIT[1]
var TP_Trigger_Short_HIT = false
TP_Trigger_Short_HIT := useTP and use_TP_Trigger and sell_trend and low <= takeprofitPriceTrigger
? true : TP_Trigger_Short_HIT[1]
display_long_TP_trigger = useTP and buy_trend and TP_Trigger_Long_HIT == false
and takeprofitPriceTrigger != -1
display_short_TP_trigger = useTP and sell_trend and TP_Trigger_Short_HIT == false
and takeprofitPriceTrigger != -1
display_TP_trigger = display_long_TP_trigger or display_short_TP_trigger
//🔷🔷🔷
// @hugo: Will display the TP trigger as long as not hit
// once the TP trigger is hit, the TP trailing will activate
plot(display_TP_trigger ? takeprofitPriceTrigger : na, title='takeprofitPriceTrigger', transp=0, color=color.orange,
style=plot.style_cross, linewidth=3)
longTrailTP= 0.0, shortTrailTP = 0.0
// Trailing Profit
// Start trailing once trigger is reached
longTrailTP := if useTP and buy_trend
tpValue = high * (1 + ProfitTrailPerc)
max(tpValue, longTrailTP[1])
else
0
shortTrailTP := if useTP and sell_trend
tpValue = low * (1 - ProfitTrailPerc)
min(tpValue, shortTrailTP[1])
else
999999
//plot(longTrailTP, title='debug longTrailTP', transp=100)
//plot(shortTrailTP, title='debug shortTrailTP', transp=100)
//////////////////////////////////////////////////////////////////////////////////////////
//*** TRAILING TAKE PROFIT HIT CONDITIONS TO BE USED IN ALERTS ***//
//////////////////////////////////////////////////////////////////////////////////////////
//🔷🔷🔷
// @hugo: I use crossover/crossunder for the alerts to trigger the events only once
cond_long_trail_tp_hit = useTP and buy_trend and crossover(high, longTrailTP[1])
and (TP_Trigger_Long_HIT or use_TP_Trigger == false)
cond_short_trail_tp_hit = useTP and sell_trend and crossunder(low, shortTrailTP[1])
and (TP_Trigger_Short_HIT or use_TP_Trigger == false)
// 🔷🔷🔷
// Plot take profits values for confirmation
// Display the trailing TP until not hit
plot(series= useTP and buy_trend and high <= longTrailTP and
(TP_Trigger_Long_HIT or use_TP_Trigger == false) ? longTrailTP : na,
color=color.aqua, style=plot.style_circles,
linewidth=2, title="Long Trail TP")
plot(series= useTP and sell_trend and low >= shortTrailTP and
(TP_Trigger_Short_HIT or use_TP_Trigger == false) ? shortTrailTP : na,
color=color.aqua, style=plot.style_circles,
linewidth=2, title="Short Trail TP")
close_long = cond_long_trail_tp_hit or cond_long_stop_loss_hit
close_short = cond_short_trail_tp_hit or cond_short_stop_loss_hit
strategy.entry("Long", 1, when=isLong)
strategy.close("Long", when=close_long)
strategy.entry("Short", 0, when=isShort)
strategy.close("Short", when=close_short)
if change_trend
SL_Trigger_Long_HIT := false
SL_Trigger_Short_HIT := false
TP_Trigger_Long_HIT := false
TP_Trigger_Short_HIT := false