Die Ressourcen sind geladen. Beförderung...

Mehrindikator-Quantitative Handelsstrategie

Schriftsteller:ChaoZhang, Datum: 2023-12-05 10:29:20
Tags:

Übersicht

Diese Strategie integriert gleitende Durchschnitte, Relative Strength Index (RSI) und gleitende Durchschnittskonvergenzdivergenz (MACD), drei wichtige technische Indikatoren, um automatisch lange und kurze Positionen zu eröffnen und zu schließen.

Strategie Logik

Die Strategie beurteilt hauptsächlich die Trendrichtung, indem sie zwei gleitende Durchschnitte vergleicht, und kombiniert den RSI-Indikator, um fehlende Umkehrmöglichkeiten zu vermeiden. Insbesondere verwendet die Strategie EMA oder SMA, um die schnelle Linie und die langsame Linie zu berechnen. Die schnelle Linie, die über die langsame Linie kreuzt, ist das Kaufsignal, und die schnelle Linie, die darunter kreuzt, ist das Verkaufssignal. Um falsche Durchbrüche zu filtern, setzt die Strategie auch die Logik des RSI-Indikators fest, nur wenn der RSI-Indikator auch die Bedingung erfüllt, wird das Handelssignal ausgelöst.

Darüber hinaus ist der MACD-Indikator auch in die Strategie für Handelsentscheidungen integriert. Wenn die Differenz zwischen dem MACD-Indikator über die 0-Achse kreuzt, ist es ein Kaufsignal, und wenn er darunter kreuzt, ist es ein Verkaufssignal. Dies kann dazu beitragen, zu beurteilen, ob der Trend umgekehrt ist, um falsche Signale an Wendepunkten zu vermeiden.

Analyse der Vorteile

Der größte Vorteil dieser Strategie besteht darin, mehrere Indikatoren zu integrieren, um Signale zu filtern, wodurch die falschen Signale effektiv reduziert und die Signalqualität verbessert werden kann.

Die schnellen und langsamen Linien in Kombination mit dem RSI-Indikator können falsche Durchbrüche verhindern, die durch die einmalige Verwendung von gleitenden Durchschnitten verursacht werden.
Die Integration des MACD-Indikators kann beurteilen, ob sich der Trend vorzeitig umgekehrt hat, um falsche Signale am Wendepunkt zu vermeiden.
Die Wahl zwischen EMA und SMA ermöglicht die Auswahl von Indikatoren, die für unterschiedliche Marktmerkmale besser geeignet sind.
Die Wahl von Geldverwaltungssystemen ermöglicht es, die Größe einzelner Aufträge zu kontrollieren, um Risiken wirksam zu kontrollieren.
Die Unterstützung von Stop-Loss und Take-Profit ermöglicht es, Gewinne zu sichern und Verluste zu vermeiden.

Risikoanalyse

Zu den wichtigsten Risiken dieser Strategie gehören:

Eine unsachgemäße Optimierung der Parameter kann zu einer schlechten Strategieleistung führen. Es muss Zeit mit dem Testen verschiedener Parameterkombinationen verbracht werden.
Die Wahrscheinlichkeit, dass der Indikator falsche Signale ausgibt, besteht immer noch. Wenn die drei Indikatoren gleichzeitig falsche Signale ausgeben, führt dies zu größeren Verlusten.
Die Leistung eines einzigen Symbols ist instabil, es ist notwendig, auf andere Sorten auszuweiten.
Die Strategie wird in der Zukunft wirksam.

Optimierungsrichtlinien

Zu den wichtigsten Aspekten für die Optimierung dieser Strategie gehören:

Versuche verschiedene Kombinationen von Indikatorparametern, um die optimalen Parameter zu finden.
Erhöhen Sie den Trailing-Stop im Stop-Loss-Mechanismus.
Vergrößern Sie die Bewertungsindizes für den wichtigsten Trend, um einen gegen den Trend gerichteten Handel zu vermeiden.
Fügen Sie das Geldmanagement-Modul hinzu für besseres Risikomanagement.
Fügen Sie Filter für grundlegende Faktoren wie Nachrichten hinzu.

Zusammenfassung

