Estrategia de trading cuantitativo que combina el promedio móvil de múltiples marcos temporales y el tiempo de trading
ChaoZhang
Descripción general
Esta estrategia utiliza una variedad de indicadores de medias móviles, en combinación con el tiempo de negociación para elegir el momento de entrada y salida, para lograr una negociación cuantitativa.
Principio de estrategia
La estrategia utiliza 9 tipos de promedios móviles, incluidos SMA, EMA, WMA, etc. De acuerdo con la elección del usuario, al entrar en una posición múltiple, el precio de cierre se coloca sobre el promedio móvil seleccionado y el precio de cierre de la línea K anterior está por debajo del promedio móvil; cuando hay un espacio, el precio de cierre se coloca debajo del promedio móvil seleccionado y el precio de cierre de la línea K anterior está por encima del promedio móvil. Todas las operaciones se emiten solo cuando se abre el lunes.
Análisis de las ventajas
Este conjunto de estrategias se compone de una variedad de promedios móviles, que permiten a los usuarios elegir diferentes parámetros para adaptarse a diferentes entornos del mercado.‘Porcentaje de transacciones fallidas’Al mismo tiempo, esta estrategia solo abre posiciones el lunes y detiene la pérdida o el cierre antes del domingo, lo que limita el número máximo de posiciones abiertas en una semana y controla el riesgo de negociación.
Análisis de riesgos
La estrategia se basa en el indicador de la línea de paridad para determinar la tendencia, y existe el riesgo de que parte de la operación se encuentre bloqueada cuando la tendencia se invierta. Además, solo se puede abrir una posición el lunes y no se puede ingresar si se presentan mejores oportunidades de negociación después del lunes, lo que puede perder parte de las ganancias.
Para controlar estos riesgos, se recomienda la adopción de parámetros de promedio móvil dinámico, que se acortan adecuadamente cuando el mercado entra en la oscilación; al mismo tiempo, también se puede aumentar el tiempo de apertura de posiciones y se permite abrir nuevas posiciones el miércoles o el jueves.
Dirección de optimización
La estrategia puede ser optimizada en los siguientes aspectos:
El algoritmo Algerism para el ajuste dinámico de los puntos de parada de pérdidas.
Aumentar la capacidad de los modelos de aprendizaje automático para evaluar tendencias y evitar entrar en mercados convulsionados.
Optimización de la lógica de apertura de posición y paz de posición, permitiendo más oportunidades de apertura de posición.
Resumir
Esta estrategia integra varios indicadores de medias móviles para determinar la dirección de la tendencia y controla eficazmente el número máximo de operaciones en una semana al abrir posiciones el lunes y cerrar posiciones el domingo. Al mismo tiempo, las estrictas reglas de stop-loss también limitan la pérdida máxima de una sola operación. En conjunto, esta estrategia está diseñada para optimizar la tendencia y controlar el riesgo.
/*backtest
start: 2023-12-01 00:00:00
end: 2023-12-31 23:59:59
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © exlux99
//@version=5
strategy('Time MA strategy ', overlay=true)
longEntry = input.bool(true, group="Type of Entries")
shortEntry = input.bool(false, group="Type of Entries")
//==========DEMA
getDEMA(src, len) =>
dema = 2 * ta.ema(src, len) - ta.ema(ta.ema(src, len), len)
dema
//==========HMA
getHULLMA(src, len) =>
hullma = ta.wma(2 * ta.wma(src, len / 2) - ta.wma(src, len), math.round(math.sqrt(len)))
hullma
//==========KAMA
getKAMA(src, len, k1, k2) =>
change = math.abs(ta.change(src, len))
volatility = math.sum(math.abs(ta.change(src)), len)
efficiency_ratio = volatility != 0 ? change / volatility : 0
kama = 0.0
fast = 2 / (k1 + 1)
slow = 2 / (k2 + 1)
smooth_const = math.pow(efficiency_ratio * (fast - slow) + slow, 2)
kama := nz(kama[1]) + smooth_const * (src - nz(kama[1]))
kama
//==========TEMA
getTEMA(src, len) =>
e = ta.ema(src, len)
tema = 3 * (e - ta.ema(e, len)) + ta.ema(ta.ema(e, len), len)
tema
//==========ZLEMA
getZLEMA(src, len) =>
zlemalag_1 = (len - 1) / 2
zlemadata_1 = src + src - src[zlemalag_1]
zlema = ta.ema(zlemadata_1, len)
zlema
//==========FRAMA
getFRAMA(src, len) =>
Price = src
N = len
if N % 2 != 0
N := N + 1
N
N1 = 0.0
N2 = 0.0
N3 = 0.0
HH = 0.0
LL = 0.0
Dimen = 0.0
alpha = 0.0
Filt = 0.0
N3 := (ta.highest(N) - ta.lowest(N)) / N
HH := ta.highest(N / 2 - 1)
LL := ta.lowest(N / 2 - 1)
N1 := (HH - LL) / (N / 2)
HH := high[N / 2]
LL := low[N / 2]
for i = N / 2 to N - 1 by 1
if high[i] > HH
HH := high[i]
HH
if low[i] < LL
LL := low[i]
LL
N2 := (HH - LL) / (N / 2)
if N1 > 0 and N2 > 0 and N3 > 0
Dimen := (math.log(N1 + N2) - math.log(N3)) / math.log(2)
Dimen
alpha := math.exp(-4.6 * (Dimen - 1))
if alpha < .01
alpha := .01
alpha
if alpha > 1
alpha := 1
alpha
Filt := alpha * Price + (1 - alpha) * nz(Filt[1], 1)
if bar_index < N + 1
Filt := Price
Filt
Filt
//==========VIDYA
getVIDYA(src, len) =>
mom = ta.change(src)
upSum = math.sum(math.max(mom, 0), len)
downSum = math.sum(-math.min(mom, 0), len)
out = (upSum - downSum) / (upSum + downSum)
cmo = math.abs(out)
alpha = 2 / (len + 1)
vidya = 0.0
vidya := src * alpha * cmo + nz(vidya[1]) * (1 - alpha * cmo)
vidya
//==========JMA
getJMA(src, len, power, phase) =>
phase_ratio = phase < -100 ? 0.5 : phase > 100 ? 2.5 : phase / 100 + 1.5
beta = 0.45 * (len - 1) / (0.45 * (len - 1) + 2)
alpha = math.pow(beta, power)
MA1 = 0.0
Det0 = 0.0
MA2 = 0.0
Det1 = 0.0
JMA = 0.0
MA1 := (1 - alpha) * src + alpha * nz(MA1[1])
Det0 := (src - MA1) * (1 - beta) + beta * nz(Det0[1])
MA2 := MA1 + phase_ratio * Det0
Det1 := (MA2 - nz(JMA[1])) * math.pow(1 - alpha, 2) + math.pow(alpha, 2) * nz(Det1[1])
JMA := nz(JMA[1]) + Det1
JMA
//==========T3
getT3(src, len, vFactor) =>
ema1 = ta.ema(src, len)
ema2 = ta.ema(ema1, len)
ema3 = ta.ema(ema2, len)
ema4 = ta.ema(ema3, len)
ema5 = ta.ema(ema4, len)
ema6 = ta.ema(ema5, len)
c1 = -1 * math.pow(vFactor, 3)
c2 = 3 * math.pow(vFactor, 2) + 3 * math.pow(vFactor, 3)
c3 = -6 * math.pow(vFactor, 2) - 3 * vFactor - 3 * math.pow(vFactor, 3)
c4 = 1 + 3 * vFactor + math.pow(vFactor, 3) + 3 * math.pow(vFactor, 2)
T3 = c1 * ema6 + c2 * ema5 + c3 * ema4 + c4 * ema3
T3
//==========TRIMA
getTRIMA(src, len) =>
N = len + 1
Nm = math.round(N / 2)
TRIMA = ta.sma(ta.sma(src, Nm), Nm)
TRIMA
src = input.source(close, title='Source', group='Parameters')
len = input.int(17, minval=1, title='Moving Averages', group='Parameters')
out_ma_source = input.string(title='MA Type', defval='ALMA', options=['SMA', 'EMA', 'WMA', 'ALMA', 'SMMA', 'LSMA', 'VWMA', 'DEMA', 'HULL', 'KAMA', 'FRAMA', 'VIDYA', 'JMA', 'TEMA', 'ZLEMA', 'T3', 'TRIM'], group='Parameters')
out_ma = out_ma_source == 'SMA' ? ta.sma(src, len) : out_ma_source == 'EMA' ? ta.ema(src, len) : out_ma_source == 'WMA' ? ta.wma(src, len) : out_ma_source == 'ALMA' ? ta.alma(src, len, 0.85, 6) : out_ma_source == 'SMMA' ? ta.rma(src, len) : out_ma_source == 'LSMA' ? ta.linreg(src, len, 0) : out_ma_source == 'VWMA' ? ta.vwma(src, len) : out_ma_source == 'DEMA' ? getDEMA(src, len) : out_ma_source == 'HULL' ? ta.hma(src, len) : out_ma_source == 'KAMA' ? getKAMA(src, len, 2, 30) : out_ma_source == 'FRAMA' ? getFRAMA(src, len) : out_ma_source == 'VIDYA' ? getVIDYA(src, len) : out_ma_source == 'JMA' ? getJMA(src, len, 2, 50) : out_ma_source == 'TEMA' ? getTEMA(src, len) : out_ma_source == 'ZLEMA' ? getZLEMA(src, len) : out_ma_source == 'T3' ? getT3(src, len, 0.7) : out_ma_source == 'TRIM' ? getTRIMA(src, len) : na
plot(out_ma)
long = close> out_ma and close[1] < out_ma and dayofweek==dayofweek.monday
short = close< out_ma and close[1] > out_ma and dayofweek==dayofweek.monday
stopPer = input.float(10.0, title='LONG Stop Loss % ', group='Fixed Risk Management') / 100
takePer = input.float(30.0, title='LONG Take Profit %', group='Fixed Risk Management') / 100
stopPerShort = input.float(5.0, title='SHORT Stop Loss % ', group='Fixed Risk Management') / 100
takePerShort = input.float(10.0, title='SHORT Take Profit %', group='Fixed Risk Management') / 100
longStop = strategy.position_avg_price * (1 - stopPer)
longTake = strategy.position_avg_price * (1 + takePer)
shortStop = strategy.position_avg_price * (1 + stopPerShort)
shortTake = strategy.position_avg_price * (1 - takePerShort)
// strategy.risk.max_intraday_filled_orders(2) // After 10 orders are filled, no more strategy orders will be placed (except for a market order to exit current open market position, if there is any).
if(longEntry)
strategy.entry("long",strategy.long,when=long )
strategy.exit('LONG EXIT', "long", limit=longTake, stop=longStop)
strategy.close("long",when=dayofweek==dayofweek.sunday)
if(shortEntry)
strategy.entry("short",strategy.short,when=short )
strategy.exit('SHORT EXIT', "short", limit=shortTake, stop=shortStop)
strategy.close("short",when=dayofweek==dayofweek.sunday)