La estrategia de la inversión de doble línea
ChaoZhang
Descripción general
La estrategia de doble media móvil de reversión es una estrategia típica de inversión de corto plazo. La estrategia utiliza dos medias con diferentes parámetros para emitir señales de negociación y obtener ganancias cuando la tendencia se revuelve.
Principio de estrategia
La estrategia utiliza dos líneas de avance para generar señales de negociación. La primera línea de avance maopening se utiliza para determinar la dirección de la tendencia, y la segunda línea de avance maclosing se utiliza para emitir señales de negociación.
Cuando el maopening sube, indica que se encuentra en la fase de subida de la tendencia; cuando el maopening baja, indica que se encuentra en la fase de bajada de la tendencia. El maclosing se multiplica por un factor mayor a 1, lo que lo hace más sensible y puede emitir una señal de reversión con anticipación.
En concreto, cuando el maopening sube y el maclosing baja a través del maopening, la estrategia abre una posición a la baja; cuando el maopening baja y el maclosing atraviesa el maopening, la estrategia abre una posición a la baja.
Los parámetros de la estrategia incluyen el tipo de línea promedio, la longitud, la fuente de datos, etc., que se pueden ajustar para obtener mejores resultados comerciales. Además, la estrategia también incluye algunas opciones, como la forma de abrir posiciones, la forma de detener los pérdidas, etc., que se pueden configurar según sea necesario.
Análisis de las ventajas
Las principales ventajas de la estrategia de inversión de doble línea son:
Retracciones pequeñas, adecuadas para el comercio de líneas cortas. El uso de dos líneas medias rápidas permite capturar rápidamente la reversión de la tendencia a corto plazo, y las retracciones son pequeñas.
Es fácil de usar y de manejar. El cruce de dos líneas es una señal de transacción, muy simple y clara.
Hay muchos parámetros ajustables que se pueden optimizar. Los parámetros y los factores que contienen 2 líneas medias se pueden optimizar para encontrar la mejor combinación de parámetros.
Es programable, adecuado para operaciones automatizadas. La lógica de la estrategia es simple y clara, la frecuencia de ejecución es alta, muy adecuada para la programación de operaciones automatizadas.
Riesgo controlado, con un mecanismo de stop loss. Se puede configurar un stop loss móvil o un stop loss numérico, para controlar la pérdida individual.
Análisis de riesgos
La estrategia de doble equilátero también tiene algunos riesgos:
El cruce de dos líneas medias está en retraso. La línea mediana está en retraso del precio, y la tendencia puede haberse invertido durante un tiempo cuando ocurre el cruce.
Es fácil de encajar. La reversión de la tendencia no siempre es duradera, y puede volver a invertirse muy pronto, lo que genera una trampa.
Las retiradas siguen existiendo. La detención oportuna de pérdidas puede reducir las pérdidas individuales, pero la detención continua de pérdidas también puede causar una mayor retirada.
Riesgo de optimización de datos. Parámetros de optimización excesiva, que funcionan bien en los datos históricos pero no funcionan bien en el disco real.
Las soluciones para los riesgos incluyen:
Optimiza los parámetros para encontrar la configuración de línea media de respuesta rápida.
Evite la trampa en combinación con otros indicadores, como el indicador de precio de la cantidad, el indicador de fluctuación, etc.
Ajuste la posición de los estancamientos para reducir la probabilidad de que se produzcan estancamientos continuos.
Pruebas de optimización de múltiples parámetros para evaluar la robustez de los parámetros.
Dirección de optimización
Las estrategias de inversión de doble equilátero se pueden optimizar en los siguientes aspectos:
Prueba diferentes tipos de medias para encontrar medias más sensibles a la reacción. Como Kama, ZLEMA, etc.
Optimización de los parámetros de la línea media para encontrar la combinación óptima de longitud. Normalmente, la línea media con periodos más cortos es más eficaz.
Prueba diferentes fuentes de datos, como el precio de cierre, el precio medio, el precio típico, etc.
Aumentar el filtro de tendencia para evitar señales de reversión inapropiadas. Se puede usar el canal Donchian, etc.
En combinación con otros indicadores, como el indicador de precio por volumen (MACD), OBV, etc.
Aumentar los mecanismos de gestión de riesgos, como el stop loss móvil, la pérdida máxima de la cuenta, etc.
Optimización de la cartera para encontrar la mejor proporción de distribución de activos.
Aumentar las pruebas de robustez de los parámetros para evaluar el riesgo de optimización de los parámetros.
Resumir
La estrategia de inversión de doble línea uniforme es una estrategia de línea corta simple y práctica, adecuada para capturar la inversión a corto plazo en el mercado. La estrategia de retracción es pequeña, fácil de implementar y muy adecuada para el comercio de volumen. Pero también hay algunos problemas, como el riesgo de retraso, la trampa, etc. Se puede mejorar la eficacia de la estrategia mediante la optimización de los parámetros, el aumento de la filtración de los indicadores y la mejora del control del riesgo, entre otros métodos, para desarrollar una estrategia estable y eficiente con un efecto de liquidación.
/*backtest
start: 2023-10-17 00:00:00
end: 2023-11-16 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=5
strategy(title = "hamster-bot MRS 2", overlay = true, default_qty_type = strategy.percent_of_equity, initial_capital = 100, default_qty_value = 100, pyramiding = 9, commission_value = 0.045, backtest_fill_limits_assumption = 1)
info_options = "Options"
on_close = input(false, title = "Entry on close", inline=info_options, group=info_options)
OFFS = input.int(0, minval = 0, maxval = 1, title = "| Offset View", inline=info_options, group=info_options)
trade_offset = input.int(0, minval = 0, maxval = 1, title = "Trade", inline=info_options, group=info_options)
use_kalman_filter = input.bool(false, title="Use Kalman filter", group=info_options)
//MA Opening
info_opening = "MA Opening"
maopeningtyp = input.string("SMA", title="Type", options=["SMA", "EMA", "TEMA", "DEMA", "ZLEMA", "WMA", "Hma", "Thma", "Ehma", "H", "L", "DMA"], title = "", inline=info_opening, group=info_opening)
maopeningsrc = input.source(ohlc4, title = "", inline=info_opening, group=info_opening)
maopeninglen = input.int(3, minval = 1, maxval = 200, title = "", inline=info_opening, group=info_opening)
//MA Closing
info_closing = "MA Closing"
maclosingtyp = input.string("SMA", title="Type", options=["SMA", "EMA", "TEMA", "DEMA", "ZLEMA", "WMA", "Hma", "Thma", "Ehma", "H", "L", "DMA"], title = "", inline=info_closing, group=info_closing)
maclosingsrc = input.source(ohlc4, title = "", inline=info_closing, group=info_closing)
maclosinglen = input.int(3, minval = 1, maxval = 200, title = "", inline=info_closing, group=info_closing)
maclosingmul = input.float(1, step = 0.005, title = "mul", inline=info_closing, group=info_closing)
long1on = input(true, title = "", inline = "long1")
long1shift = input.float(0.96, step = 0.005, title = "Long", inline = "long1")
long1lot = input.int(10, minval = 0, maxval = 10000, step = 10, title = "Lot 1", inline = "long1")
short1on = input(true, title = "", inline = "short1")
short1shift = input.float(1.04, step = 0.005, title = "short", inline = "short1")
short1lot = input.int(10, minval = 0, maxval = 10000, step = 10, title = "Lot 1", inline = "short1")
startTime = input(timestamp("01 Jan 2010 00:00 +0000"), "Start date", inline = "period")
finalTime = input(timestamp("31 Dec 2030 23:59 +0000"), "Final date", inline = "period")
HMA(_src, _length) => ta.wma(2 * ta.wma(_src, _length / 2) - ta.wma(_src, _length), math.round(math.sqrt(_length)))
EHMA(_src, _length) => ta.ema(2 * ta.ema(_src, _length / 2) - ta.ema(_src, _length), math.round(math.sqrt(_length)))
THMA(_src, _length) => ta.wma(ta.wma(_src,_length / 3) * 3 - ta.wma(_src, _length / 2) - ta.wma(_src, _length), _length)
tema(sec, length)=>
tema1= ta.ema(sec, length)
tema2= ta.ema(tema1, length)
tema3= ta.ema(tema2, length)
tema_r = 3*tema1-3*tema2+tema3
donchian(len) => math.avg(ta.lowest(len), ta.highest(len))
ATR_func(_src, _len)=>
atrLow = low - ta.atr(_len)
trailAtrLow = atrLow
trailAtrLow := na(trailAtrLow[1]) ? trailAtrLow : atrLow >= trailAtrLow[1] ? atrLow : trailAtrLow[1]
supportHit = _src <= trailAtrLow
trailAtrLow := supportHit ? atrLow : trailAtrLow
trailAtrLow
f_dema(src, len)=>
EMA1 = ta.ema(src, len)
EMA2 = ta.ema(EMA1, len)
DEMA = (2*EMA1)-EMA2
f_zlema(src, period) =>
lag = math.round((period - 1) / 2)
ema_data = src + (src - src[lag])
zl= ta.ema(ema_data, period)
f_kalman_filter(src) =>
float value1= na
float value2 = na
value1 := 0.2 * (src - src[1]) + 0.8 * nz(value1[1])
value2 := 0.1 * (ta.tr) + 0.8 * nz(value2[1])
lambda = math.abs(value1 / value2)
alpha = (-math.pow(lambda, 2) + math.sqrt(math.pow(lambda, 4) + 16 * math.pow(lambda, 2)))/8
value3 = float(na)
value3 := alpha * src + (1 - alpha) * nz(value3[1])
//SWITCH
ma_func(modeSwitch, src, len, use_k_f=true) =>
modeSwitch == "SMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.sma(src, len)) : ta.sma(src, len) :
modeSwitch == "RMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.rma(src, len)) : ta.rma(src, len) :
modeSwitch == "EMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.ema(src, len)) : ta.ema(src, len) :
modeSwitch == "TEMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(tema(src, len)) : tema(src, len):
modeSwitch == "DEMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(f_dema(src, len)) : f_dema(src, len):
modeSwitch == "ZLEMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(f_zlema(src, len)) : f_zlema(src, len):
modeSwitch == "WMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.wma(src, len)) : ta.wma(src, len):
modeSwitch == "VWMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.vwma(src, len)) : ta.vwma(src, len):
modeSwitch == "Hma" ? use_kalman_filter and use_k_f ? f_kalman_filter(HMA(src, len)) : HMA(src, len):
modeSwitch == "Ehma" ? use_kalman_filter and use_k_f ? f_kalman_filter(EHMA(src, len)) : EHMA(src, len):
modeSwitch == "Thma" ? use_kalman_filter and use_k_f ? f_kalman_filter(THMA(src, len/2)) : THMA(src, len/2):
modeSwitch == "ATR" ? use_kalman_filter and use_k_f ? f_kalman_filter(ATR_func(src, len)): ATR_func(src, len) :
modeSwitch == "L" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.lowest(len)): ta.lowest(len) :
modeSwitch == "H" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.highest(len)): ta.highest(len) :
modeSwitch == "DMA" ? donchian(len) : na
//Var
sum = 0.0
maopening = 0.0
maclosing = 0.0
os = maopeningsrc
cs = maclosingsrc
pos = strategy.position_size
p = 0.0
p := pos == 0 ? (strategy.equity / 100) / close : p[1]
truetime = true
loss = 0.0
maxloss = 0.0
equity = 0.0
//MA Opening
maopening := ma_func(maopeningtyp, maopeningsrc, maopeninglen)
//MA Closing
maclosing := ma_func(maclosingtyp, maclosingsrc, maclosinglen) * maclosingmul
long1 = long1on == false ? 0 : long1shift == 0 ? 0 : long1lot == 0 ? 0 : maopening == 0 ? 0 : maopening * long1shift
short1 = short1on == false ? 0 : short1shift == 0 ? 0 : short1lot == 0 ? 0 : maopening == 0 ? 0 : maopening * short1shift
//Colors
maopeningcol = maopening == 0 ? na : color.blue
maclosingcol = maclosing == 0 ? na : color.fuchsia
long1col = long1 == 0 ? na : color.green
short1col = short1 == 0 ? na : color.red
//Lines
plot(maopening, offset = OFFS, color = maopeningcol)
plot(maclosing, offset = OFFS, color = maclosingcol)
long1line = long1 == 0 ? close : long1
short1line = short1 == 0 ? close : short1
plot(long1line, offset = OFFS, color = long1col)
plot(short1line, offset = OFFS, color = short1col)
//Lots
lotlong1 = p * long1lot
lotshort1 = p * short1lot
//Entry
if maopening > 0 and maclosing > 0 and truetime
//Long
sum := 0
strategy.entry("L", strategy.long, lotlong1, limit = on_close ? na : long1, when = long1 > 0 and pos <= sum and (on_close ? close <= long1[trade_offset] : true))
sum := lotlong1
//Short
sum := 0
pos := -1 * pos
strategy.entry("S", strategy.short, lotshort1, limit = on_close ? na : short1, when = short1 > 0 and pos <= sum and (on_close ? close >= short1[trade_offset] : true))
sum := lotshort1
strategy.exit("Exit", na, limit = maclosing)
if time > finalTime
strategy.close_all()