Diese Strategie realisiert das Finden und Filtern von Long- und Short-Positionen durch die Integration mehrerer technischer Indikatoren wie gleitender Durchschnitte, RSI und MACD. Ihr Vorteil ist, dass sie falsche Signale effektiv filtern und die Signalqualität verbessern kann. Die Hauptnachteile sind die Parameterwahl und die Wahrscheinlichkeit, dass Indikatoren falsche Signale ausgeben. Zukünftige Optimierungsrichtungen umfassen Parameteroptimierung, Stop-Loss-Optimierung, Trendfilterung usw. Insgesamt ist diese Strategie als Multi-Indikator-Strategie-Framework effektiv und muss in Zukunft weiter optimiert und verifiziert werden.

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

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © fikira
//@version=4
strategy("Strategy Tester EMA-SMA-RSI-MACD", shorttitle="Strat-test", overlay=true, max_bars_back=5000, 
 default_qty_type= strategy.percent_of_equity, calc_on_order_fills=false, calc_on_every_tick=false, 
 pyramiding=0, default_qty_value=100, initial_capital=100)

Tiny     = "Tiny"
Small    = "Small"
Normal   = "Normal"
Large    = "Large"

cl      = "close" , op  = "open" , hi  = "high" , lo  = "low"
c4      = "ohlc4" , c3  = "hlc3" , hl  = "hl2"

co      = "(E)MA 1 > (E)MA 2" 
cu      = "(E)MA 3 < (E)MA 4"

co_HTF  = "(E)MA 1 (HTF) > (E)MA 2 (HTF)" 
cu_HTF  = "(E)MA 3 (HTF) < (E)MA 4 (HTF)"

L_S     = "Long & Short"                , _L_  = "Long Only"                , _S_ = "Short Only"

cla     = "Close above (E)MA 1"         
clu     = "Close under (E)MA 3"

cla_HTF = "Close above (E)MA 1 (HTF)"
clu_HTF = "Close under (E)MA 3 (HTF)"

rsi     = "RSI strategy"

none    = "NONE"
mch     = "macd > signal"               , mcl     = "macd < signal"
mch0    = "macd > 0"                    , mcl0    = "macd < 0"
sgh0    = "signal > 0"                  , sgl0    = "signal < 0"

mch_HTF = "macd (HTF) > signal (HTF)"   , mcl_HTF = "macd (HTF) < signal (HTF)"
mch0HTF = "macd (HTF) > 0"              , mcl0HTF = "macd (HTF) < 0"
sgh0HTF = "signal (HTF) > 0"            , sgl0HTF = "signal (HTF) < 0"

EMA     = "EMA"                         , SMA = "SMA"       

s       = input(cl,   "Source" , options=[cl, op, hi, lo, c4, c3, hl])

src     =
 s  == cl ? close :
 s  == op ? open  :
 s  == hi ? high  :
 s  == lo ? low   :
 s  == c4 ? ohlc4 :
 s  == c3 ? hlc3  : 
 s  == hl ? hl2   :
 close

__1_    = input(false, ">=< >=< [STRATEGIES] >=< >=<")

Type    = input(_L_,  "Type Strategy", options=[L_S, _L_, _S_])

_1a_    = input(false, ">=< >=< [BUY/LONG] >=< >=<")

ENT     = input(co,   "Pick your poison:", options=[co, cla, rsi, mch, mch0, sgh0])
EH      = input(0,    " if RSI >")
EL      = input(100,  " if RSI <")
EH_HTF  = input(0,    " if RSI (HTF) >")
EL_HTF  = input(100,  " if RSI (HTF) <")

EX      = input(none, " Extra argument", options=[none, mch, mch0, sgh0])
EX2     = input(none, " Second argument", options=[none, mch_HTF, mch0HTF, sgh0HTF, co_HTF, cla_HTF])

_1b_    = input(false, ">=< [(E)MA settings (Buy/Long)] >=<")

ma1     = input(SMA,  "  (E)MA 1", options=[EMA, SMA])
len1    = input(50,   "     Length"  )
ma2     = input(SMA,  "  (E)MA 2", options=[EMA, SMA])
len2    = input(100,  "     Length"  )
ma1HTF  = input(SMA,  "  (E)MA 1 - HTF", options=[EMA, SMA])
len1HTF = input(50,   "     Length"  )
ma2HTF  = input(SMA,  "  (E)MA 2 - HTF", options=[EMA, SMA])
len2HTF = input(100,  "     Length"  )

_2a_    = input(false, ">=< >=< [SELL/SHORT] >=< >=<")

CLO     = input(cu,   "Pick your poison:", options=[cu, clu, rsi, mcl, mcl0, sgl0])
CH      = input(0,    " if RSI >")
CL      = input(100,  " if RSI <")
CH_HTF  = input(0,    " if RSI (HTF) >")
CL_HTF  = input(100,  " if RSI (HTF) <")

CX      = input(none, " Extra argument", options=[none, mcl, mcl0, sgl0])
CX2     = input(none, " Second argument", options=[none, mcl_HTF, mcl0HTF, sgl0HTF, cu_HTF, clu_HTF])

