Estrategia de tendencia basada en múltiples indicadores

El autor:¿ Qué pasa?, fecha: 2024-01-30 17:51:04
Las etiquetas:

Resumen general

Esta estrategia identifica tendencias mediante la combinación de múltiples indicadores y establece el seguimiento de tendencias para bloquear las ganancias.

Principio de la estrategia

Los principales indicadores de juicio de la estrategia son Bollinger Bands, RSI y ADX. Cuando el precio se acerca al rieles inferior de las Bandas de Bollinger y el RSI está por debajo de 30, se juzga como sobrevendido y se toma una posición larga; cuando el precio se acerca al rieles superior de las Bandas de Bollinger y el RSI está por encima de 70, se juzga como sobrecomprado y se toma una posición corta. Además, si el ADX está por encima de 25, significa que se ha formado una tendencia, lo que hace que las señales largas y cortas sean más efectivas.

Después de abrir posiciones, la estrategia utiliza el indicador ATR y los carriles de Bollinger Bands para establecer el stop loss. Específicamente, el ATR establece el rango máximo de stop loss. Cuando el precio alcanza el punto máximo de stop loss, cierra la posición; los carriles de Bollinger Bands establecen los puntos de stop loss que se actualizan de acuerdo con el movimiento del precio.

Análisis de ventajas

La estrategia combina múltiples indicadores para el juicio y utiliza un mecanismo de stop loss para fijar las ganancias y reducir el riesgo.

Utilizando bandas de Bollinger para juzgar las situaciones de sobrecompra y sobreventa de oportunidades de reversión
La combinación con el indicador RSI aumenta la precisión del juicio
El indicador ADX determina la formación de tendencias para garantizar la dirección correcta del comercio
Las bandas de ATR y Bollinger que siguen el stop loss pueden maximizar el bloqueo de ganancias

Análisis de riesgos

También existen algunos riesgos para esta estrategia:

El juicio de múltiples indicadores conduce a una alta probabilidad de sobre-optimización
Las señales son menos efectivas cuando el rango de bandas de Bollinger es demasiado amplio
El seguimiento inadecuado del stop loss puede conducir a pérdidas ampliadas

Para hacer frente a estos riesgos, podemos tomar las siguientes medidas:

Optimización de varios parámetros para evitar la sobre-optimización
Ajustar los parámetros de las bandas de Bollinger basados en la volatilidad del mercado
Parámetros de la distancia de pérdida de prueba para soportar las fluctuaciones normales

Direcciones de optimización

La estrategia también puede optimizarse en los siguientes aspectos:

Añadir dimensionamiento de posición para ajustar la escala de posición basada en el multiplicador de pérdida de parada
Añadir módulo de gestión de dinero para controlar estrictamente el importe de pérdida de parada única
Prueba otros indicadores de stop loss como DMI, Envelop, etc.
Añadir modelos de aprendizaje automático para determinar la probabilidad de tendencia y mejorar el rendimiento

Resumen de las actividades

En resumen, esta es una estrategia de seguimiento de tendencia relativamente robusta. Al determinar la dirección de la tendencia a través de múltiples indicadores y controlar los riesgos a través de medidas de stop loss, puede lograr un buen retorno de la inversión. También hemos propuesto varios aspectos que la estrategia puede optimizar.

