En la carga de los recursos... Cargando...

Estrategia de cruce de promedio móvil de varios marcos de tiempo

El autor:¿ Qué pasa?, Fecha: 2024-02-19 15:41:29
Las etiquetas:

Resumen general

La estrategia de cruce de promedios móviles de varios marcos de tiempo es una estrategia de negociación algorítmica que utiliza señales de cruce de promedios móviles entre diferentes períodos de tiempo para determinar la dirección de tendencia.

Estrategia lógica

Esta estrategia calcula el indicador CCI durante diferentes períodos para determinar la dirección de la tendencia del mercado, combinado con las señales MACD para localizar cruces doradas y cruces de muerte, y finalmente utiliza el indicador ATR para establecer los niveles de stop loss/take profit, con el fin de comprar bajo y vender alto.

Específicamente, primero calcula el CCI de 20 períodos para juzgar las tendencias alcistas o bajistas. Luego verifica si las líneas MACD se cruzan para identificar las señales comerciales. Luego, ATR se utiliza para generar trailing stops para bloquear las ganancias. Finalmente, todas las señales se consolidan para generar las señales de entrada y salida.

Ventajas

La combinación de múltiples indicadores mejora la precisión de la señal

La combinación de CCI, MACD y ATR mejora la fiabilidad de las señales de negociación al juzgar colectivamente la tendencia, el impulso y la volatilidad.
El análisis de múltiples marcos de tiempo capta el ritmo del mercado

El CCI de período más largo capta la tendencia general, mientras que el MACD de mayor frecuencia localiza los puntos de inflexión locales, lo que permite a la estrategia capitalizar las grandes oscilaciones del mercado.
Los controles de detención trasera del ATR corren riesgos de manera efectiva

El stop loss basado en ATR puede adaptarse a la volatilidad del mercado, mientras que su característica de seguimiento bloquea aún más las ganancias a medida que el mercado se mueve favorablemente.

Los riesgos

Espacio de optimización limitado

La mayoría de los parámetros tienen un espacio de ajuste estrecho, alcanzando fácilmente un cuello de botella de rendimiento.
Aumento de la carga informática

Múltiples indicadores que se ejecutan juntos pueden aumentar la carga informática, causando retrasos en el comercio de alta frecuencia.
Señales frecuentes, control de riesgos limitado

Las señales pueden ser frecuentes, mientras que el control de riesgos se basa principalmente en el ATR trailing stop, que tiene limitaciones contra movimientos extremos.

Mejoras

Aplicar el aprendizaje automático para un ajuste de parámetros más eficiente

La optimización bayesiana, los algoritmos genéticos, etc. pueden permitir un ajuste de parámetros más inteligente y eficiente.
Añadir indicadores funcionales para mejorar la adaptabilidad

Incorporar otros indicadores como la volatilidad, el volumen, el sentimiento puede hacer que la estrategia sea más robusta y flexible.
Fortalecer la gestión de riesgos para una mayor estabilidad

Se pueden diseñar reglas de stop loss más científicas, y otros módulos como el dimensionamiento de la posición pueden ayudar a proteger contra eventos extremos.

Conclusión

La estrategia de cruce de promedios móviles de múltiples plazos utiliza los poderes del CCI, MACD y ATR para lograr una captura de tendencias confiable y un control de riesgos eficiente. Tiene en cuenta la tendencia, el impulso y la volatilidad para generar señales precisas, comprender los ritmos del mercado y gestionar el riesgo. Aunque algunos aspectos como la puesta a punto de parámetros, la carga de computación y el control de riesgos pueden mejorarse aún más, es un sistema de negociación algorítmico sólido.