_2b_    = input(false, ">=< [(E)MA settings (Sell/Short)] >=<")

ma3     = input(SMA,  "  (E)MA 3", options=[EMA, SMA])
len3    = input(50,   "     Length"  )
ma4     = input(SMA,  "  (E)MA 4", options=[EMA, SMA])
len4    = input(100,  "     Length"  )
ma3HTF  = input(SMA,  "  (E)MA 3 - HTF", options=[EMA, SMA])
len3HTF = input(50,   "     Length"  )
ma4HTF  = input(SMA,  "  (E)MA 4 - HTF", options=[EMA, SMA])
len4HTF = input(100,  "     Length"  )

__3_    = input(false, ">=< >=< [RSI]  >=< >=< >=<")

ler     = input(20 , "  RSI Length")

__4_    = input(false, ">=< >=< [MACD] >=< >=< >=<")

fst     = input(12, "  Fast Length")
slw     = input(26, "  Slow Length")
sgn     = input(9 , "  Signal Smoothing")
sma_source = input(false, "Simple MA(Oscillator)")
sma_signal = input(false, "Simple MA(Signal Line)")

__5_    = input(false, ">=< >=< [HTF settings] >=< >=<")

MA_HTF  = input("D", "  (E)MA HTF", type = input.resolution)
RSI_HTF = input("D", "  RSI HTF"  , type = input.resolution)
MACD_HTF= input("D", "  MACD HTF" , type = input.resolution)

__6_    = input(false, ">=< >=< [SL/TP] >=< >=< >=<")

sl      = input(false, "Stop Loss?")
SL      = input(10.0, title="  Stop Loss %"  ) / 100
tp      = input(false, "Take Profit?")
TP      = input(20.0, title="  Take Profit %") / 100
 
SL_     = strategy.position_avg_price * (1 - SL)
TP_     = strategy.position_avg_price * (1 + TP)

// Limitation in time
// (= inspired from a script of "Che_Trader")

xox     = input(false, ">=< >=< [TIME] >=< >=< >=<")

ystr1   = input(2010, "  Since Year" )
ystp1   = input(2099, "  Till Year"  )
mstr1   = input(1   , "  Since Month")
mstp1   = input(12  , "  Till Month" )
dstr1   = input(1   , "  Since Day"  )
dstp1   = input(31  , "  Till Day"   )
 
_Str1   = timestamp(ystr1, mstr1, dstr1,  1,  1)
Stp1_   = timestamp(ystp1, mstp1, dstp1, 23, 59)

TIME    = time >= _Str1 and time <= Stp1_ ? true : false

////////////////////////////////////////////////////////////////////////////////////////////

_1      = 
 ma1 == SMA ? sma(src, len1) : 
 ma1 == EMA ? ema(src, len1) : 
 na
_2      = 
 ma2 == SMA ? sma(src, len2) :
 ma2 == EMA ? ema(src, len2) :
 na
_3      = 
 ma3 == SMA ? sma(src, len3) :
 ma3 == EMA ? ema(src, len3) :
 na
_4      = 
 ma4 == SMA ? sma(src, len4) :
 ma4 == EMA ? ema(src, len4) :
 na

_1b  = 
 ma1HTF == SMA ? sma(src, len1HTF) :
 ma1HTF == EMA ? ema(src, len1HTF) :
 na
_2b  = 
 ma2HTF == SMA ? sma(src, len2HTF) :
 ma2HTF == EMA ? ema(src, len2HTF) :
 na
_3b  = 
 ma3HTF == SMA ? sma(src, len3HTF) :
 ma3HTF == EMA ? ema(src, len3HTF) :
 na
_4b  = 
 ma4HTF == SMA ? sma(src, len4HTF) :
 ma4HTF == EMA ? ema(src, len4HTF) :
 na

_1_HTF = security(syminfo.tickerid, MA_HTF,  _1b)
_2_HTF = security(syminfo.tickerid, MA_HTF,  _2b)
_3_HTF = security(syminfo.tickerid, MA_HTF,  _3b)
_4_HTF = security(syminfo.tickerid, MA_HTF,  _4b)
cl_HTF = security(syminfo.tickerid, MA_HTF,  close)

////////////////////////////////////////////////////////////////////////////////////////////

