Estratégia de negociação de impulso baseada no modelo multifator
Autora:ChaoZhang, Data: 2024-02-04 15:34:49Tags:
Resumo
Esta estratégia é uma estratégia de negociação de impulso baseada em múltiplos indicadores técnicos. A estratégia adota Bandas de Bollinger, RSI, ATR e outros indicadores técnicos para implementar um modelo multifator para julgar rapidamente a entrada quando uma tendência aparece. Ao mesmo tempo, a estratégia também adota stop loss, stop profit avançado e outros meios de controle de risco para controlar efetivamente os riscos.
Princípio da estratégia
Os sinais de negociação desta estratégia vêm principalmente das Bandas de Bollinger. Quando o preço se aproxima do trilho inferior das Bandas de Bollinger, ele é otimista e quando o preço se aproxima do trilho superior, ele é de baixa. A fim de filtrar falhas, a estratégia incorpora regras adicionais do indicador RSI. Somente quando o indicador RSI também confirma que está atualmente na área de sobrecompra ou sobrevenda, um sinal de negociação será gerado.
Além disso, o indicador ATR é usado na estratégia para implementar stop loss e take profit. Especificamente, ao abrir uma posição, um preço de compra será registrado.
Análise das vantagens
A maior vantagem desta estratégia é que, ao usar um modelo multifator para sintetizar o mercado, ele pode julgar efetivamente as oportunidades estruturais no mercado. Isso evita sinais falsos de um único indicador. Ao mesmo tempo, o mecanismo de stop loss e stop profit avançado da estratégia também pode controlar efetivamente os riscos e evitar perdas excessivas.
Análise de riscos
O maior risco desta estratégia é que, se houver uma reversão violenta do mercado, a probabilidade de que vários indicadores gerem sinais errados ao mesmo tempo será relativamente grande. Isso levará a perdas significativas para a estratégia. Além disso, quando os indicadores técnicos emitem sinais, também pode ser o consenso geral do mercado, propenso a efeitos de rebanho e, portanto, ser preso.
Para reduzir estes riscos, podemos ajustar adequadamente os parâmetros e escolher sinais mais claros.
Orientações de otimização
A estratégia pode ser otimizada nas seguintes direcções:
-
Adicionar mais indicadores técnicos para formar um modelo multidimensional mais tridimensional para melhorar a precisão do julgamento
-
Otimizar a lógica de stop loss e escolher diferentes estratégias de stop loss de acordo com diferentes estágios do mercado
-
Usar aprendizado de máquina e outras tecnologias para otimizar dinamicamente parâmetros e avaliar a confiabilidade do sinal
-
Incorporar a indústria, conceitos e outras informações para formar um modelo multifator embutido
Resumo
Aplicando razoavelmente a ideia de um modelo multifator, esta estratégia capta muito bem a direção da tendência. Ao mesmo tempo, as medidas de controle de risco científico também permitem que a estratégia obtenha lucros de forma controlada. Através da otimização contínua, espera-se melhorar ainda mais a estabilidade e a lucratividade da estratégia.
/*backtest
start: 2023-01-28 00:00:00
end: 2024-02-03 00:00:00
period: 1d
basePeriod: 1h
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, default_qty_type=strategy.percent_of_equity, default_qty_value=100)
// 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)
Mais.
- Estratégia de negociação RSI dinâmica
- Estratégia de cruzamento entre médias móveis múltiplas
- Estratégia de ruptura de média móvel dupla
- Estratégia de cruzamento da média móvel
- Estratégia de acompanhamento da tendência de média móvel dupla
- Impulso Quádrático Indicadores Duplos Estratégia de Tempo
- Renko e Relative Vigor Index Tendência Seguindo a Estratégia
- Estratégia de média móvel
- Bollinger Band, média móvel e estratégia de negociação combinada MACD
- Estratégia de Motivação do Preço da Criptomoeda
- Estratégia de acompanhamento da tendência das bandas de Bollinger adaptativas
- Estratégia de ruptura RSI melhorada com Stop Loss e Take Profit
- Estratégia de negociação quantitativa baseada no RSI e nas bandas de Bollinger
- Estratégia de negociação quantitativa baseada na SMA e na linha de tendência
- Estratégia de negociação de opções semanais estocásticas
- Estratégia de negociação quantitativa de EMA e RSI poderosa
- As bandas de Bollinger e a estratégia de negociação combinada do RSI
- Candlestick Demigod MACD Divergência Tendência Seguindo Estratégia
- Estratégia de negociação de quadros temporais de média móvel dupla
- O RSI estocástico e a estratégia de negociação da EMA com dois indicadores