Estratégia longa e curta do indicador RSI
ChaoZhang
Visão geral
A estratégia baseia-se em indicadores de força e fraqueza relativa (RSI) e é classificada como uma estratégia típica de negociação de inversão de RSI. A estratégia possui funções de otimização de parâmetros, como a estratégia de parada de perda, que pode ser adaptada a diferentes condições de mercado, ajustando os parâmetros.
Princípio da estratégia
A lógica central da estratégia é a seguinte:
- Calcular o valor do RSI
- Configurar o limite superior e inferior do RSI
- A RSI é um indicador de que o mercado está em alta.
- RSI, veja mais entradas
- Configure o parâmetro de suspensão
- Quando o RSI entra novamente no intervalo ou quando a condição de stop loss é acionada
O indicador RSI pode mostrar se o mercado está em um estado de supercompra ou supervenda. Quando o RSI é superior a 70, é considerado supercompra. Quando o RSI é inferior a 30, é considerado supervenda.
Esta estratégia usa a lógica clássica do indicador RSI para determinar a direção da posição de acordo com a relação entre o valor do RSI e o limite superior e inferior predefinido. Além disso, a estratégia possui parâmetros ajustáveis que podem ser otimizados para o limite superior e inferior do RSI, a amplitude de parada e perda, etc., para se adaptar às mudanças do mercado.
Vantagens estratégicas
- O RSI pode ser usado para avaliar o excesso de compra e venda
- A teoria do RSI é amplamente aceita
- Parâmetros de estratégia ajustáveis para diferentes variedades e condições de mercado
- Mecanismos integrados de suspensão de perda para controlar o risco
Riscos estratégicos e resposta
- RSI pode emitir falsos sinais, causando perdas desnecessárias
- A necessidade de otimização contínua do intervalo de parâmetros RSI
- A interrupção de funcionamento do tremor pode ter sido provocada por frequentes
Contramedidas:
- Verificação multifatorial em combinação com outros indicadores para evitar falsos sinais
- Intervalo de parâmetros RSI optimizados de acordo com as características de diferentes variedades
- Ajustar a posição de parada para reduzir o risco de aposta
Direção de otimização da estratégia
A estratégia pode ser ampliada e aperfeiçoada nos seguintes aspectos:
Otimização automática de intervalos de parâmetros RSI com aprendizado de máquina
Aumentar a confirmação de transações e evitar brechas falsas
Verificação multifatorial combinada com indicadores como a média móvel
Estabelecer uma estratégia de stop-loss adaptável, ajustando a amplitude de stop-loss de acordo com as flutuações do mercado
Estudar mudanças no volume de transações para avaliar os fluxos de capital
Combinação de outras estratégias não relevantes para reduzir a retirada global
Resumir
A estratégia usa o indicador RSI para determinar o excesso de compra e venda, uma estratégia de inversão simples e prática. A estratégia pode ajustar os parâmetros de acordo com as mudanças no mercado, mas também pode ser ampliada e otimizada em várias dimensões. Melhorias como a otimização de parâmetros, a verificação multifatorial e a parada automática podem tornar a estratégia mais estável e confiável.
/*backtest
start: 2023-08-19 00:00:00
end: 2023-09-18 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
strategy("4All V3", shorttitle="Strategy", overlay=true)
/////////////// Component Code Start ///////////////
testStartYear = input(2011, "Backtest Start Year")
testStartMonth = input(8, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear = input(2018, "Backtest Stop Year")
testStopMonth = input(9, "Backtest Stop Month")
testStopDay = input(29, "Backtest Stop Day")
// testStopDay = testStartDay + 1
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)
// A switch to control background coloring of the test period
testPeriodBackground = input(title="Color Background?", type=bool, defval=true)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)
testPeriod() => true
/////////////// Component Code Stop ///////////////
src = close
len = input(4, minval=1, title="Length")
up = rma(max(change(src), 0), len)
down = rma(-min(change(src), 0), len)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))
rsin = input(5)
sn = 100 - rsin
ln = 0 + rsin
/////////////// STRATEGY ///////////////
ts = input(99999, "Trailing Stop") / 10000
tp = input(15, "Take Profit") / 10000
sl = input(23, "Stop Loss") / 10000
pyr = input(1, "Pyramiding")
short = crossover(rsi, sn)
long = crossunder(rsi, ln)
totalLongs = 0
totalLongs := nz(totalLongs[1])
totalShorts = 0
totalShorts := nz(totalShorts[1])
totalLongsPrice = 0
totalLongsPrice := nz(totalLongsPrice[1])
totalShortsPrice = 0
totalShortsPrice := nz(totalShortsPrice[1])
sectionLongs = 0
sectionLongs := nz(sectionLongs[1])
sectionShorts = 0
sectionShorts := nz(sectionShorts[1])
if long
sectionLongs := sectionLongs + 1
sectionShorts := 0
if short
sectionLongs := 0
sectionShorts := sectionShorts + 1
longCondition = long and sectionLongs >= pyr
shortCondition = short and sectionShorts >= pyr
last_long = na
last_short = na
last_long := longCondition ? time : nz(last_long[1])
last_short := shortCondition ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = na
last_open_short_signal = na
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 = na
last_short_signal = na
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 = na
last_low = na
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])
long_ts = not na(last_high) and high <= (last_high - ts) //and high >= last_open_long_signal
short_ts = not na(last_low) and low >= (last_low + ts) //and low <= last_open_short_signal
long_tp = high >= (last_open_long_signal + tp)
short_tp = low <= (last_open_short_signal - tp)
long_sl = low <= (last_open_long_signal - sl)
short_sl = high >= (last_open_short_signal + sl)
leverage = input(1, "Leverage")
long_call = last_open_long_signal - (0.8 + 0.2 * (1/leverage)) / leverage * last_open_long_signal
short_call = last_open_short_signal + (0.78 + 0.2 * (1/leverage)) / leverage * last_open_short_signal
long_call_signal = low <= long_call
short_call_signal = high >= short_call
if testPeriod()
strategy.entry("Long", strategy.long, when=longCondition)
strategy.entry("Short", strategy.short, when=shortCondition)
strategy.close("Long", when=long_call_signal)
strategy.close("Short", when=short_call_signal)
strategy.close("Long", when=long_tp)
strategy.close("Short", when=short_tp)
strategy.close("Long", when=long_sl)
strategy.close("Short", when=short_sl)
strategy.close("Long", when=long_ts)
strategy.close("Short", when=short_ts)