plot(ENT == co or ENT == cla ? _1 : na            , title="(E)MA 1", color=color.lime                           )
plot(ENT == co               ? _2 : na            , title="(E)MA 2", color=color.red                            )
plot(CLO == cu or CLO == clu ? _3 : na            , title="(E)MA 3", color= _3 == _1 ? color.lime : color.yellow)
plot(CLO == cu               ? _4 : na            , title="(E)MA 4", color= _4 == _2 ? color.red  : color.blue  )
plot(EX2 == co_HTF or EX2 == cla_HTF ? _1_HTF : na, title="(E)MA 1 HTF", color=color.lime, linewidth=2, transp=50)
plot(EX2 == co_HTF                   ? _2_HTF : na, title="(E)MA 2 HTF", color=color.red , linewidth=2, transp=50)
plot(CX2 == cu_HTF or CX2 == clu_HTF ? _3_HTF : na, title="(E)MA 3 HTF", color= _3_HTF == _1_HTF ? color.lime : color.yellow, linewidth=2, transp=50)
plot(CX2 == cu_HTF                   ? _4_HTF : na, title="(E)MA 4 HTF", color= _4_HTF == _2_HTF ? color.red  : color.blue  , linewidth=2, transp=50)

////////////////////////////////////////////////////////////////////////////////////////////

// RSI

rsi_       = rsi(src, ler)
rsi_HTF    = security(syminfo.tickerid, RSI_HTF,  rsi_)

////////////////////////////////////////////////////////////////////////////////////////////

// MACD

fast_ma    = sma_source ? sma(src, fst) : ema(src, fst)
slow_ma    = sma_source ? sma(src, slw) : ema(src, slw)
macd       = fast_ma - slow_ma
signal     = sma_signal ? sma(macd, sgn) : ema(macd, sgn)
hist       = macd - signal

macd_HTF   = security(syminfo.tickerid, MACD_HTF, macd  )
signal_HTF = security(syminfo.tickerid, MACD_HTF, signal)

////////////////////////////////////////////////////////////////////////////////////////////

extra = 
 EX  == none    ? true                   :
 EX  == mch     ? macd >  signal         :
 EX  == mch0    ? macd >  0              :
 EX  == sgh0    ? signal >  0            :
 false

cxtra = 
 CX  == none    ? true                   :
 CX  == mcl     ? macd <= signal         :
 CX  == mcl0    ? macd <= 0              :
 CX  == sgl0    ? signal <= 0            :
 false

EXTRA = 
 EX2 == none    ? true                   :
 EX2 == mch_HTF ? macd_HTF >  signal_HTF :
 EX2 == mch0HTF ? macd_HTF >  0          :
 EX2 == sgh0HTF ? signal_HTF >  0        :
 EX2 == co_HTF  ? _1_HTF >  _2_HTF       :
 EX2 == cla_HTF ? cl_HTF >  _1_HTF       : 
 false
 
CXTRA =
 CX2 == none    ? true                   :
 CX2 == mcl_HTF ? macd_HTF <= signal_HTF :
 CX2 == mcl0HTF ? macd_HTF <= 0          :
 CX2 == sgl0HTF ? signal_HTF <= 0        :
 CX2 == cu_HTF  ? _3_HTF <= _4_HTF       :
 CX2 == clu_HTF ? cl_HTF <= _3_HTF       : 
 false

RSI = rsi_ > EH and rsi_ <= EL and rsi_HTF > EH_HTF and rsi_HTF <= EL_HTF

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

BUY = 
 ENT == co    and TIME and extra and EXTRA and RSI ? _1 > _2        : 
 ENT == cla   and TIME and extra and EXTRA and RSI ? src > _1       : 
 ENT == rsi   and TIME and extra and EXTRA         ? RSI            : 
 ENT == mch   and TIME and extra and EXTRA and RSI ? macd > signal  : 
 ENT == mch0  and TIME and extra and EXTRA and RSI ? macd > 0       : 
 ENT == sgh0  and TIME and extra and EXTRA and RSI ? signal > 0     : 
 na

SELL = 
 CLO == cu    and TIME and cxtra and CXTRA and RSI ? _3 <= _4       : 
 CLO == clu   and TIME and cxtra and CXTRA and RSI ? src <= _3      : 
 CLO == rsi   and TIME and cxtra and CXTRA         ? RSI            :
 CLO == mcl   and TIME and cxtra and CXTRA and RSI ? macd <= signal : 
 CLO == mcl0  and TIME and cxtra and CXTRA and RSI ? macd <= 0      : 
 CLO == sgl0  and TIME and cxtra and CXTRA and RSI ? signal <= 0    : 
 na

if BUY
    if (Type == _S_)
        strategy.close("[S]")
    else
        strategy.entry("[B]", strategy.long)

if SELL
    if (Type == _L_)
        strategy.close("[B]")
    else
        strategy.entry("[S]", strategy.short)

strategy.exit("[SL/TP]", "[B]", stop= sl ? SL_ : na, limit= tp ? TP_ : na)

Mehr