Die Ressourcen sind geladen. Beförderung...

Mehrzeitrahmen-Strategie für bewegliche Durchschnittswerte

Schriftsteller:ChaoZhang, Datum: 2024-02-19 15:41:29
Tags:

Übersicht

Die Multi Timeframe Moving Average Crossover Strategie ist eine algorithmische Handelsstrategie, die bewegliche Durchschnitts-Crossover-Signale zwischen verschiedenen Zeitrahmenperioden verwendet, um die Trendrichtung zu bestimmen.

Strategie Logik

Diese Strategie berechnet den CCI-Indikator über verschiedene Zeiträume hinweg, um die Marktentwicklung zu bestimmen, kombiniert mit MACD-Signalen, um Goldkreuze und Todkreuze zu lokalisieren, und verwendet schließlich den ATR-Indikator, um Stop-Loss-/Take-Profit-Levels festzulegen, um niedrig zu kaufen und hoch zu verkaufen.

Es wird zunächst der 20-Perioden-CCI berechnet, um bullische oder bärische Trends zu beurteilen. Dann wird überprüft, ob sich MACD-Linien kreuzen, um Handelssignale zu identifizieren. Als nächstes wird ATR verwendet, um Trailing-Stops zu generieren, um Gewinne zu erzielen. Schließlich werden alle Signale konsolidiert, um die Ein- und Ausstiegssignale zu generieren.

Vorteile

Mehrfache Indikatorenverbesserung der Signalgenauigkeit

Die Kombination von CCI, MACD und ATR erhöht die Zuverlässigkeit der Handelssignale, indem sie gemeinsam Trend, Dynamik und Volatilität beurteilen.
Mehrzeitanalysen erfassen den Marktrhythmus

Der langfristige CCI erfasst den allgemeinen Trend, während der MACD mit höherer Frequenz lokale Wendepunkte lokalisiert, so dass die Strategie große Marktschwankungen nutzen kann.
Die ATR-Rückfahrstopp-Steuerung ist risikowirksam

Der auf ATR basierende Stop-Loss kann sich an die Marktvolatilität anpassen, während seine Trailing-Funktion die Gewinne weiter verringert, wenn sich der Markt günstig bewegt.

Risiken

Beschränkter Optimierungsraum

Die meisten Parameter verfügen über einen engen Feinabstimmungsraum, wodurch leicht ein Leistungsengpass erreicht wird.
Erhöhte Rechenlast

Mehrere Indikatoren, die zusammenlaufen, können die Rechenlast erhöhen und Verzögerungen beim Hochfrequenzhandel verursachen.
Häufige Signale, begrenzte Risikokontrolle

Die Signale können häufig sein, während sich die Risikokontrolle hauptsächlich auf den ATR Trailing Stop stützt, der Einschränkungen gegen extreme Bewegungen aufweist.

Verbesserungen

Anwendung von maschinellem Lernen für effizientere Parameter-Tuning

Bayesische Optimierung, genetische Algorithmen usw. können eine intelligentere und effizientere Parameter-Tuning ermöglichen.
Hinzufügen von funktionalen Indikatoren zur Verbesserung der Anpassungsfähigkeit

Die Einbeziehung anderer Indikatoren wie Volatilität, Volumen, Stimmung kann die Strategie robuster und flexibler machen.
Stärkung des Risikomanagements für eine bessere Stabilität

Es können wissenschaftlichere Stop-Loss-Regeln entwickelt werden, und weitere Module wie Positionsgrößen können zur Absicherung vor Extremereignissen beitragen.

Schlussfolgerung

Die Multi Timeframe Moving Average Crossover Strategy nutzt die Fähigkeiten von CCI, MACD und ATR, um zuverlässige Trend-Erfassung und effiziente Risikokontrolle zu erreichen. Sie berücksichtigt Trend, Momentum und Volatilität, um genaue Signale zu generieren, Marktrhythmen zu erfassen und Risiken zu managen. Obwohl einige Aspekte wie Parameter-Tuning, Rechenlast und Risikokontrolle weiter verbessert werden können, ist es trotzdem ein solides algorithmisches Handelssystem. Mit einigen Verbesserungen mit maschinellem Lernen, mehr Indikatoren und einem besseren Risikomanagement kann seine Leistung neue Ebenen erreichen.

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

//@version=5
strategy('smplondonclinic Strategy', shorttitle='SMPLC Strategy', overlay=true, pyramiding = 0, process_orders_on_close = true, default_qty_type = strategy.percent_of_equity, default_qty_value = 100)

direction   = input.string(title='Entry Direction', defval='Long', options=['Long', 'Short', 'Both'],group = "Strategy Entry Direction")

TPPerc = input.float(title='Take Profit (%)', minval=0.0, step=0.1, defval=0.5, group='Strategy TP & SL')
SLPerc = input.float(title='Stop Loss (%)', minval=0.0, step=0.1, defval=0.5, group='Strategy TP & SL')

period = input(20, 'CCI period',group = "TREND MAGIC")
coeff = input(1, 'ATR Multiplier',group = "TREND MAGIC")
AP = input(5, 'ATR Period',group = "TREND MAGIC")
ATR = ta.sma(ta.tr, AP)
srctm = close
upT = low - ATR * coeff
downT = high + ATR * coeff
MagicTrend = 0.0
MagicTrend := ta.cci(srctm, period) >= 0 ? upT < nz(MagicTrend[1]) ? nz(MagicTrend[1]) : upT : downT > nz(MagicTrend[1]) ? nz(MagicTrend[1]) : downT
color1 = ta.cci(srctm, period) >= 0 ? #0022FC : #FC0400
plot(MagicTrend, color=color1, linewidth=3)
tmb = ta.cci(srctm, period) >= 0 and close>MagicTrend
tms = ta.cci(srctm, period) <= 0 and close<MagicTrend

