Strategi Pembalikan Dwi Landasan
ChaoZhang
Gambaran keseluruhan
Strategi berbalik arah yang diikuti oleh dua trek adalah strategi berbalik arah yang menggabungkan jalur Brin, saluran Keltner, dan indikator momentum. Strategi ini menggunakan penilaian gabungan jalur Brin dan saluran Keltner untuk mengenal pasti masa harga memasuki kawasan pemampatan; dan dengan gabungan indikator momentum untuk menentukan isyarat berbalik arah harga, membentuk isyarat masuk dan keluar perdagangan.
Prinsip Strategi
Mengira laluan tengah, atas, dan bawah di dalam tali pinggang Brin
- Trajek tengah menggunakan SMA yang dekat
- Jalur atas dan bawah adalah perbezaan piawaian dari jalur tengah ditambah dengan pengurangan ganda yang boleh disesuaikan
Mengira laluan tengah, atas, dan bawah dalam saluran Keltner
- Trajek tengah menggunakan SMA yang dekat
- Laluan atas dan bawah ialah ATR dari laluan tengah ditambah dengan pengurangan satu kelipatan yang boleh disesuaikan
Menentukan sama ada Brin Belt terletak di bahagian dalam Keltner Channel
- Apabila jalur atas Brin lebih rendah daripada jalur atas Keltner, dan jalur bawah Brin lebih tinggi daripada jalur bawah Keltner, dianggap berada dalam pemampatan
- Sebaliknya, bukan pemampatan.
Hitung kemiringan kemerosotan linear untuk titik dekat dengan titik tengah dalam Keltner Channel
- Val > 0 menunjukkan bahawa hampir naik, dan val < 0 menunjukkan bahawa hampir turun
Mengira kadar perubahan ROC dan EMA
- Menentukan sama ada kadar perubahan mencapai tahap yang boleh diselaraskan
- Jika melebihi nilai terendah, ia dianggap dalam trend
Pada masa pemampatan, apabila val > 0 dan kadar perubahan mencapai had
- Sebaliknya kosongkan
Tetapkan keadaan hentikan dan hentikan
Kelebihan Strategik
Meningkatkan ketepatan dalam menentukan masa berbalik dengan menggunakan sistem dua hala
Menambah pengiraan regresi linear dan kadar perubahan untuk mengelakkan isyarat pembalikan palsu
Tetapan parameter yang boleh diselaraskan dan boleh dioptimumkan untuk pelbagai jenis
Menggunakan strategi Hentikan Kerosakan untuk Mengendalikan Risiko Perdagangan Tunggal
Data pengesanan mencukupi untuk mengesahkan keberkesanan strategi
Risiko Strategik dan Penyelesaian
Kompresi dua hala tidak semestinya menghasilkan pembalikan yang berkesan
- Parameter pengoptimuman, syarat pemampatan dua hala yang ketat
Penembusan palsu menghasilkan isyarat yang salah
- Menambah penilaian regresi linear untuk menentukan arah trend
Tetapan stop loss terlalu longgar, kerugian sekali gus terlalu besar
- Optimumkan titik henti, kawalan ketat kerugian tunggal
Tempoh ujian Datenichinhalt
- Menambah pusingan pengesanan untuk mengesahkan keberkesanan jangka panjang
Arah pengoptimuman strategi
Pengaturan parameter yang dioptimumkan untuk lebih banyak varieti
Tambahan penilaian pembelajaran mesin menyokong titik-titik rintangan
Meningkatkan Keaslian Terobosan Bersama Perubahan Jumlah Perdagangan
Menambah analisis jangka masa untuk menilai trend yang berterusan
Mengoptimumkan strategi hentian kerugian dan pelacakan dinamik
ringkaskan
Strategi pembalikan jejak dua hala secara keseluruhan adalah strategi pembalikan yang menggunakan indikator seperti saluran Keltner Brin. Strategi ini dapat dioptimumkan dengan parameter, dapat disesuaikan dengan pelbagai jenis, dan dapat mengenal pasti keaslian terobosan hingga tahap tertentu. Tetapi perdagangan pembalikan masih mempunyai risiko tertentu, dan memerlukan penggabungan lebih lanjut dengan teknologi seperti pembelajaran mesin untuk meningkatkan ketepatan penghakiman, yang menghasilkan keuntungan tambahan yang lebih stabil.
/*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)