Dual-Track-Umkehrstrategie
ChaoZhang
Überblick
Die Doppelbahn-Tracking-Umkehrstrategie ist eine Umkehrhandelsstrategie, die Brin-Band, Keltner-Kanal und Dynamometer kombiniert. Die Strategie identifiziert die Zeit, in der der Preis in die Kompressionszone eintritt, durch die Kombination von Brin-Band- und Keltner-Kanal-Urteilen.
Strategieprinzip
Berechnung der mittleren, oberen und unteren Gleise im Brin-Band
- Mittelschiene mit Close-SMA
- Der Standarddifferenz zwischen den oberen und unteren Bahnen ist der Standarddifferenz zwischen den mittleren Bahnen plus und minus ein einstellbares Vielfaches
Berechnung der mittleren, oberen und unteren Schienen im Keltner-Kanal
- Mittelschiene mit Close-SMA
- Auf- und Abfahrt ist der ATR des Mittelbahn plus oder minus ein verstellbares Multiplikator
Beurteilung, ob sich die Brin-Band auf der Innenseite des Keltner-Kanals befindet
- Wenn die Brin-Band-Oberbahn niedriger als die Keltner-Oberbahn ist und die Brin-Band-Unterbahn höher als die Keltner-Unterbahn ist, wird als Kompression angesehen
- Im Gegenteil, nicht komprimieren.
Berechnen Sie die Schräglage der linearen Regression von close und dem Mittelpunkt des Brin-Bandes und des Keltner-Kanals
- Val > 0 bedeutet, dass die Close steigt, val < 0 bedeutet, dass die Close sinkt
Berechnen Sie die Veränderungsrate des Closes ROC und seine EMA
- Beurteilen, ob die Veränderungsrate einen anpassbaren Schwellenwert erreicht
- Wenn der Wert über der Schwelle liegt, ist er im Trend.
Bei der Komprimierung wird mehr getan, wenn val > 0 ist und die Veränderungsrate die Schwelle erreicht
- Stattdessen machen sie es leer.
Setzen Sie die Stop-Loss- und Stop-Stop-Bedingungen
Strategische Vorteile
Verbesserte Genauigkeit bei der Bestimmung des Wendepunkts in Kombination mit einem Doppelschienensystem
Erhöhung der linearen Regression und der Veränderungsrate, um falsche Umkehrsignale zu vermeiden
Anpassbare Parameter-Einstellungen, die flexibel für verschiedene Sorten optimiert werden können
Ein Stop-Loss-Stopp-Strategie, um das Risiko eines einzelnen Handels effektiv zu kontrollieren
Die Daten sind ausreichend, um die Wirksamkeit der Strategie zu überprüfen.
Strategische Risiken und Lösungen
Doppelschienenkomprimierung führt nicht unbedingt zu einer effektiven Umkehrung
- Optimierungsparameter, strenge Doppelspur-Kompressionsbedingungen
Falsche Durchbrüche erzeugen falsche Signale
- Erhöhung der linearen Regressionsbeurteilung, um die Trendrichtung zu bestimmen
Die Stop-Loss-Einstellungen sind zu locker und die Einmalverluste zu hoch.
- Optimierung der Stop-Loss-Punkte und strenge Kontrolle der Einmalverluste
Testperiode Datenichinhalt
- Mehr Testzyklen zur Überprüfung der Langzeitwirksamkeit
Richtung der Strategieoptimierung
Optimierte Parameter-Einstellungen für mehr Sorten
Mehr Machine-Learning-Urteile unterstützen die Widerstandskriterien
Durchbruch-Authentizität in Kombination mit Veränderungen des Handelsvolumens
Die Analyse über die Zeiträume hinzufügen, um die Beständigkeit der Trends zu beurteilen.
Optimierung der Stop-Loss-Strategie und Dynamikverfolgung
Zusammenfassen
Die Doppelspur-Tracking-Umkehrstrategie ist im Allgemeinen eine Umkehrstrategie, die Indikatoren wie den Brin-Band-Keltner-Kanal nutzt. Die Strategie kann durch Parameteroptimierung an verschiedene Sorten angepasst werden, um die Authentizität von Durchbrüchen zu einem gewissen Grad zu erkennen. Die Umkehrgeschäfte selbst bergen jedoch ein gewisses Risiko und erfordern eine weitere Kombination von Technologien wie maschinellem Lernen, um die Genauigkeit der Beurteilung zu verbessern und so einen stabileren Zusatzerlös zu erzielen.
/*backtest
start: 2023-10-02 00:00:00
end: 2023-11-01 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
// Credit for the initial Squeeze Momentum code to LazyBear, rate of change code is from Kiasaki
strategy("Squeeze X BF 🚀", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.0)
/////////////// Time Frame ///////////////
testStartYear = input(2012, "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(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)
testPeriod() => true
/////////////// Squeeeeze ///////////////
length = input(20, title="BB Length")
mult = input(2.0,title="BB MultFactor")
lengthKC=input(22, title="KC Length")
multKC = input(1.5, title="KC MultFactor")
useTrueRange = input(true, title="Use TrueRange (KC)")
// Calculate BB
source = close
basis = sma(source, length)
dev = mult * stdev(source, length)
upperBB = basis + dev
lowerBB = basis - dev
// Calculate KC
ma = sma(source, lengthKC)
range = useTrueRange ? tr : (high - low)
rangema = sma(range, lengthKC)
upperKC = ma + rangema * multKC
lowerKC = ma - rangema * multKC
sqzOn = (lowerBB > lowerKC) and (upperBB < upperKC)
sqzOff = (lowerBB < lowerKC) and (upperBB > upperKC)
noSqz = (sqzOn == false) and (sqzOff == false)
val = linreg(source - avg(avg(highest(high, lengthKC), lowest(low, lengthKC)),sma(close,lengthKC)), lengthKC,0)
///////////// Rate Of Change /////////////
roclength = input(30, minval=1), pcntChange = input(7, minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Strategy ///////////////
long = val > 0 and isMoving()
short = val < 0 and isMoving()
last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
sl_inp = input(100.0, title='Stop Loss %') / 100
tp_inp = input(5000.0, title='Take Profit %') / 100
take_level_l = strategy.position_avg_price * (1 + tp_inp)
take_level_s = strategy.position_avg_price * (1 - tp_inp)
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("Long", strategy.long, when=long)
strategy.entry("Short", strategy.short, when=short)
strategy.exit("Long Ex", "Long", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
strategy.exit("Short Ex", "Short", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
bcolor = iff(val > 0, iff(val > nz(val[1]), color.lime, color.green), iff(val < nz(val[1]), color.red, color.maroon))
plot(val, color=bcolor, linewidth=4)
bgcolor(not isMoving() ? color.white : long ? color.lime : short ? color.red : na, transp=70)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=50)
hline(0, color = color.white)