//MACD

res           = input.timeframe("",  "Indicator TimeFrame", group = "MACD")
fast_length   = input.int(title="Fast Length", defval=12, group = "MACD")
slow_length   = input.int(title="Slow Length", defval=26, group = "MACD")
src           = input.source(title="Source", defval=close, group = "MACD")
signal_length = input.int(title="Signal Smoothing", minval = 1, maxval = 999, defval = 9, group = "MACD")
sma_source    = input.string(title="Oscillator MA Type", defval="EMA", options=["SMA", "EMA"], group = "MACD")
sma_signal    = input.string(title="Signal Line MA Type", defval="EMA", options=["SMA", "EMA"], group = "MACD")

fast_ma = request.security(syminfo.tickerid, res, sma_source == "SMA" ? ta.sma(src, fast_length) : ta.ema(src, fast_length))
slow_ma = request.security(syminfo.tickerid, res, sma_source == "SMA" ? ta.sma(src, slow_length) : ta.ema(src, slow_length))
macd = fast_ma - slow_ma
signal = request.security(syminfo.tickerid, res, sma_signal == "SMA" ? ta.sma(macd, signal_length) : ta.ema(macd, signal_length))
hist = macd - signal

trend_up   = macd > signal
trend_dn   = macd < signal
cross_UP   = signal[1] >= macd[1] and signal < macd
cross_DN   = signal[1] <= macd[1] and signal > macd
cross_UP_A = (signal[1] >= macd[1] and signal < macd) and macd > 0
cross_DN_B = (signal[1] <= macd[1] and signal > macd) and macd < 0


//UT Bot

srcut = close
showut = input.bool(false, 'Show UT Bot Labels', group = "UT BOT")
keyvalue = input.float(2, title='Key Vaule. \'This changes the sensitivity\'', step=.5, group = "UT BOT")
atrperiod = input(7, title='ATR Period', group = "UT BOT")
xATR = ta.atr(atrperiod)
nLoss = keyvalue * xATR

xATRTrailingStop = 0.0
iff_1 = srcut > nz(xATRTrailingStop[1], 0) ? srcut - nLoss : srcut + nLoss
iff_2 = srcut < nz(xATRTrailingStop[1], 0) and srcut[1] < nz(xATRTrailingStop[1], 0) ? math.min(nz(xATRTrailingStop[1]), srcut + nLoss) : iff_1
xATRTrailingStop := srcut > nz(xATRTrailingStop[1], 0) and srcut[1] > nz(xATRTrailingStop[1], 0) ? math.max(nz(xATRTrailingStop[1]), srcut - nLoss) : iff_2

pos = 0
iff_3 = srcut[1] > nz(xATRTrailingStop[1], 0) and srcut < nz(xATRTrailingStop[1], 0) ? -1 : nz(pos[1], 0)
pos := srcut[1] < nz(xATRTrailingStop[1], 0) and srcut > nz(xATRTrailingStop[1], 0) ? 1 : iff_3

xcolor = pos == -1 ? color.red : pos == 1 ? color.green : color.blue

//plot(xATR, color=xcolor, title='Trailing Stop')
buy = ta.crossover(srcut, xATRTrailingStop)
sell = ta.crossunder(srcut, xATRTrailingStop)
barcolor = srcut > xATRTrailingStop

plotshape(showut ? buy:na, title='Buy', text='Buy', style=shape.labelup, location=location.belowbar, color=color.new(color.green, 0), textcolor=color.new(color.white, 0), size=size.tiny)
plotshape(showut ? sell:na, title='Sell', text='Sell', style=shape.labeldown, color=color.new(color.red, 0), textcolor=color.new(color.white, 0), size=size.tiny)

//barcolor(barcolor ? color.green : color.red)

goLong = buy and tmb and cross_UP
goShort = sell and tms and cross_DN

plotshape(goLong, location=location.bottom, style=shape.triangleup, color=color.lime, size=size.small)
plotshape(goShort, location=location.top, style=shape.triangledown, color=color.red, size=size.small)

percentAsPoints(pcnt) =>
    strategy.position_size != 0 ? math.round(pcnt / 100.0 * strategy.position_avg_price / syminfo.mintick) : float(na)

percentAsPrice(pcnt) =>
    strategy.position_size != 0 ? (pcnt / 100.0 + 1.0) * strategy.position_avg_price : float(na)

current_position_size = math.abs(strategy.position_size)
initial_position_size = math.abs(ta.valuewhen(strategy.position_size[1] == 0.0, strategy.position_size, 0))

TP = strategy.position_avg_price + percentAsPoints(TPPerc) * syminfo.mintick * strategy.position_size / math.abs(strategy.position_size)
SL = strategy.position_avg_price - percentAsPoints(SLPerc) * syminfo.mintick * strategy.position_size / math.abs(strategy.position_size)

var long = false
var short = false

if direction == 'Long' 
    long := goLong
    short := false

if direction == 'Short'
    short := goShort
    long := false

if direction == 'Both' 
    long := goLong
    short := goShort

if long and strategy.opentrades == 0
    strategy.entry(id='Long', direction=strategy.long)

if short and strategy.opentrades == 0
    strategy.entry(id='Short', direction=strategy.short)

if strategy.position_size > 0

    strategy.exit('TPSL', from_entry='Long', qty=initial_position_size, limit=TP, stop=SL)

if strategy.position_size < 0

    strategy.exit('TPSL2', from_entry='Short', qty=initial_position_size, limit=TP, stop=SL)

Mehr