Estrategia de creación de mercado con límite de bandas de Bollinger


Fecha de creación: 2024-01-24 11:05:56 Última modificación: 2024-01-24 11:05:56
Copiar: 0 Número de Visitas: 949
1
Seguir
1617
Seguidores

Estrategia de creación de mercado con límite de bandas de Bollinger

Descripción general

La estrategia es una estrategia de mercadotecnia que utiliza las bandas de Brin como entradas, los promedios móviles como cerrar, y el porcentaje de parada simple como parada de pérdidas. Se obtuvo una gran ganancia en los contratos de xtbtusd en junio de 2022.

Principio de estrategia

La estrategia utiliza el tren de arriba a abajo de la banda de Brin como una zona de oportunidad para la construcción de un almacén. Concretamente, cuando el precio está por debajo del tren de abajo, se abrirá un almacén múltiple; cuando el precio está por encima del tren de arriba, se abrirá un almacén vacío.

Además, la estrategia también utiliza las medias móviles como referencia para la posición en blanco. Cuando se tiene una cantidad de órdenes, se elige la posición en blanco si el precio es superior a la media móvil; del mismo modo, cuando se tiene una carta en blanco, se elige la posición en blanco si el precio es inferior a la media móvil.

Para el stop loss, la estrategia utiliza un simple método de stop rolling, multiplicado por el precio de entrada por un porcentaje determinado. Esto puede evitar de manera efectiva grandes pérdidas en un escenario unilateral.

Análisis de las ventajas

Las principales ventajas de esta estrategia son las siguientes:

  1. El uso de las bandas de Brin permite capturar la volatilidad de los precios de manera eficiente, lo que permite obtener más oportunidades de negociación cuando la volatilidad se agrava.
  2. Las estrategias de mercadotecnia permiten obtener ingresos por comisiones de los compradores y vendedores a través de transacciones bidireccionales.
  3. El uso de stop loss porcentual permite controlar el riesgo de manera activa y evitar pérdidas masivas en situaciones unilaterales.

Análisis de riesgos

La estrategia también tiene sus riesgos:

  1. El cinturón de Brin no siempre es un indicador fiable de entrada, a veces emite señales erróneas.
  2. Las estrategias de mercadotecnia pueden ser fácilmente capturadas en situaciones de crisis.
  3. El cierre porcentual puede ser demasiado arbitrario y no flexible para manejar situaciones complejas.

Para reducir estos riesgos, podemos considerar la posibilidad de filtrar en combinación con otros indicadores, optimizar la configuración de la estrategia de stop loss o limitar el tamaño de la posición de manera adecuada.

Dirección de optimización

La estrategia tiene espacio para ser optimizada aún más:

  1. Puede probar diferentes combinaciones de parámetros para encontrar el parámetro óptimo.
  2. Se pueden agregar más indicadores de filtración para la verificación multifactorial.
  3. Los parámetros se pueden optimizar automáticamente con métodos de aprendizaje automático.
  4. Se puede considerar el uso de métodos de deterioro más finos, como el deterioro de la parallaxa.

Resumir

La estrategia en su conjunto es una estrategia muy rentable para los comerciantes de alta frecuencia. Utiliza las bandas de Brin para ofrecer oportunidades de negociación y controlar el riesgo. Pero también debemos ser conscientes de sus problemas y deficiencias y verificarlos cuidadosamente en el mercado real.

