Handelsstrategie zur Umkehrung der Mittelwerte auf der Grundlage gleitender Durchschnitte

Schriftsteller:ChaoZhang, Datum: 2023-10-26
Tags:

Übersicht

Die durchschnittliche Umkehrhandelsstrategie basiert auf der Abweichung des Preises von einem gleitenden Durchschnitt, um Handelsentscheidungen zu treffen. Sie nutzt die kurzfristige Abweichung und das langfristige Umkehrmuster der Preise zum Durchschnitt, indem sie Positionen einstellt, wenn die Preise deutlich unter oder über dem gleitenden Durchschnitt liegen, und Positionen schließt, wenn die Preise zurückkehren.

Strategie Logik

Die Strategie berechnet zunächst einen gleitenden Durchschnitt über einen bestimmten Zeitraum, um die langfristige Kursentwicklung darzustellen, und bestimmt dann den Zeitpunkt und die Größe der Positionen anhand der Abweichung des Preises vom gleitenden Durchschnitt.

Wenn der Preis um einen bestimmten Prozentsatz unter den gleitenden Durchschnitt fällt, signalisiert dies, dass der Preis von dem langfristigen Trend abweicht. In diesem Fall werden lange Positionen allmählich mit zunehmender Größe aufgebaut, wenn sich die Abweichung vergrößert. Wenn der Preis über den gleitenden Durchschnitt zurückspringt, was auf eine Rückkehr zum Durchschnitt hindeutet, werden die langen Positionen für die Gewinnentnahme geschlossen.

Wenn der Kurs den gleitenden Durchschnitt um einen Schwellenwert übersteigt, werden Short-Positionen aufgebaut, und wenn der Kurs wieder in Richtung des gleitenden Durchschnitts fällt, werden die Short-Positionen mit Gewinn geschlossen.

Analyse der Vorteile

Nutzen Sie die Fähigkeit der gleitenden Durchschnittswerte, den langfristigen Gleichgewichtstrend der Aktienkurse zu verfolgen und die Haupttrendrichtung zu identifizieren.
Verringern Sie die durchschnittlichen Kosten, indem Sie in Positionen skalieren und bessere Einstiegspreise erhalten.
Einführung einer stufenweisen Gewinnentnahme, um Gewinn auf verschiedenen Ebenen der mittleren Umkehrung zu sichern und Risiken zu senken.
Kontrollpositionsgröße in einem festen Prozentsatz zur Begrenzung der Größe einzelner Verluste.
Flexible Parameter-Einstellungen wie beispielsweise gleitende Durchschnittszeit und Positionsgröße je nach Produkt.

Risikoanalyse

Häufiger Stop-Loss bei Preisschwankungen. Kann den Stop-Loss-Bereich erweitern oder andere Filter hinzufügen.
Ein starker Trend kann den gleitenden Durchschnitt durchbrechen und nicht bei der mittleren Umkehrung schließen können.
Bei falschen Parameter-Einstellungen kann es zu übermäßig aggressiven Eintritten oder Stopps kommen.
Bei der Optimierung der Parameter sollten Kostenfaktoren berücksichtigt werden.

Verbesserungsrichtlinien

Optimierung der gleitenden Durchschnittszeit, um sich an die Merkmale des Produkts anzupassen.
Optimieren Sie die Positionsgröße, um Risiko und Rendite auszugleichen.
Hinzufügen anderer technischer Filter, um unnötige Transaktionen zu vermeiden.
Einbeziehung von Volatilitätsmaßnahmen zur Anpassung der Positionsgröße anhand der Marktschwankungen.
Einführung einer Skalierung der Gewinnziele zur Verringerung des Risikos und Erhöhung der Rendite.

Schlussfolgerung

Die Mittelumkehrstrategie nutzt die Gleichgewichtsumkehrtendenz von Aktien, indem sie bei Abweichung vom gleitenden Durchschnitt eingeht und bei Umkehr Gewinn erzielt. Mit angemessener Parameteranpassung und Filtern kann sie sich an Marktveränderungen anpassen und unter Risikokontrolle gute Renditen erzielen. Die Strategie beinhaltet sowohl Trendverfolgung als auch Risikomanagement, was es für Anleger lohnt, zu recherchieren und anzuwenden.

