Estrategia de seguimiento de tendencias del canal de gravedad central
ChaoZhang
Descripción general
La estrategia combina el indicador de centro de gravedad y el indicador de canal SSL para permitir el juicio y el seguimiento de brechas en las tendencias de los precios, perteneciendo a la estrategia de seguimiento de tendencias. Al mismo tiempo, combina el stop loss ATR dinámico para controlar el riesgo.
Principio de estrategia
Indicador de gravedad de centro de cálculo, en el que el tren superior y el tren inferior son los límites de tendencia de los precios al alza y a la baja, respectivamente.
Calcular el indicador del canal SSL, el interior del canal es el intervalo de convergencia, el exterior del canal es la dirección de la tendencia.
Cuando el precio rompe la vía o el canal, se juzga como una tendencia alcista y se hace más; cuando el precio rompe la vía o el canal, se juzga como una tendencia descendente y se hace vacío.
El ATR dinámico se utiliza para rastrear los paros y evitar la expansión de las pérdidas durante el mantenimiento de la posición.
La combinación de los períodos de tiempo de retroalimentación para generar una señal de negociación real.
La estrategia utiliza dos indicadores para determinar la dirección de la tendencia al mismo tiempo, uno para determinar la ruptura y otro para confirmar la tendencia, la combinación de los dos puede mejorar la precisión del juicio. El stop loss dinámico puede ajustar el stop loss en función de la amplitud de las fluctuaciones del mercado, y es un medio de control de riesgo muy práctico.
Análisis de las ventajas
El uso simultáneo de dos indicadores para determinar tendencias puede mejorar la precisión.
El indicador de gravedad central es sensible a los cambios de tendencia, y el canal SSL determina la dirección de la tendencia.
El stop ATR dinámico es flexible y se ajusta en tiempo real a las fluctuaciones del mercado.
Las reglas de la estrategia son sencillas, claras, fáciles de entender e implementar.
El espacio para la optimización de los parámetros es amplio y se puede ajustar para diferentes mercados.
La detección está completa para verificar el efecto de la estrategia.
Análisis de riesgos
El indicador de centrífuga y el canal SSL pueden fallar, lo que lleva a una señal de transacción errónea. Se pueden agregar otros indicadores para confirmar.
El stop-loss dinámico puede ser demasiado radical y se puede relajar la amplitud de stop-loss adecuadamente.
La elección incorrecta de los períodos de retrospectiva puede conducir a una estrategia ineficaz, que requiere retrospectiva para diferentes fases del mercado.
Se debe tener en cuenta el impacto de los costos de las transacciones.
Dirección de optimización
Prueba diferentes combinaciones de parámetros para encontrar el mejor par de ellos.
Optimización de los parámetros ATR y multiplicadores de los ciclos de pérdidas dinámicas.
Introduzca otros indicadores para filtrar la señal, como MACD, KDJ, etc.
Añadir modelos de aprendizaje automático para ayudar a determinar la dirección de las tendencias.
Optimización de la gestión de fondos y control de posiciones.
Ajuste y optimización de parámetros para variedades específicas.
Resumir
La estrategia combina indicadores de centro de gravedad y indicadores de canal SSL para juzgar la tendencia, el uso de ATR dinámico para controlar el riesgo de pérdidas, es una estrategia de seguimiento de tendencias viable. Se puede mejorar aún más la estabilidad de la estrategia y la eficacia en el campo de batalla mediante la optimización de los parámetros, la introducción de otros indicadores y el aprendizaje automático. En general, la estrategia tiene una gran utilidad y escalabilidad, es una idea de estrategia que vale la pena consultar para la cuantificación de las transacciones.
/*backtest
start: 2023-08-19 00:00:00
end: 2023-09-13 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
// Thanks to HPotter for the original code for Center of Gravity Backtest
strategy("CoG SSL BF 🚀", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)
/////////////// Time Frame ///////////////
_0 = input(false, "════════ Test Period ═══════")
testStartYear = input(2017, "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
/////////////// SSL Channels ///////////////
_1 = input(false, "═════════ SSL ══════════")
len1=input(title="SMA Length 1", defval=12)
len2=input(title="SMA Length 2", defval=13)
smaHigh = sma(high, len1)
smaLow = sma(low, len2)
Hlv = 0
Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? smaHigh : smaLow
sslUp = Hlv < 0 ? smaLow : smaHigh
///////////// Center of Gravity /////////////
_2 = input(false, "═════════ CoG ══════════")
Length = input(25, minval=1)
m = input(5, minval=0)
Percent = input(6, minval=0, title="COG %")
xLG = linreg(close, Length, m)
xLG1r = xLG + ((close * Percent) / 100)
xLG1s = xLG - ((close * Percent) / 100)
pos = 0.0
pos := iff(close > xLG1r, 1, iff(close < xLG1s, -1, nz(pos[1], 0)))
possig = iff(pos == 1, 1, iff(pos == -1, -1, pos))
///////////// Rate Of Change /////////////
_3 = input(false, "══════ Rate of Change ══════")
source = close
roclength = input(2, "ROC Length", minval=1)
pcntChange = input(10, "ROC % Change", minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Srategy ///////////////
long = possig == 1 or (sslUp > sslDown and isMoving())
short = possig == -1 or (sslUp < sslDown 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])
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
/////////////// Dynamic ATR Stop Losses ///////////////
_4 = input(false, "════════ Stop Loss ═══════")
atrLkb = input(1, minval=1, title='ATR Stop Period')
atrMult = input(2, step=0.25, title='ATR Stop Multiplier')
atr1 = atr(atrLkb)
longStop = 0.0
longStop := short_signal ? na : long_signal ? close - (atr1 * atrMult) : longStop[1]
shortStop = 0.0
shortStop := long_signal ? na : short_signal ? close + (atr1 * atrMult) : shortStop[1]
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("L", strategy.long, when=long)
strategy.entry("S", strategy.short, when=short)
strategy.exit("L SL", "L", stop=longStop, when=since_longEntry > 0)
strategy.exit("S SL", "S", stop=shortStop, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
p1 = plot(sslDown, linewidth = 1, color=color.red, title="SSL down")
p2 = plot(sslUp, linewidth = 1, color=color.lime, title="SSL up")
fill(p1, p2, color = not isMoving() ? color.white : sslDown < sslUp ? color.lime : color.red, transp=80)
plot(xLG1r, color=color.lime, title="LG1r")
plot(xLG1s, color=color.red, title="LG1s")
plot(strategy.position_size <= 0 ? na : longStop, title="Long Stop Loss", color=color.yellow, style=plot.style_circles, linewidth=1)
plot(strategy.position_size >= 0 ? na : shortStop, title="Short Stop Loss", color=color.orange, style=plot.style_circles, linewidth=1)
bgcolor(long ? color.green : short ? color.red : not isMoving() ? color.white : na, transp=80)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=60)