Estratégia de negociação de spread de curto prazo com base no rompimento da sessão


Data de criação: 2023-09-20 17:00:16 última modificação: 2023-09-20 17:00:16
cópia: 1 Cliques: 724
1
focar em
1617
Seguidores

Visão geral

Esta estratégia combina um quadro de paradas de espaço múltiplo com um quadro de tempo múltiplo para capturar brechas de linha curta e fazer transações de difusão durante o período de tempo da sessão.

Princípio da estratégia

  1. Calcula-se a trajetória multi-aérea do dia e do curto prazo, formando uma brecha em dois quadros temporais.

  2. Apenas negocie dentro de um período de negociação personalizado. O período começa a entrar em breakouts e o período termina em equilíbrio.

  3. O preço calcula a EMA em tempo real como o preço de entrada. O preço acima da trajectória média gera um sinal de ruptura.

  4. Estabeleça uma linha de perda fora da brecha.

  5. Quando o preço retrocede perto da trajectória média, a confirmação de que a ruptura falhou e a liquidação.

Análise de vantagens

  1. A combinação de vários períodos permite uma eficiente filtragem de falhas.

  2. A restrição do horário de negociação permite evitar notícias importantes.

  3. A EMA pode rastrear os preços de forma progressiva e entrar em ação em tempo hábil.

  4. Estabelecer um limite de perda ajuda a controlar o risco.

  5. A obrigação de fechar uma posição por um período de tempo pode evitar riscos durante a noite.

Análise de Riscos

  1. A ruptura de uma linha curta pode ocorrer quando a parada é acionada.

  2. Algumas descobertas podem não ser totalmente lucrativas até o final do período.

  3. A configuração errada do horário também pode fazer com que você perca uma oportunidade de negociação.

  4. Não há garantias de que todos os avanços alcançarão os lucros esperados.

  5. Pode haver problemas de compatibilidade com os parâmetros de otimização.

Direção de otimização

  1. Teste diferentes parâmetros de ruptura para encontrar a combinação ideal.

  2. Avaliar outros indicadores para melhorar a precisão da admissão.

  3. Otimizar o tempo de negociação, encontrar um equilíbrio entre lucro e risco.

  4. Estude como combinar estratégias de bloqueio com estratégias de bloqueio de lucro.

  5. Teste a variabilidade de configurações de parâmetros de diferentes variedades.

  6. Parâmetros de otimização dinâmica de algoritmos de aprendizagem de máquina.

Resumir

A estratégia tenta fazer a troca de spreads de curta distância por meio de brechas de sessão limitada. Otimização para brechas falsas e controle de risco pode ser melhorada para uma estratégia de negociação de curta distância prática e eficiente.