Código Fuente de la Estrategia
/*backtest
start: 2023-12-24 00:00:00
end: 2024-01-23 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=3
strategy(shorttitle="BBL", title="BB limit", overlay = true)


length = input(200, minval=1)
src = input(hlc3, title="Source")
xmult = input(44, minval=0.001, maxval=5000, title = "bb mult (0.1%)")
s = input(title="Trend source", defval = "sma", options = ["ema", "sma", "rma", "wma"])
basis = s == "ema" ? ema(src, length) : s == "sma" ? sma(src, length) : s =="rma" ? rma(src, length) : wma(src, length)
sd = input(title="Dev source", defval = "stdev", options = ["stdev", "dev"])
mult = xmult / 10  
dev = sd == "stdev" ? mult * stdev(src, length) : mult * dev(src, length)
diff = input(0.5, title = "Spread")
LongPrice(p) =>
    LongPrice = diff == 0 ? p : floor(p / diff) * diff

ShortPrice(p) =>
    ShortPrice = diff == 0 ? p : ceil(p / diff) * diff

pyr = input(1, title = "Pyramiding")
useStopLoss = input(true)
stoploss_xmult = input(15, minval=0.001, maxval=5000, title = "StopLoss 0.1%")
stopLoss_mult = sd == "simple" ? 1 + stoploss_xmult / 10 / 100 : stoploss_xmult / 10  
dev2 = sd == "stdev" ? stopLoss_mult * stdev(src, length) : sd == "dev" ? stopLoss_mult * dev(src, length) : (stopLoss_mult - 1) * basis
upper = basis + (1*dev)
lower = basis - (1*dev)
plot(basis, color=fuchsia, linewidth=2)
plot(upper, color=green, linewidth=2)
plot(lower, color=green, linewidth=2)


strategy.cancel_all()

if strategy.position_size > 0 and close <= basis + diff * 2
    strategy.order("Close long", strategy.short, strategy.position_size, limit = ShortPrice(basis))
else 
    if strategy.position_size < 0 and close >= basis - diff * 2
        strategy.order("Close short", strategy.long, -strategy.position_size, limit = LongPrice(basis))
            
stopLossPrice1 = na
stopLossPrice2 = na
add = na
openOrderCondition = close > lower - 2 * diff and (strategy.opentrades < pyr or (strategy.position_size < 0 and strategy.position_avg_price > lower * (1 + stopLoss_mult / 100)))
if openOrderCondition
    add := strategy.position_size > 0 ? -strategy.position_size : close >= basis - diff * 2 ? 0 : -strategy.position_size
    strategy.order("Open long", strategy.long, strategy.equity / pyr / lower + add, limit = LongPrice(lower))
if useStopLoss and (strategy.position_size > 0 or openOrderCondition)
    add = openOrderCondition ? strategy.equity / pyr / lower : 0
    posPrice = strategy.position_size <= 0 ? lower : strategy.position_avg_price
    posSize = strategy.position_size <= 0 ? 0 : strategy.position_size
    stopLossPrice1 := posPrice * (1 - stopLoss_mult / 100)
    strategy.order("StopLoss open short ", strategy.short, posSize + add + strategy.equity / pyr / stopLossPrice1, stop = ShortPrice(stopLossPrice1))


openOrderCondition := close < upper + 2 * diff and (strategy.opentrades < pyr or (strategy.position_size > 0 and strategy.position_avg_price * (1 + stopLoss_mult / 100) < upper))
if openOrderCondition
    add := strategy.position_size < 0 ? strategy.position_size : close <= basis + diff * 2 ? 0 : strategy.position_size
    strategy.order("Open short", strategy.short, strategy.equity / pyr / upper + add, limit = ShortPrice(upper))
if useStopLoss and (strategy.position_size < 0 or openOrderCondition)
    add = openOrderCondition ? strategy.equity / pyr / upper : 0
    posPrice = strategy.position_size >= 0 ? upper : strategy.position_avg_price
    posSize = strategy.position_size >= 0 ? 0 : -strategy.position_size
    stopLossPrice2 := posPrice * (1 + stopLoss_mult / 100)
    strategy.order("StopLoss open long", strategy.long, posSize + add + strategy.equity / pyr / stopLossPrice2, stop = LongPrice(stopLossPrice2))

plot(not useStopLoss ? na : stopLossPrice1, color=red, linewidth=2)
plot(not useStopLoss ? na : stopLossPrice2, color=red, linewidth=2)

// === Backtesting Dates ===
testPeriodSwitch = input(false, "Custom Backtesting Dates")
testStartYear = input(2018, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testStartHour = input(0, "Backtest Start Hour")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,testStartHour,0)
testStopYear = input(2018, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(14, "Backtest Stop Day")
testStopHour = input(14, "Backtest Stop Hour")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,testStopHour,0)
testPeriod() =>
    time >= testPeriodStart and time <= testPeriodStop ? true : false
isPeriod = testPeriodSwitch == true ? testPeriod() : true
// === /END
if not isPeriod
    strategy.cancel_all()
    strategy.close_all()