/*backtest
start: 2022-10-19 00:00:00
end: 2023-10-25 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("YJ Mean Reversion", overlay=true)
//Was designed firstly to work on an index like the S&P 500 , which over time tends to go up in value. 
//Avoid trading too frequently (e.g. Daily, Weekly), to avoid getting eaten by fees. 
//If you change the underlying asset, or time frame, tweaking the moving average may be necessary. 
//Can work with a starting capital of just $1000, optimise the settings as necessary. 
//Accepts floating point values for the amount of units to purchase (e.g. Bitcoin ). 
//If price of units exceeds available capital, script will cancel the buy. 
//Adjusted the input parameters to be more intuitive.

//input variables
movingAverage = input(title="Moving Average (bars)", type=input.integer, defval=28, minval=1, maxval=1000)
//riskPercentage = input(title="Amount to Risk (%)", type=input.integer, defval=1, minval=1, maxval=50)
deviation = input(title="Deviation Increment (%)", type=input.float, defval=5, minval=0.01, maxval=100) / 100
unitsLevel1 = input(title="Level 1 (units)", type=input.float, defval=1, minval=0.0001, maxval=10000)
unitsLevel2 = input(title="Level 2 (units)", type=input.float, defval=2, minval=0.0001, maxval=10000)
unitsLevel3 = input(title="Level 3 (units)", type=input.float, defval=4, minval=0.0001, maxval=10000)
unitsLevel4 = input(title="Level 4 (units)", type=input.float, defval=8, minval=0.0001, maxval=10000)
unitsLevel5 = input(title="Level 5 (units)", type=input.float, defval=16, minval=0.0001, maxval=10000)

//moving average and ma slope (use on weekly chart)
ma = sma(close, movingAverage)
//sl = ma > ma[4]

//units to buy
//amount = riskPercentage / 100 * (strategy.initial_capital + strategy.netprofit)
//units = floor(amount / close)

//mode 1
//strategy.order("buy", true, 1, when = (close < 0.95 * ma) and (strategy.position_size < 10))
//strategy.order("sell", false, strategy.position_size, when = (close > 1.05 * ma) and (strategy.position_size > 0))

//mode 2
//strategy.order("buy", true, 1, when = close < 0.8 * ma)
//strategy.order("sell", false, strategy.position_size, when = (close > 310) and (strategy.position_size > 0))

//mode 3
//strategy.order("buy", true, 1, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("buy", true, 2, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("buy", true, 4, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("buy", true, 8, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("buy", true, 16, when = (close < 0.75 * ma))
//strategy.order("sell", false, strategy.position_size, when = (close > 310) and (strategy.position_size > 0))

//mode 4
//strategy.order("buy", true, 1, when = (close < 0.98 * ma) and (close > 0.96 * ma) and (sl))
//strategy.order("buy", true, 2, when = (close < 0.96 * ma) and (close > 0.94 * ma) and (sl))
//strategy.order("buy", true, 4, when = (close < 0.94 * ma) and (close > 0.92 * ma) and (sl))
//strategy.order("buy", true, 8, when = (close < 0.92 * ma) and (close > 0.90 * ma) and (sl))
//strategy.order("buy", true, 16, when = (close < 0.90 * ma) and (sl))
//strategy.order("sell", false, strategy.position_size, when = (close > 310) and (strategy.position_size > 0))

//mode 5
//strategy.order("buy", true, 1, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("buy", true, 2, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("buy", true, 4, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("buy", true, 8, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("buy", true, 16, when = (close < 0.75 * ma))

//strategy.order("sell", false, 1, when = (close > 1.05 * ma) and (close < 1.1 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 2, when = (close > 1.1 * ma) and (close < 1.15 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 4, when = (close > 1.15 * ma) and (close < 1.2 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 8, when = (close > 1.2 * ma) and (close < 1.25 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 16, when = (close > 1.25 * ma) and (close < 1.3 * ma) and (strategy.position_size > 0))

//mode 6
//strategy.order("B1", true, unitsLevel1 * units, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("B2", true, unitsLevel2 * units, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("B3", true, unitsLevel3 * units, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("B4", true, unitsLevel4 * units, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("B5", true, unitsLevel5 * units, when = (close < 0.75 * ma))

//strategy.order("S1", false, unitsLevel1 * units, when = (close > 1.05 * ma) and (close < 1.1 * ma) and (strategy.position_size > 0))
//strategy.order("S2", false, unitsLevel2 * units, when = (close > 1.1 * ma) and (close < 1.15 * ma) and (strategy.position_size > 0))
//strategy.order("S3", false, unitsLevel3 * units, when = (close > 1.15 * ma) and (close < 1.2 * ma) and (strategy.position_size > 0))
//strategy.order("S4", false, unitsLevel4 * units, when = (close > 1.2 * ma) and (close < 1.25 * ma) and (strategy.position_size > 0))
//strategy.order("S5", false, unitsLevel5 * units, when = (close > 1.25 * ma) and (close < 1.3 * ma) and (strategy.position_size > 0))

//mode 7
//strategy.order("B1", true, units, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("B2", true, units, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("B3", true, units, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("B4", true, units, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("B5", true, units, when = (close < 0.75 * ma))

//strategy.order("S1", false, units, when = (close > 1.05 * ma) and (close < 1.1 * ma) and (strategy.position_size > 0))
//strategy.order("S2", false, units, when = (close > 1.1 * ma) and (close < 1.15 * ma) and (strategy.position_size > 0))
//strategy.order("S3", false, units, when = (close > 1.15 * ma) and (close < 1.2 * ma) and (strategy.position_size > 0))
//strategy.order("S4", false, units, when = (close > 1.2 * ma) and (close < 1.25 * ma) and (strategy.position_size > 0))
//strategy.order("S5", false, units, when = (close > 1.25 * ma) and (close < 1.3 * ma) and (strategy.position_size > 0))

//banding calculations
aH = 1.0 - deviation
aL = aH - deviation
bH = aL
bL = bH - deviation
cH = bL
cL = cH - deviation
dH = cL
dL = dH - deviation
eH = dL
strategy.initial_capital = 50000
//mode 8
strategy.order("B1", true, unitsLevel1, when = (close < aH * ma) and (close > aL * ma) and (unitsLevel1 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B2", true, unitsLevel2, when = (close < bH * ma) and (close > bL * ma) and (unitsLevel2 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B3", true, unitsLevel3, when = (close < cH * ma) and (close > cL * ma) and (unitsLevel3 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B4", true, unitsLevel4, when = (close < dH * ma) and (close > dL * ma) and (unitsLevel4 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B5", true, unitsLevel5, when = (close < eH * ma) and (unitsLevel5 * close < (strategy.initial_capital + strategy.netprofit)))

//banding calculations
fL = 1.0 + deviation
fH = fL + deviation
gL = fH
gH = gL + deviation
hL = gH
hH = hL + deviation
iL = hH
iH = iL + deviation
jL = iH

strategy.order("S1", false, unitsLevel1, when = (close > fL * ma) and (close < fH * ma) and (strategy.position_size > 0))
strategy.order("S2", false, unitsLevel2, when = (close > gL * ma) and (close < gH * ma) and (strategy.position_size > 0))
strategy.order("S3", false, unitsLevel3, when = (close > hL * ma) and (close < hH * ma) and (strategy.position_size > 0))
strategy.order("S4", false, unitsLevel4, when = (close > iL * ma) and (close < iH * ma) and (strategy.position_size > 0))
strategy.order("S5", false, unitsLevel5, when = (close > jL * ma) and (strategy.position_size > 0))

plot(ma, color=#666666, linewidth=5)

Mehr