Código-fonte da estratégia
/*backtest
start: 2023-08-20 00:00:00
end: 2023-09-19 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=3
strategy("Breakout Scalper", overlay=true)

// -------------------------------------------------------------------------------------------------
// INPUTS
// -------------------------------------------------------------------------------------------------
// Period of the "fast" donchian channel
fast_window = input(title="Fast Window",  defval=13, minval=1)
// Used for the volatility (atr) period
slow_window = input(title="Slow Window",  defval=52, minval=1)
// Period of EMA used as the current price
instant_period = input(title="Instant Period",  defval=3, minval=1)
// Minimum ratio of cloud width to ATR in order for trade to be active
cloud_min_percent = input(title="Minimum Cloud ATR Multiplier", type=float, defval=1.0, minval=0)
// Session where we allow trades to be active
trading_sesh = input(title="Trading Session",  defval='1000-1500')
// -------------------------------------------------------------------------------------------------

// -------------------------------------------------------------------------------------------------
// SESSION TIMING
// -------------------------------------------------------------------------------------------------
is_newbar(t) =>
    na(t[1]) and not na(t) or t[1] < t

day_time = time("D")
sess_time = time(timeframe.period, trading_sesh)
day_open_bar = is_newbar(day_time)
sess_open_bar = is_newbar(sess_time)
sess_close_bar = na(sess_time) and not na(sess_time[1])
sess_is_open = false
sess_is_open := sess_open_bar ? true : (sess_close_bar ? false : sess_is_open[1])
// -------------------------------------------------------------------------------------------------

// -------------------------------------------------------------------------------------------------
// DONCHIANS
// -------------------------------------------------------------------------------------------------
slow_high = na
slow_high := day_open_bar ? high : (high > slow_high[1] ? high : slow_high[1])
slow_low = na
slow_low := day_open_bar ? low : (low < slow_low[1] ? low : slow_low[1])
slow_mid = (slow_high + slow_low) / 2

fast_low = max(slow_low, lowest(fast_window))
fast_high = min(slow_high, highest(fast_window))
fast_mid = (fast_low + fast_high) / 2
// -------------------------------------------------------------------------------------------------


// -------------------------------------------------------------------------------------------------
// TREND CLOUD
// -------------------------------------------------------------------------------------------------
cloud_width = fast_mid - slow_mid
slow_atr = atr(slow_window)
cloud_percent = cloud_width / slow_atr
cloud_color = cloud_percent > cloud_min_percent ? green : (cloud_percent < -cloud_min_percent ? red : gray)

fp = plot(fast_mid, title="Fast MidR", color=green)
sp = plot(slow_mid, title="Slow MidR", color=red)
fill(fp, sp, color=cloud_color)
// -------------------------------------------------------------------------------------------------


// -------------------------------------------------------------------------------------------------
// INSTANT PRICE
// -------------------------------------------------------------------------------------------------
instant_price = ema(close, instant_period)
plot(instant_price, title="Instant Price", color=black, transp=50)
// -------------------------------------------------------------------------------------------------


// -------------------------------------------------------------------------------------------------
// ENTRY SIGNALS & STOPS
// -------------------------------------------------------------------------------------------------
buy_entry_signal = sess_is_open and (instant_price > fast_mid) and (cloud_percent > cloud_min_percent)
sell_entry_signal = sess_is_open and (instant_price < fast_mid) and (cloud_percent < -cloud_min_percent)
buy_close_signal = sess_close_bar or (cloud_percent < 0)
sell_close_signal = sess_close_bar or (cloud_percent > 0)

entry_buy_stop = slow_high
entry_sell_stop = slow_low
exit_buy_stop = max(slow_low, fast_low)
exit_sell_stop = min(slow_high, fast_high)

entry_buy_stop_color = (strategy.position_size == 0) ? (buy_entry_signal ? green : na) : na
plotshape(entry_buy_stop, location=location.absolute, color=entry_buy_stop_color, style=shape.circle)
entry_sell_stop_color = (strategy.position_size == 0) ? (sell_entry_signal ? red : na) : na
plotshape(entry_sell_stop, location=location.absolute, color=entry_sell_stop_color, style=shape.circle)
exit_buy_stop_color = (strategy.position_size > 0) ? red : na
plotshape(exit_buy_stop, location=location.absolute, color=exit_buy_stop_color, style=shape.xcross)
exit_sell_stop_color = (strategy.position_size < 0) ? green : na
plotshape(exit_sell_stop, location=location.absolute, color=exit_sell_stop_color, style=shape.xcross)
// -------------------------------------------------------------------------------------------------


// -------------------------------------------------------------------------------------------------
// STRATEGY EXECUTION
// -------------------------------------------------------------------------------------------------
strategy.entry("long", strategy.long, stop=entry_buy_stop, when=buy_entry_signal)
strategy.cancel("long", when=not buy_entry_signal)
strategy.exit("stop", "long", stop=exit_buy_stop)
strategy.entry("short", strategy.short, stop=entry_sell_stop, when=sell_entry_signal)
strategy.cancel("short", when=not sell_entry_signal)
strategy.exit("stop", "short", stop=exit_sell_stop)
strategy.close("long", when=buy_close_signal)
strategy.close("short", when=sell_close_signal)
// -------------------------------------------------------------------------------------------------