/*backtest
start: 2024-01-01 00:00:00
end: 2024-01-31 23:59:59
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=5
strategy('smplondonclinic Strategy', shorttitle='SMPLC Strategy', overlay=true, pyramiding = 0, process_orders_on_close = true, default_qty_type = strategy.percent_of_equity, default_qty_value = 100)

direction   = input.string(title='Entry Direction', defval='Long', options=['Long', 'Short', 'Both'],group = "Strategy Entry Direction")

TPPerc = input.float(title='Take Profit (%)', minval=0.0, step=0.1, defval=0.5, group='Strategy TP & SL')
SLPerc = input.float(title='Stop Loss (%)', minval=0.0, step=0.1, defval=0.5, group='Strategy TP & SL')

period = input(20, 'CCI period',group = "TREND MAGIC")
coeff = input(1, 'ATR Multiplier',group = "TREND MAGIC")
AP = input(5, 'ATR Period',group = "TREND MAGIC")
ATR = ta.sma(ta.tr, AP)
srctm = close
upT = low - ATR * coeff
downT = high + ATR * coeff
MagicTrend = 0.0
MagicTrend := ta.cci(srctm, period) >= 0 ? upT < nz(MagicTrend[1]) ? nz(MagicTrend[1]) : upT : downT > nz(MagicTrend[1]) ? nz(MagicTrend[1]) : downT
color1 = ta.cci(srctm, period) >= 0 ? #0022FC : #FC0400
plot(MagicTrend, color=color1, linewidth=3)
tmb = ta.cci(srctm, period) >= 0 and close>MagicTrend
tms = ta.cci(srctm, period) <= 0 and close<MagicTrend

//MACD

res           = input.timeframe("",  "Indicator TimeFrame", group = "MACD")
fast_length   = input.int(title="Fast Length", defval=12, group = "MACD")
slow_length   = input.int(title="Slow Length", defval=26, group = "MACD")
src           = input.source(title="Source", defval=close, group = "MACD")
signal_length = input.int(title="Signal Smoothing", minval = 1, maxval = 999, defval = 9, group = "MACD")
sma_source    = input.string(title="Oscillator MA Type", defval="EMA", options=["SMA", "EMA"], group = "MACD")
sma_signal    = input.string(title="Signal Line MA Type", defval="EMA", options=["SMA", "EMA"], group = "MACD")

fast_ma = request.security(syminfo.tickerid, res, sma_source == "SMA" ? ta.sma(src, fast_length) : ta.ema(src, fast_length))
slow_ma = request.security(syminfo.tickerid, res, sma_source == "SMA" ? ta.sma(src, slow_length) : ta.ema(src, slow_length))
macd = fast_ma - slow_ma
signal = request.security(syminfo.tickerid, res, sma_signal == "SMA" ? ta.sma(macd, signal_length) : ta.ema(macd, signal_length))
hist = macd - signal

trend_up   = macd > signal
trend_dn   = macd < signal
cross_UP   = signal[1] >= macd[1] and signal < macd
cross_DN   = signal[1] <= macd[1] and signal > macd
cross_UP_A = (signal[1] >= macd[1] and signal < macd) and macd > 0
cross_DN_B = (signal[1] <= macd[1] and signal > macd) and macd < 0


//UT Bot

srcut = close
showut = input.bool(false, 'Show UT Bot Labels', group = "UT BOT")
keyvalue = input.float(2, title='Key Vaule. \'This changes the sensitivity\'', step=.5, group = "UT BOT")
atrperiod = input(7, title='ATR Period', group = "UT BOT")
xATR = ta.atr(atrperiod)
nLoss = keyvalue * xATR

xATRTrailingStop = 0.0
iff_1 = srcut > nz(xATRTrailingStop[1], 0) ? srcut - nLoss : srcut + nLoss
iff_2 = srcut < nz(xATRTrailingStop[1], 0) and srcut[1] < nz(xATRTrailingStop[1], 0) ? math.min(nz(xATRTrailingStop[1]), srcut + nLoss) : iff_1
xATRTrailingStop := srcut > nz(xATRTrailingStop[1], 0) and srcut[1] > nz(xATRTrailingStop[1], 0) ? math.max(nz(xATRTrailingStop[1]), srcut - nLoss) : iff_2

pos = 0
iff_3 = srcut[1] > nz(xATRTrailingStop[1], 0) and srcut < nz(xATRTrailingStop[1], 0) ? -1 : nz(pos[1], 0)
pos := srcut[1] < nz(xATRTrailingStop[1], 0) and srcut > nz(xATRTrailingStop[1], 0) ? 1 : iff_3

xcolor = pos == -1 ? color.red : pos == 1 ? color.green : color.blue

//plot(xATR, color=xcolor, title='Trailing Stop')
buy = ta.crossover(srcut, xATRTrailingStop)
sell = ta.crossunder(srcut, xATRTrailingStop)
barcolor = srcut > xATRTrailingStop

plotshape(showut ? buy:na, title='Buy', text='Buy', style=shape.labelup, location=location.belowbar, color=color.new(color.green, 0), textcolor=color.new(color.white, 0), size=size.tiny)
plotshape(showut ? sell:na, title='Sell', text='Sell', style=shape.labeldown, color=color.new(color.red, 0), textcolor=color.new(color.white, 0), size=size.tiny)

//barcolor(barcolor ? color.green : color.red)

goLong = buy and tmb and cross_UP
goShort = sell and tms and cross_DN

plotshape(goLong, location=location.bottom, style=shape.triangleup, color=color.lime, size=size.small)
plotshape(goShort, location=location.top, style=shape.triangledown, color=color.red, size=size.small)

percentAsPoints(pcnt) =>
    strategy.position_size != 0 ? math.round(pcnt / 100.0 * strategy.position_avg_price / syminfo.mintick) : float(na)

percentAsPrice(pcnt) =>
    strategy.position_size != 0 ? (pcnt / 100.0 + 1.0) * strategy.position_avg_price : float(na)

current_position_size = math.abs(strategy.position_size)
initial_position_size = math.abs(ta.valuewhen(strategy.position_size[1] == 0.0, strategy.position_size, 0))

TP = strategy.position_avg_price + percentAsPoints(TPPerc) * syminfo.mintick * strategy.position_size / math.abs(strategy.position_size)
SL = strategy.position_avg_price - percentAsPoints(SLPerc) * syminfo.mintick * strategy.position_size / math.abs(strategy.position_size)

var long = false
var short = false

if direction == 'Long' 
    long := goLong
    short := false

if direction == 'Short'
    short := goShort
    long := false

if direction == 'Both' 
    long := goLong
    short := goShort

if long and strategy.opentrades == 0
    strategy.entry(id='Long', direction=strategy.long)

if short and strategy.opentrades == 0
    strategy.entry(id='Short', direction=strategy.short)

if strategy.position_size > 0

    strategy.exit('TPSL', from_entry='Long', qty=initial_position_size, limit=TP, stop=SL)

if strategy.position_size < 0

    strategy.exit('TPSL2', from_entry='Short', qty=initial_position_size, limit=TP, stop=SL)

Más.