Estratégia de negociação de reversão de média móvel
ChaoZhang
Visão geral
A estratégia de negociação de retorno à média é uma estratégia de negociação baseada no grau de desvio do preço da média. A estratégia utiliza as características de um desvio do preço da média a curto prazo, para estabelecer posições quando o preço está significativamente abaixo ou acima da média, e para estabelecer um risco de arbitragem quando o preço retorna à média.
Princípio da estratégia
A estratégia primeiro calcula a média móvel de um determinado período, representando a tendência de preços a longo prazo. Em seguida, o tempo e o tamanho da posição são julgados com base no grau de desvio do preço em relação à média móvel.
Quando o preço está abaixo da média móvel em uma certa proporção, representa um desvio do preço da tendência de longo prazo, que é gradualmente estabelecido por uma determinada proporção de posição. Quanto mais o preço se desvia, maior é a posição estabelecida. Quando o preço retorna acima da média móvel, representa o retorno à tendência de longo prazo, que é um equilíbrio de posição em proporção de posição.
Da mesma forma, quando o preço é superior a uma determinada proporção da média móvel, é criada uma posição em branco. Quando o preço cai de volta à média móvel, é eliminado proporcionalmente.
Análise de vantagens
Utilize a capacidade de identificar tendências na linha média para acompanhar a tendência de equilíbrio de longo prazo no preço das ações e entender a direção das principais tendências.
A redução do custo de construção de um estoque, através da construção de posições em lotes, permite obter preços de custo mais favoráveis.
O uso de parada em etapas, com diferentes graus de regresso à linha média, tem diferentes oportunidades de parada, reduzindo o risco.
O controle de posição usa uma parcela fixa para evitar perdas individuais excessivas.
A configuração dos parâmetros é flexível e pode ser ajustada de acordo com a variedade de períodos de média móvel ou proporção de posição.
Análise de Riscos
Pode ocorrer uma perda frequente quando os preços oscilam. A amplitude de perda pode ser relaxada de forma apropriada ou outras condições de filtragem podem ser aplicadas.
As ações fortes podem atravessar diretamente a linha média e continuar subindo ou caindo, sem poder retornar à linha média. Pode ser combinado com um indicador de tendência para determinar a tendência forte e reduzir a posição.
A configuração inadequada dos parâmetros pode levar a posições ou paradas muito radicais. Os parâmetros devem ser cuidadosamente testados e ajustados de acordo com o mercado.
As taxas de transação podem ser mais altas quando as transações são frequentes, e os parâmetros de otimização dos fatores de custo devem ser considerados.
Direção de otimização
Otimizar o ciclo de média móvel para adaptar-se às características de diferentes variedades.
Optimizar a proporção de posição para equilibrar o risco com o lucro.
Adicionar filtros para outros indicadores técnicos, evitando transações desnecessárias.
Combinado com um indicador de volatilidade, ajuste a proporção da posição de acordo com a volatilidade do mercado.
A partir de agora, a empresa vai investir mais em soluções de gestão de risco, como o sistema de amplificação de barras, para reduzir o risco e aumentar a rentabilidade.
Resumir
A estratégia de regresso de equilíbrio aproveita a característica de equilíbrio de equilíbrio das ações, construindo posições quando o preço se desvia da linha de equilíbrio móvel e parando quando o preço retorna, para efetivamente capturar a tendência de longo prazo das ações. Através da otimização de parâmetros e filtragem de indicadores, é capaz de se adaptar às mudanças do mercado e obter melhores retornos sob a premissa de controlar o risco.
/*backtest
start: 2022-10-19 00:00:00
end: 2023-10-25 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("YJ Mean Reversion", overlay=true)
//Was designed firstly to work on an index like the S&P 500 , which over time tends to go up in value.
//Avoid trading too frequently (e.g. Daily, Weekly), to avoid getting eaten by fees.
//If you change the underlying asset, or time frame, tweaking the moving average may be necessary.
//Can work with a starting capital of just $1000, optimise the settings as necessary.
//Accepts floating point values for the amount of units to purchase (e.g. Bitcoin ).
//If price of units exceeds available capital, script will cancel the buy.
//Adjusted the input parameters to be more intuitive.
//input variables
movingAverage = input(title="Moving Average (bars)", type=input.integer, defval=28, minval=1, maxval=1000)
//riskPercentage = input(title="Amount to Risk (%)", type=input.integer, defval=1, minval=1, maxval=50)
deviation = input(title="Deviation Increment (%)", type=input.float, defval=5, minval=0.01, maxval=100) / 100
unitsLevel1 = input(title="Level 1 (units)", type=input.float, defval=1, minval=0.0001, maxval=10000)
unitsLevel2 = input(title="Level 2 (units)", type=input.float, defval=2, minval=0.0001, maxval=10000)
unitsLevel3 = input(title="Level 3 (units)", type=input.float, defval=4, minval=0.0001, maxval=10000)
unitsLevel4 = input(title="Level 4 (units)", type=input.float, defval=8, minval=0.0001, maxval=10000)
unitsLevel5 = input(title="Level 5 (units)", type=input.float, defval=16, minval=0.0001, maxval=10000)
//moving average and ma slope (use on weekly chart)
ma = sma(close, movingAverage)
//sl = ma > ma[4]
//units to buy
//amount = riskPercentage / 100 * (strategy.initial_capital + strategy.netprofit)
//units = floor(amount / close)
//mode 1
//strategy.order("buy", true, 1, when = (close < 0.95 * ma) and (strategy.position_size < 10))
//strategy.order("sell", false, strategy.position_size, when = (close > 1.05 * ma) and (strategy.position_size > 0))
//mode 2
//strategy.order("buy", true, 1, when = close < 0.8 * ma)
//strategy.order("sell", false, strategy.position_size, when = (close > 310) and (strategy.position_size > 0))
//mode 3
//strategy.order("buy", true, 1, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("buy", true, 2, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("buy", true, 4, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("buy", true, 8, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("buy", true, 16, when = (close < 0.75 * ma))
//strategy.order("sell", false, strategy.position_size, when = (close > 310) and (strategy.position_size > 0))
//mode 4
//strategy.order("buy", true, 1, when = (close < 0.98 * ma) and (close > 0.96 * ma) and (sl))
//strategy.order("buy", true, 2, when = (close < 0.96 * ma) and (close > 0.94 * ma) and (sl))
//strategy.order("buy", true, 4, when = (close < 0.94 * ma) and (close > 0.92 * ma) and (sl))
//strategy.order("buy", true, 8, when = (close < 0.92 * ma) and (close > 0.90 * ma) and (sl))
//strategy.order("buy", true, 16, when = (close < 0.90 * ma) and (sl))
//strategy.order("sell", false, strategy.position_size, when = (close > 310) and (strategy.position_size > 0))
//mode 5
//strategy.order("buy", true, 1, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("buy", true, 2, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("buy", true, 4, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("buy", true, 8, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("buy", true, 16, when = (close < 0.75 * ma))
//strategy.order("sell", false, 1, when = (close > 1.05 * ma) and (close < 1.1 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 2, when = (close > 1.1 * ma) and (close < 1.15 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 4, when = (close > 1.15 * ma) and (close < 1.2 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 8, when = (close > 1.2 * ma) and (close < 1.25 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 16, when = (close > 1.25 * ma) and (close < 1.3 * ma) and (strategy.position_size > 0))
//mode 6
//strategy.order("B1", true, unitsLevel1 * units, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("B2", true, unitsLevel2 * units, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("B3", true, unitsLevel3 * units, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("B4", true, unitsLevel4 * units, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("B5", true, unitsLevel5 * units, when = (close < 0.75 * ma))
//strategy.order("S1", false, unitsLevel1 * units, when = (close > 1.05 * ma) and (close < 1.1 * ma) and (strategy.position_size > 0))
//strategy.order("S2", false, unitsLevel2 * units, when = (close > 1.1 * ma) and (close < 1.15 * ma) and (strategy.position_size > 0))
//strategy.order("S3", false, unitsLevel3 * units, when = (close > 1.15 * ma) and (close < 1.2 * ma) and (strategy.position_size > 0))
//strategy.order("S4", false, unitsLevel4 * units, when = (close > 1.2 * ma) and (close < 1.25 * ma) and (strategy.position_size > 0))
//strategy.order("S5", false, unitsLevel5 * units, when = (close > 1.25 * ma) and (close < 1.3 * ma) and (strategy.position_size > 0))
//mode 7
//strategy.order("B1", true, units, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("B2", true, units, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("B3", true, units, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("B4", true, units, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("B5", true, units, when = (close < 0.75 * ma))
//strategy.order("S1", false, units, when = (close > 1.05 * ma) and (close < 1.1 * ma) and (strategy.position_size > 0))
//strategy.order("S2", false, units, when = (close > 1.1 * ma) and (close < 1.15 * ma) and (strategy.position_size > 0))
//strategy.order("S3", false, units, when = (close > 1.15 * ma) and (close < 1.2 * ma) and (strategy.position_size > 0))
//strategy.order("S4", false, units, when = (close > 1.2 * ma) and (close < 1.25 * ma) and (strategy.position_size > 0))
//strategy.order("S5", false, units, when = (close > 1.25 * ma) and (close < 1.3 * ma) and (strategy.position_size > 0))
//banding calculations
aH = 1.0 - deviation
aL = aH - deviation
bH = aL
bL = bH - deviation
cH = bL
cL = cH - deviation
dH = cL
dL = dH - deviation
eH = dL
strategy.initial_capital = 50000
//mode 8
strategy.order("B1", true, unitsLevel1, when = (close < aH * ma) and (close > aL * ma) and (unitsLevel1 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B2", true, unitsLevel2, when = (close < bH * ma) and (close > bL * ma) and (unitsLevel2 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B3", true, unitsLevel3, when = (close < cH * ma) and (close > cL * ma) and (unitsLevel3 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B4", true, unitsLevel4, when = (close < dH * ma) and (close > dL * ma) and (unitsLevel4 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B5", true, unitsLevel5, when = (close < eH * ma) and (unitsLevel5 * close < (strategy.initial_capital + strategy.netprofit)))
//banding calculations
fL = 1.0 + deviation
fH = fL + deviation
gL = fH
gH = gL + deviation
hL = gH
hH = hL + deviation
iL = hH
iH = iL + deviation
jL = iH
strategy.order("S1", false, unitsLevel1, when = (close > fL * ma) and (close < fH * ma) and (strategy.position_size > 0))
strategy.order("S2", false, unitsLevel2, when = (close > gL * ma) and (close < gH * ma) and (strategy.position_size > 0))
strategy.order("S3", false, unitsLevel3, when = (close > hL * ma) and (close < hH * ma) and (strategy.position_size > 0))
strategy.order("S4", false, unitsLevel4, when = (close > iL * ma) and (close < iH * ma) and (strategy.position_size > 0))
strategy.order("S5", false, unitsLevel5, when = (close > jL * ma) and (strategy.position_size > 0))
plot(ma, color=#666666, linewidth=5)