Estrategia de compra y venta del indicador RSI
ChaoZhang
Descripción general
La estrategia se basa en el índice de fuerza relativa (RSI) indicador para juzgar, cuando el RSI es superior a la creación de la parte superior del límite, y cuando el RSI es inferior a la creación de la parte inferior de más, pertenece a la típica estrategia de comercio de inversión RSI. La estrategia tiene al mismo tiempo la optimización de parámetros, la estrategia de detener los pérdidas y otras funciones, puede adaptarse a diferentes condiciones de mercado mediante el ajuste de los parámetros.
Principio de estrategia
La lógica central de la estrategia incluye:
- Cálculo del índice RSI
- Configuración de los límites superiores y inferiores del RSI
- El RSI está en el límite de entrada.
- Cuando el RSI cruza el límite inferior, mira más entradas
- Configuración de las condiciones de parada y deterioro
- El RSI cerrará la posición cuando se vuelva a entrar en el intervalo o cuando se activen las condiciones de stop loss
El indicador RSI puede mostrar si el mercado está sobrecomprado o sobrevendido. Cuando el RSI está por encima de 70, se considera sobrecomprado, y cuando el RSI está por debajo de 30, se considera sobrevendido. La estrategia de negociación es determinar si se debe establecer una posición en blanco o una posición en polvo en función del estado de sobrecompra y sobreventa del RSI.
Esta estrategia utiliza la lógica clásica del RSI para determinar la dirección de la posición en función de la relación entre el valor del RSI y el límite superior inferior predeterminado. Además, la estrategia tiene parámetros ajustables que pueden optimizarse para el RSI, el límite superior inferior, el stop loss, etc., para adaptarse a los cambios en el mercado.
Ventajas estratégicas
- El uso del RSI puede ayudar a determinar el estado de sobrecompra y sobreventa en el mercado.
- La teoría del RSI es ampliamente aceptada
- Los parámetros de la estrategia se pueden ajustar para adaptarse a diferentes variedades y entornos del mercado
- Mecanismo integrado de detención de pérdidas para controlar el riesgo
Riesgo estratégico y respuesta
- El RSI podría emitir señales falsas que podrían causar pérdidas innecesarias
- Optimizar continuamente el rango de los parámetros RSI
- La interrupción de la actividad del temblor puede ser provocada por Frequent.
Contramedidas:
- Identificación multifactorial en combinación con otros indicadores para evitar falsas señales
- Optimización del rango de parámetros RSI según las características de las diferentes variedades
- Ajuste de la posición de pérdida para reducir el riesgo de ser cubierto
Dirección de optimización de la estrategia
La estrategia puede ampliarse y optimizarse en los siguientes aspectos:
Aprendizaje automático para optimizar el rango de parámetros RSI
Aumentar la cantidad de transacciones confirmadas para evitar falsos brechas
Verificación multifactorial combinada con indicadores como las medias móviles
Establecer una estrategia de stop loss adaptativa para ajustar el stop loss a las fluctuaciones del mercado
Estudiar los cambios en el volumen de transacciones para determinar los flujos de entrada y salida de fondos
Combinación con otras estrategias no relevantes para reducir el retroceso global
Resumir
La estrategia utiliza el indicador RSI para determinar sobrecompra y sobreventa, es una estrategia de inversión simple y práctica. La estrategia puede ajustar los parámetros según los cambios en el mercado, pero también puede ampliarse y optimizarse en múltiples dimensiones. Las mejoras como la optimización de parámetros, la verificación multifactorial y el stop loss adaptativo pueden hacer que la estrategia sea más estable y confiable.
/*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)