Estrategia de inversión de doble vía
ChaoZhang
Descripción general
La estrategia de reversión de seguimiento de dos vías es una estrategia de reversión de negociación que combina el cinturón de Brin, el canal de Keltner y el indicador de movimiento. La estrategia identifica el momento en que el precio entra en la zona de compresión mediante el juicio integral del cinturón de Brin y el canal de Keltner; al mismo tiempo, combina el indicador de movimiento para determinar la señal de reversión del precio y formar la entrada y salida de la operación.
Principio de estrategia
Cálculo de las vías media, media alta y media baja en la banda de Bryn
- El SMA de la vía central es cerrado
- La línea ascendente y descendente es la diferencia estándar de la línea media más un múltiplo ajustable
Cálculo de las vías media, superior y inferior en el canal Keltner
- El SMA de la vía central es cerrado
- La vía ascendente y descendente es la vía media más el ATR menos un múltiplo ajustable
Determinar si el cinturón de Brin está dentro del canal Keltner
- Cuando la banda de Brin está en la vía inferior a la de Keltner y la banda de Brin está en la vía inferior a la de Keltner, se considera que está en compresión
- En cambio, no se comprimen.
Calcula la inclinación de regreso lineal de close con el punto medio de la banda de Bryn y el canal de Keltner
- val > 0 indica que el cierre está subiendo, val < 0 indica que el cierre está bajando
Calcular la variación de la ROC de un cercano y su EMA
- Determinar si el cambio alcanza un umbral ajustable
- Si se supera el umbral, se considera que está en la tendencia
En la compresión, cuando val > 0 y el índice de variación alcanza un umbral
- En vez de hacer vacío
Configuración de las condiciones de detener y detener
Ventajas estratégicas
Combinado con un sistema de dos vías para mejorar la precisión en la determinación del punto de inflexión
Aumentar la regresión lineal y el juicio de la tasa de cambio para evitar falsas señales de inversión
Ajustable configuración de parámetros flexible y se puede optimizar para diferentes variedades
El uso de una estrategia de stop loss para controlar el riesgo de una sola operación
El análisis de datos es suficiente para comprobar la eficacia de la estrategia.
Riesgos estratégicos y soluciones
La compresión de dos vías no necesariamente produce una inversión efectiva
- Parámetros de optimización, condiciones de compresión de dos vías estrictas
La brecha falsa produce una señal errónea
- Aumentar la determinación de la regresión lineal para determinar la dirección de la tendencia
La suspensión de pérdidas es demasiado flexible, la pérdida es demasiado grande.
- Optimización de los puntos de parada y control estricto de las pérdidas individuales
Periodo de prueba Datenichinhalt
- Aumentar el número de ciclos de prueba para comprobar la eficacia a largo plazo
Dirección de optimización de la estrategia
Optimización de la configuración de los parámetros para adaptarse a más variedades
Los puntos clave de resistencia para el aumento del juicio de aprendizaje automático
Mejora de la autenticidad de las brechas en combinación con cambios en el volumen de transacciones
Aumentar el análisis a través de períodos de tiempo para determinar la continuidad de las tendencias
Optimización de las estrategias de stop loss y seguimiento dinámico
Resumir
La estrategia de retroceso de seguimiento de dos vías es en general una estrategia de retroceso que utiliza indicadores como el canal de Keltner con el cinturón de Brin. La estrategia se puede adaptar a diferentes variedades a través de la optimización de parámetros y, hasta cierto punto, identificar la veracidad de los avances.
/*backtest
start: 2023-10-02 00:00:00
end: 2023-11-01 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
// Credit for the initial Squeeze Momentum code to LazyBear, rate of change code is from Kiasaki
strategy("Squeeze X BF 🚀", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.0)
/////////////// Time Frame ///////////////
testStartYear = input(2012, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)
testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)
testPeriod() => true
/////////////// Squeeeeze ///////////////
length = input(20, title="BB Length")
mult = input(2.0,title="BB MultFactor")
lengthKC=input(22, title="KC Length")
multKC = input(1.5, title="KC MultFactor")
useTrueRange = input(true, title="Use TrueRange (KC)")
// Calculate BB
source = close
basis = sma(source, length)
dev = mult * stdev(source, length)
upperBB = basis + dev
lowerBB = basis - dev
// Calculate KC
ma = sma(source, lengthKC)
range = useTrueRange ? tr : (high - low)
rangema = sma(range, lengthKC)
upperKC = ma + rangema * multKC
lowerKC = ma - rangema * multKC
sqzOn = (lowerBB > lowerKC) and (upperBB < upperKC)
sqzOff = (lowerBB < lowerKC) and (upperBB > upperKC)
noSqz = (sqzOn == false) and (sqzOff == false)
val = linreg(source - avg(avg(highest(high, lengthKC), lowest(low, lengthKC)),sma(close,lengthKC)), lengthKC,0)
///////////// Rate Of Change /////////////
roclength = input(30, minval=1), pcntChange = input(7, minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Strategy ///////////////
long = val > 0 and isMoving()
short = val < 0 and isMoving()
last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
sl_inp = input(100.0, title='Stop Loss %') / 100
tp_inp = input(5000.0, title='Take Profit %') / 100
take_level_l = strategy.position_avg_price * (1 + tp_inp)
take_level_s = strategy.position_avg_price * (1 - tp_inp)
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("Long", strategy.long, when=long)
strategy.entry("Short", strategy.short, when=short)
strategy.exit("Long Ex", "Long", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
strategy.exit("Short Ex", "Short", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
bcolor = iff(val > 0, iff(val > nz(val[1]), color.lime, color.green), iff(val < nz(val[1]), color.red, color.maroon))
plot(val, color=bcolor, linewidth=4)
bgcolor(not isMoving() ? color.white : long ? color.lime : short ? color.red : na, transp=70)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=50)
hline(0, color = color.white)