Una estrategia de negociación de reversión de RSI

El autor:¿ Qué pasa?, Fecha: 2024-01-30 17:06:45
Las etiquetas:

Resumen general

Esta estrategia identifica las condiciones de mercado de sobrecompra y sobreventa utilizando el indicador RSI para ir corto en cruces bajistas en zonas de sobrecompra y ir largo en cruces alcistas en zonas de sobreventa.

Estrategia lógica

Las señales comerciales de esta estrategia se generan basadas en cruces alcistas / bajistas del indicador RSI. El indicador RSI generalmente utiliza 30 como la línea de sobreventa y 70 como la línea de sobrecompra. Cuando la línea RSI cruza por encima de la línea de sobreventa, se genera una señal de compra. Cuando la línea RSI cruza por debajo de la línea de sobrecompra, se genera una señal de venta. Basándose en esta lógica, la estrategia identifica las zonas de sobrecompra y sobreventa y genera las señales largas / cortas correspondientes.

Después de ingresar a una posición, la estrategia utiliza paradas de seguimiento porcentual actualizando continuamente el precio más alto / más bajo alcanzado y alejándose un porcentaje fijo de eso como el stop loss. También hay niveles fijos de toma de ganancias y stop loss, cerrando la posición cuando se alcanza el beneficio objetivo o se supera la pérdida máxima.

Análisis de ventajas

Las ventajas de esta estrategia incluyen:

El uso del RSI para identificar los niveles de sobrecompra/sobreventa es una técnica de negociación madura para capturar con fiabilidad los puntos de inflexión del mercado.
El uso de cruces alcista / bajista filtra algunas señales falsas y hace que el comercio sea más confiable.
Las paradas de seguimiento de tendencia bloquean las ganancias tanto como sea posible, al tiempo que tienen paradas rápidas para contener pérdidas por operación.
Los niveles fijos de TP/SL también controlan eficazmente el riesgo por operación.
En general, la lógica es simple y clara, fácil de entender e implementar, adecuada para principiantes.

Análisis de riesgos

Los riesgos de esta estrategia incluyen:

Las señales RSI pueden ser falsas, con una alta probabilidad de fallo del patrón, lo que conduce al detener la pérdida.
El TP/SL fijo no puede adaptarse a la volatilidad del mercado, puede reducir las ganancias o dejar correr las pérdidas.
El porcentaje de seguimiento solo sigue el precio más alto / más bajo, puede ser demasiado agresivo dejando ganancias atrás.
El riesgo de sobreajuste como parámetros podría optimizarse solo para datos históricos.
Frecuencia de comercio alta que aumenta los costos de transacción y el deslizamiento.

Direcciones de optimización

Posibles formas de mejorar la estrategia:

Optimice los parámetros del RSI para obtener los mejores resultados.
Añadir indicadores de filtro para una mayor precisión de la señal.
Se aplican las medidas de reducción de las pérdidas y de reducción de las pérdidas.
Limitar la frecuencia del comercio para reducir los costes de transacción.
Se añade el tamaño de la posición para limitar la pérdida por operación.
Prueba de retroceso en un plazo más largo para probar la estabilidad.

Conclusión

En resumen, esta es una estrategia de reversión típica que utiliza el RSI para identificar el sobrecomprado / sobreventa, con cruces toro / oso como señales. Las paradas de tendencia y el TP / SL fijo manejan 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"}]
*/

// 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)

Más.