Estratégia de negociação de reversão baseada no indicador RSI
ChaoZhang
Visão geral
Esta estratégia utiliza o indicador RSI para identificar o estado de mercado em que as ações são sobre-compradas e sobre-vendidas, formando um forco morto em áreas de sobre-compra e um forco dourado em áreas de sobre-venda, pertencendo a estratégia de negociação de reversão baseada em indicadores. Esta estratégia, combinada com o rastreamento de tendências e o stop loss fixo, pode controlar efetivamente o risco de negociação.
Princípio da estratégia
O indicador RSI geralmente usa 30 como linha de superalimento e 70 como linha de superalimento. Quando o indicador RSI atravessa a linha de superalimento, gera um sinal de compra; Quando o indicador RSI atravessa a linha de superalimento, gera um sinal de venda. De acordo com este princípio, a estratégia determina a formação de áreas de superalimento e, correspondentemente, gera um sinal de superalimento.
Após a entrada, a estratégia usa o método de rastreamento de perdas em porcentagem, atualizando continuamente o preço mais alto ou mais baixo e deixando uma determinada porcentagem como ponto de parada. Ao mesmo tempo, usa um intervalo fixo de parada e parada, que é interrompido quando o lucro-alvo ou a perda máxima são atingidos. Esta combinação pode controlar muito bem o risco de negociação.
Análise de vantagens
A estratégia tem as seguintes vantagens:
O uso do indicador RSI para determinar áreas de sobrevenda e sobrecompra é uma técnica de negociação mais avançada que permite capturar com mais precisão os pontos de reversão do mercado.
O método Gold Fork Dead Fork permite filtrar parte do ruído dos sinais de transação, tornando as transações mais confiáveis.
Combinado com um stop loss de seguimento de tendências, pode maximizar o bloqueio de lucros, mas também pode parar rapidamente, reduzindo a perda individual.
A distância fixa de stop loss também pode ser usada para controlar o risco de uma única transação.
No geral, as regras da estratégia são claras, fáceis de entender e implementar, e são adequadas para quem está começando a aprender a negociar com quantidade.
Análise de Riscos
A estratégia também apresenta os seguintes riscos:
Os indicadores RSI são propensos a produzir sinais errôneos, com uma maior probabilidade de ruptura do padrão técnico, o que pode levar a que o stop loss seja acionado.
A distância de parada fixa não pode ser ajustada com base na volatilidade do mercado, podendo causar parada prematura ou expansão de parada.
A percentagem de tracking stop loss só segue os pontos mais altos ou mais baixos do preço, podendo ser muito radical e não ser suficientemente lucrativa.
Risco de adequação de dados de retrospecção. Os parâmetros da estratégia podem ser otimizados para dados históricos e podem ter um desempenho inferior em aplicações reais.
A frequência de transações pode ser excessiva, aumentando as taxas de transação e o risco de deslizamento.
Direção de otimização
A estratégia pode ser otimizada em várias direções:
Optimizar os parâmetros do RSI, procurar a melhor combinação de parâmetros do indicador e melhorar a qualidade do sinal.
Adicionar filtros de outros indicadores, formando ressonância multi-indicadores, aumentando a precisão do sinal.
O mecanismo de parada de perda adaptável é usado para ajustar automaticamente a parada de perda de acordo com as flutuações do mercado.
Aumentar o módulo de controle de frequência de transação, reduzir o número de transações e reduzir as taxas de transação.
Adicionar módulos de gestão de fundos, controlar o tamanho de transações individuais e reduzir perdas individuais.
Refazer o teste em períodos de tempo mais longos para verificar a estabilidade dos parâmetros.
Resumir
Esta estratégia é uma estratégia típica de negociação de inversão, usando o indicador RSI para determinar áreas de sobrevenda e venda, gerando sinais de negociação de forma a usar um garfo de ouro e um garfo de ouro. Usando um stop loss de acompanhamento de tendência e um stop loss fixo para controlar o risco. A lógica da estratégia é clara, fácil de implementar e adequada para o aprendizado e a prática dos iniciantes em negociação quantitativa.
/*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"}]
*/
// LOVE JOY PEACE PATIENCE KINDNESS GOODNESS FAITHFULNESS GENTLENESS SELF-CONTROL
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// Author: © JoshuaMcGowan
// Taken from https://www.tradingview.com/script/GbZGYi6l-Adding-some-essential-components-to-a-prebuilt-RSI-strategy/
// Just updated to compile in version 4.
//@version=4
strategy("Adding some essential components to a prebuilt RSI 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(2100, "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=input.bool, defval=true)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)
testPeriod() => true
/////////////// Component Code Stop ///////////////
// Replace RSI Component, Long/Short, and Long Signal/Short Signal conditions with your trade setup components.
///////////// RSI component /////////////
length = input( 14 )
overSold = input( 30 )
overBought = input( 70 )
price = close
vrsi = rsi(price, length)
notna = not na(vrsi)
/////////////// STRATEGY ///////////////
ts = input(99999, "Trailing Stop") / 100
tp = input(99999, "Take Profit") / 100
sl = input(99999, "Stop Loss") / 100
// Update this with your setup.
long = notna and crossover(vrsi, overSold)
short = notna and crossunder(vrsi, overBought)
last_long = 0
last_short = 0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
// Update this to reflect your setup.
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
float last_open_long_signal = 0
float last_open_short_signal = 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
last_short_signal = 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
float last_high = 0
float last_low = 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])
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(200, "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=long_signal)
strategy.entry("Short", strategy.short, when=short_signal)
// plot(long_call, color=color.red)
// plot(short_call, color=color.green)
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)