Strategi Pembalikan Jalur Ganda
ChaoZhang
Ringkasan
Strategi reversal dengan pelacakan dua jalur adalah strategi reversal perdagangan yang menggabungkan Bollinger Bands, Keltner Channel, dan momentum indicator. Strategi ini mengidentifikasi kapan harga memasuki area kompresi melalui penilaian komprehensif dari Bollinger Bands dan Keltner Channel; sekaligus menggabungkan momentum indicator untuk menilai sinyal reversal harga, membentuk sinyal masuk dan keluar perdagangan.
Prinsip Strategi
Perhitungan rel tengah, rel atas, dan rel bawah di sabuk Brin
- SMA dengan close
- Jalur atas-bawah adalah jarak standar dari jalur tengah ditambah dengan pengurangan perkalian yang dapat disesuaikan
Perhitungan rel tengah, rel atas, dan rel bawah di Keltner Channel
- SMA dengan close
- Jalur atas dan bawah adalah ATR dari jalur tengah ditambah atau dikurangi dengan perkalian yang dapat disesuaikan
Menentukan apakah Brin Belt berada di bagian dalam Keltner Channel
- Kompresi terjadi ketika jalur atas Brin berada di bawah jalur atas Keltner dan jalur bawah Brin berada di atas jalur bawah Keltner.
- Sebaliknya, tidak kompresi
Hitung kemiringan kemiringan regressi linear antara close dengan titik tengah di sabuk Brin dan saluran Keltner
- Val > 0 menunjukkan close naik, val < 0 menunjukkan close turun
Perhitungan perubahan ROC dan EMA dari close
- Menentukan apakah tingkat perubahan mencapai batas yang dapat disesuaikan
- Jika di atas titik terendah, dianggap sedang dalam tren
Pada saat kompresi, lakukan lebih banyak saat val > 0 dan tingkat perubahan mencapai ambang batas
- Tidak, tidak, tidak.
Setting Stop Loss, Stop Stop Condition
Keunggulan Strategis
Dengan sistem dual track, ini akan meningkatkan akurasi pengamatan saat berbalik
Meningkatkan linear regression dan penilaian tingkat perubahan untuk menghindari sinyal pembalikan palsu
Pengaturan parameter yang dapat disesuaikan, fleksibel, dan dapat dioptimalkan untuk varietas yang berbeda
Menggunakan strategi stop loss dan stop loss untuk mengontrol risiko transaksi tunggal secara efektif
Data yang cukup untuk memverifikasi efektivitas strategi
Risiko Strategis dan Solusi
Kompresi dual-track tidak selalu menghasilkan pembalikan yang efektif
- Parameter optimasi, kondisi kompresi dual-rail yang ketat
Penembusan palsu menghasilkan sinyal yang salah
- Menambahkan penilaian regresi linier untuk menentukan arah tren
Stop loss terlalu longgar, terlalu banyak kerugian
- Optimalkan Stop Loss, Kendalikan Kerugian Tunggal
Periode pengujian Datenichinhalt
- Meningkatkan siklus pengujian ulang untuk validasi jangka panjang
Arah optimasi strategi
Pengaturan parameter yang dioptimalkan untuk lebih banyak varietas
Menambahkan titik-titik penolakan yang mendukung penilaian pembelajaran mesin
Meningkatkan Authenticitas Terobosan dengan Perubahan Volume Transaksi
Menambahkan analisis jangka waktu untuk menilai keberlanjutan tren
Optimalkan strategi stop loss dan pelacakan dinamis
Meringkaskan
Strategi reversal dengan pelacakan dua jalur secara keseluruhan adalah strategi reversal yang menggunakan indikator seperti Brin Belt Keltner Channel. Strategi ini dapat dioptimalkan dengan parameter, dapat disesuaikan dengan varietas yang berbeda, dan dapat mengidentifikasi keaslian terobosan sampai batas tertentu. Namun, perdagangan reversal sendiri masih memiliki risiko tertentu, yang memerlukan kombinasi lebih lanjut dengan teknologi seperti pembelajaran mesin untuk meningkatkan akurasi penilaian, sehingga 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)