/*backtest
start: 2023-12-01 00:00:00
end: 2023-12-31 23:59:59
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=3
// THIS SCRIPT IS MEANT TO ACCOMPANY COMMAND EXECUTION BOTS
// THE INCLUDED STRATEGY IS NOT MEANT FOR LIVE TRADING
// THIS STRATEGY IS PURELY AN EXAMLE TO START EXPERIMENTATING WITH YOUR OWN IDEAS
/////////////////////////////////////////////////////////////////////////////////

// comment out the next line to use this script as an alert script
strategy(title="Dragon Bot - Default Script", overlay=true)
// remove the // in the next line to use this script as an alert script
// study(title="Dragon Bot - Default Script", overlay=true)

// Dragon-Bot default script version 2.0
// This can also be used with bot that reacts to tradingview alerts.
// Use the script as "strategy" for backtesting
// Comment out line 8 and de-comment line 10 to be able to set tradingview alerts.
// You should also comment out (place // before it) the lines 360, 364, 368 and 372 (strategy.entry and strategy.close) to be able to set the alerts.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// In this first part of the script we setup variables and make sure the script keeps all information it used in the past. //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
longs = 0
longs := nz(longs[1])

shorts = 0
shorts := nz(shorts[1])

buyprice = 0.0
buyprice := buyprice[1]

sellprice = 0.0
sellprice := sellprice[1]

scaler = 0.0
scaler := scaler[1]

sellprofit = input(1.0, minval=0.0, step=0.1, title="main strat profit")
sellproffinal = sellprofit/100

enable_shorts = input(1, minval=0, maxval=1, title="Shorts on/off")

enable_flipping = input(0, minval=0, maxval=1, title="Flipping on/off -> Go directly from long -> short or short -> long without closing ")

enable_stoploss = input(0, minval=0, maxval=1, title="Stoploss on/off")
sellstoploss = input(30.0, minval=0.0, step=1.0, title="Stoploss %")
sellstoplossfinal = sellstoploss/100

enable_trailing = input(1, minval=0, maxval=1, title="Trailing on/off")
enable_trailing_ATR = input(1, minval=0, maxval=1, title="Trailing use ATR on/off")
ATR_Multi = input(1.0, minval=0.0, step=0.1, title="Multiplier for ATR")
selltrailing = input(10.0, minval=0.0, step=1.0, title="Trailing %")
selltrailingfinal = selltrailing/100

Backtestdate = input(0, minval=0, maxval=1, title="backtest date on/off")

// Component Code by pbergden - Start backtest dates
// The following code snippet is taken from an example by pbergen
// All rights to this snippet remain with pbergden
testStartYear = input(2018, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)

testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(1, "Backtest Stop Month")
testStopDay = input(1, "Backtest Stop Day")
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

/////////////////////////////////////////////////////////////////////////////////////////////////////
// In this second part of the script we setup indicators that we can use for our actual algorithm. //
/////////////////////////////////////////////////////////////////////////////////////////////////////


//ATR
lengthtr = input(20, minval=1, title="ATR Length")
ATRsell = input(0, minval=0, title="1 for added ATR when selling")
ATR=rma(tr(true), lengthtr)
Trail_ATR=rma(tr(true), 10) * ATR_Multi
atr = 0.0
if ATRsell == 1
    atr := ATR

//OC2
lengthoc2 = input(20, minval=1, title="OC2 Length")
OC2sell = input(0, minval=0, title="1 for added OC2 when selling")
OC2mult = input(1, minval=1, title="OC2 multiplayer")
OC= abs(open[1]-close)
OC2=rma(OC, lengthoc2)
oc2 = 0.0
if OC2sell == 1
    oc2 := OC2*OC2mult

//ADX
lenadx = input(10, minval=1, title="DI Length")
lensig = input(10, title="ADX Smoothing", minval=1, maxval=50)

up = change(high)
down = -change(low)
plusDM = na(up) ? na : (up > down and up > 0 ? up : 0)
minusDM = na(down) ? na : (down > up and down > 0 ? down : 0)
trur = rma(tr, lenadx)
plus = fixnan(100 * rma(plusDM, lenadx) / trur)
minus = fixnan(100 * rma(minusDM, lenadx) / trur)
sum = plus + minus
sigadx = 100 * rma(abs(plus - minus) / (sum == 0 ? 1 : sum), lensig)

//StochRSI
smoothKRSI = input(3, minval=1)
smoothDRSI = input(3, minval=1)
lengthRSI = input(14, minval=1)
lengthStochRSI = input(14, minval=1)
srcRSI = input(close, title="RSI Source")
buyRSI = input(30, minval=1, title="RSI Buy Value")
sellRSI = input(70, minval=1, title="RSI Sell Value")
rsi1 = rsi(srcRSI, lengthRSI)
krsi = sma(stoch(rsi1, rsi1, rsi1, lengthStochRSI), smoothKRSI)
drsi = sma(krsi, smoothDRSI)

// Bollinger bands
lengthbb = input(20, minval=1)
srcbb = input(close, title="Sourcebb")
multbb = input(2.0, minval=0.001, maxval=50)
bb_buy_value = input(0.5, step=0.1, title="BB Buy Value")
bb_sell_value = input(0.5, step=0.1, title="BB Sell Value")
basisbb = sma(srcbb, lengthbb)
devbb = multbb * stdev(srcbb, lengthbb)
upperbb = basisbb + devbb
lowerbb = basisbb - devbb
bbr = (srcbb - lowerbb)/(upperbb - lowerbb)
bbbuy = basisbb - (devbb*bb_buy_value)
bbsell = basisbb + (devbb*bb_sell_value)

//ema very short
shorter = ema(close, 2)
shorterlong = ema(close, 5)

//ema short
short = ema(close, 10)
long = ema(close, 30)

//ema long
shortday = ema(close, 110)
longday = ema(close, 360)

//ema even longer
shortlongerday = ema(close, 240)
longlongerday = ema(close, 720)

//declaring extra timeframe value
profit = request.security(syminfo.tickerid, timeframe.period, close)

        
////////////////////////////////////////////////////////////////////////
// In the 3rd part of the script we define all the entries and exits //
///////// This third part is basically the acual algorithm ////////////
///////////////////////////////////////////////////////////////////////

//Declaring function with the long entries
OPENLONG_funct() =>
    // You can add more buy entries to the script
    longentry1 = false
    longentry2 = false
    longentry3 = false
    longentry4 = false
    longentry5 = false
    makelong_funct = false
    if  close<bbbuy and krsi<buyRSI // You could for instance add "and shortday > longday"
        longentry1 := close>close[1]
        // longentry2 := ...
    // if another thing we want to buy on happens
        // longentry3 := ...
    //All the buy entries go above, this last variable is what the function puts out
    // if you add more entries, add them in the following list too
    makelong_funct := longentry1 or longentry2 or longentry3 or longentry4 or longentry5

//Declaring function wit the short entries
OPENSHORT_funct() =>
    // You can add more buy entries to the script
    shortentry1 = false
    shortentry2 = false
    shortentry3 = false
    shortentry4 = false
    shortentry5 = false
    makeshort_funct = false
    if  close>bbsell and krsi>sellRSI // You could for instance add "and shortday < longday"
        shortentry1 := close<close[1]
        // shortentry2 := ...
    // if another thing we want to buy on happens
        // shortentry3 := ...
    //All the buy entries go above, this last variable is what the function puts out
    // if you add more entries, add them in the following list too
    makeshort_funct := shortentry1 or shortentry2 or shortentry3 or shortentry4 or shortentry5
    
//Declaring function with the long exits
CLOSELONG_funct() =>
    // You can add more buy entries to the script
    longexit1 = false
    longexit2 = false
    longexit3 = false
    longexit4 = false
    longexit5 = false
    closelong_funct = false
    if  close>bbsell and krsi>sellRSI
        longexit1 := close<close[1]
        // longexit2 := ...
    // if another thing we want to close on on happens you can add them here...
    // longexit3 := ...
    //All the buy entries go above, this last variable is what the function puts out
    // if you add more exits, add them in the following list too
    closelong_funct := longexit1 or longexit2 or longexit3 or longexit4 or longexit5

//Declaring function wit the short exits
CLOSESHORT_funct() =>
    // You can add more buy entries to the script
    shortexit1 = false
    shortexit2 = false
    shortexit3 = false
    shortexit4 = false
    shortexit5 = false
    closeshort_funct = false
    if  close<bbsell and krsi<sellRSI
        shortexit1 := close>close[1]
        // shortexit2 := ...
    // if another thing we want to close on on happens you can add them here...
        // shortexit3 := ...
    //All the buy entries go above, this last variable is what the function puts out
    // if you add more exits, add them in the following list too
    closeshort_funct := shortexit1 or shortexit2 or shortexit3 or shortexit4 or shortexit5

/////////////////////////////////////////////////////////////////////////////////////
////////////// End of "entries" and "exits" definition code /////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/// In the fourth part we do the actual work, as defined in the part before this ////
////////////////////// This part does not need to be changed ////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

//OPEN LONG LOGIC
makelong = false
//buy with backtesting on specific dates
if Backtestdate > 0 and testPeriod()
    if (longs < 1 and shorts < 1) or (short > 0 and enable_flipping > 0 and enable_shorts > 0)
        makelong := OPENLONG_funct()

//buy without backtesting on specific dates
if Backtestdate < 1
    if (longs < 1 and shorts < 1) or (short > 0 and enable_flipping > 0 and enable_shorts > 0)
        makelong := OPENLONG_funct()
    
if makelong
    buyprice := close
    scaler := close
    longs := 1
    shorts := 0
    
//OPEN SHORT LOGIC
makeshort = false

//buy with backtesting on specific dates
if Backtestdate > 0 and testPeriod()
    if (shorts < 1 and longs < 1 and enable_shorts > 0) or (longs > 0 and enable_flipping > 0 and enable_shorts > 0)
        makeshort := OPENSHORT_funct()

//buy without backtesting on specific dates
if Backtestdate < 1
    if (shorts < 1 and longs < 1 and enable_shorts > 0) or (longs > 0 and enable_flipping > 0 and enable_shorts > 0)
        makeshort := OPENSHORT_funct()
    

if makeshort
    buyprice := close
    scaler := close
    shorts := 1
    longs := 0

//Calculating values for traling stop
if longs > 0 and enable_flipping < 1
    if close > scaler+Trail_ATR and enable_trailing_ATR > 0
        scaler := close
    if close > scaler * (1.0 + selltrailingfinal) and enable_trailing_ATR < 1
        scaler := close
if shorts > 0 and enable_flipping < 1
    if close < scaler-Trail_ATR and enable_trailing_ATR > 0
        scaler := close
    if close < scaler * (1.0 - selltrailingfinal) and enable_trailing_ATR < 1
        scaler := close
    
long_exit = false
long_security1 = false
long_security2 = false
long_security3 = false

//CLOSE LONG LOGIC
if longs > 0 and enable_flipping < 1
    if ( (buyprice + (buyprice*sellproffinal) + atr + oc2) < close) and ( (buyprice + (buyprice*sellproffinal) ) < profit)
        long_exit := CLOSELONG_funct()
//security
    if enable_stoploss > 0
        long_security1 := close < ( buyprice * (1.0 - sellstoplossfinal) )
    if enable_trailing > 0 and enable_trailing_ATR < 1
        long_security2 := close < ( scaler * (1.0 - selltrailingfinal) )
    if enable_trailing > 0 and enable_trailing_ATR > 0
        long_security2 := close < ( scaler - Trail_ATR)
        
//CLOSE LONG LOGIC
if longs > 0 and enable_flipping > 0
//security
    if enable_stoploss > 0
        long_security1 := close < ( buyprice * (1.0 - sellstoplossfinal) )
    if enable_trailing > 0 and enable_trailing_ATR < 1
        long_security2 := close < ( scaler * (1.0 - selltrailingfinal) )
    if enable_trailing > 0 and enable_trailing_ATR > 0
        long_security2 := close < ( scaler - Trail_ATR)
        
closelong = long_exit or long_security1 or long_security2 or long_security3 

short_exit = false
short_security1 = false
short_security2 = false
short_security3 = false

if closelong
    longs := 0

//CLOSE SHORT LOGIC
if shorts > 0 and enable_flipping < 1
    if ( (buyprice - (buyprice*(sellproffinal) - atr - oc2) > close) and ( (buyprice - (buyprice*sellproffinal) ) > profit) )
        short_exit := CLOSESHORT_funct()
//security
    if enable_stoploss > 0
        short_security1 := close > ( buyprice * (1.0 + sellstoplossfinal) )
    if enable_trailing > 0 and enable_trailing_ATR < 1
        short_security2 := close > ( scaler * (1.0 + selltrailingfinal) )
    if enable_trailing > 0 and enable_trailing_ATR > 0
        short_security2 := close > ( scaler + Trail_ATR)
if shorts > 0 and enable_flipping > 0
//security
    if enable_stoploss > 0
        short_security1 := close > ( buyprice * (1.0 + sellstoplossfinal) )
    if enable_trailing > 0 and enable_trailing_ATR < 1
        short_security2 := close > ( scaler * (1.0 + selltrailingfinal) )
    if enable_trailing > 0 and enable_trailing_ATR > 0
        short_security2 := close > ( scaler + Trail_ATR)
        
closeshort = short_exit or short_security1 or short_security2 or short_security3

if closeshort
    shorts := 0

///////////////////////////////////////////////////////////////////////////////////////
///////////// The last section takes care of the alerts //////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
plotshape(makelong, style=shape.arrowup)
alertcondition(makelong, title="openlong", message="openlong")
strategy.entry("BuyLONG", strategy.long, oca_name="DBCross", when= makelong, comment="Open Long")

plotshape(makeshort, style=shape.arrowdown)
alertcondition(makeshort, title="openshort", message="openshort")
strategy.entry("BuySHORT", strategy.short, oca_name="DBCross", when= makeshort, comment="Open Short")

plotshape(closelong, style=shape.arrowdown)
alertcondition(closelong, title="closelong", message="closelong")
strategy.close("BuyLONG", when=closelong)

plotshape(closeshort, style=shape.arrowup)
alertcondition(closeshort, title="closeshort", message="closeshort")
strategy.close("BuySHORT", when=closeshort)

Más.