Strategi Mengikuti Tren Saluran Gravitasi Sentral
ChaoZhang
Ringkasan
Strategi ini menggabungkan indikator gravitasi pusat dan indikator saluran SSL untuk menilai dan melacak tren harga, termasuk dalam kategori strategi pelacakan tren. Selain itu, ATR stop loss dinamis dikombinasikan untuk mengendalikan risiko.
Prinsip Strategi
Indikator gravitasi pusat perhitungan, di mana rel atas dan rel bawah adalah batas tren kenaikan dan penurunan harga.
Perhitungan indikator saluran SSL, saluran internal untuk zona konsolidasi, saluran eksternal untuk arah tren.
Ketika harga menembus jalur atau saluran, itu akan dianggap sebagai tren naik dan melakukan lebih banyak. Ketika harga menembus jalur atau saluran, itu akan dianggap sebagai tren turun dan melakukan lebih banyak.
Stop loss menggunakan ATR dinamis untuk melacak stop loss saat memegang posisi, untuk menghindari kerugian berkembang.
Ini adalah sinyal perdagangan yang sebenarnya, yang dikombinasikan dengan periode pengembalian.
Strategi ini menggunakan dua indikator sekaligus untuk menentukan arah tren, satu untuk menentukan breakout dan satu untuk mengkonfirmasi tren, keduanya dapat meningkatkan akurasi penilaian. Stop loss dinamis dapat menyesuaikan stop loss sesuai dengan amplitudo fluktuasi pasar, dan merupakan alat kontrol risiko yang sangat praktis.
Analisis Keunggulan
Dengan menggunakan dua indikator untuk menilai tren, dapat meningkatkan akurasi.
Indikator gravitasi pusat sensitif terhadap perubahan tren, dan saluran SSL menilai arah tren.
Stop loss ATR dinamis menyesuaikan stop loss dalam waktu nyata sesuai dengan fluktuasi pasar, memiliki fleksibilitas.
Peraturan-peraturan strategi yang sederhana dan jelas, mudah dipahami dan diterapkan.
Ada banyak ruang untuk mengoptimalkan parameter, yang dapat disesuaikan dengan pasar yang berbeda.
Fungsi pengembalian sudah tersedia untuk memverifikasi keefektifan strategi.
Analisis risiko
Indikator gravitasi pusat dan saluran SSL dapat mengalami kegagalan, menyebabkan kesalahan sinyal perdagangan. Indikator lain dapat ditambahkan untuk konfirmasi.
Stop loss yang dinamis mungkin terlalu radikal, dan stop loss yang sesuai dapat dilepaskan.
Pemilihan periode pelacakan yang tidak tepat dapat menyebabkan efektivitas strategi yang buruk dan perlu dilakukan pelacakan untuk fase pasar yang berbeda.
Konsekuensi dari biaya transaksi harus diperhitungkan.
Arah optimasi
Uji kombinasi parameter yang berbeda untuk menemukan pasangan parameter yang optimal.
Optimalkan siklus ATR dan parameter perkalian untuk stop loss dinamis.
Masukkan indikator lain untuk memfilter sinyal, seperti MACD, KDJ, dll.
Menambahkan model pembelajaran mesin untuk membantu menentukan arah tren.
Mengoptimalkan pengelolaan dana, mengatur kontrol posisi.
Adapun parameter yang disesuaikan dan dioptimalkan untuk varietas tertentu.
Meringkaskan
Strategi ini menggabungkan indikator gravitasi pusat dan indikator SSL channel untuk menilai tren, menggunakan ATR yang dinamis untuk mengendalikan risiko kerugian, dan merupakan strategi pelacakan tren yang dapat diterapkan. Dengan pengoptimalan parameter, pengenalan indikator lain, dan pembelajaran mesin, stabilitas strategi dan efektivitas pertempuran dapat ditingkatkan. Secara keseluruhan, strategi ini memiliki kepraktisan dan skalabilitas yang kuat, dan merupakan ide strategi yang layak untuk dikutip.
/*backtest
start: 2023-08-19 00:00:00
end: 2023-09-13 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
// Thanks to HPotter for the original code for Center of Gravity Backtest
strategy("CoG SSL BF 🚀", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)
/////////////// Time Frame ///////////////
_0 = input(false, "════════ Test Period ═══════")
testStartYear = input(2017, "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
/////////////// SSL Channels ///////////////
_1 = input(false, "═════════ SSL ══════════")
len1=input(title="SMA Length 1", defval=12)
len2=input(title="SMA Length 2", defval=13)
smaHigh = sma(high, len1)
smaLow = sma(low, len2)
Hlv = 0
Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? smaHigh : smaLow
sslUp = Hlv < 0 ? smaLow : smaHigh
///////////// Center of Gravity /////////////
_2 = input(false, "═════════ CoG ══════════")
Length = input(25, minval=1)
m = input(5, minval=0)
Percent = input(6, minval=0, title="COG %")
xLG = linreg(close, Length, m)
xLG1r = xLG + ((close * Percent) / 100)
xLG1s = xLG - ((close * Percent) / 100)
pos = 0.0
pos := iff(close > xLG1r, 1, iff(close < xLG1s, -1, nz(pos[1], 0)))
possig = iff(pos == 1, 1, iff(pos == -1, -1, pos))
///////////// Rate Of Change /////////////
_3 = input(false, "══════ Rate of Change ══════")
source = close
roclength = input(2, "ROC Length", minval=1)
pcntChange = input(10, "ROC % Change", minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Srategy ///////////////
long = possig == 1 or (sslUp > sslDown and isMoving())
short = possig == -1 or (sslUp < sslDown 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])
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
/////////////// Dynamic ATR Stop Losses ///////////////
_4 = input(false, "════════ Stop Loss ═══════")
atrLkb = input(1, minval=1, title='ATR Stop Period')
atrMult = input(2, step=0.25, title='ATR Stop Multiplier')
atr1 = atr(atrLkb)
longStop = 0.0
longStop := short_signal ? na : long_signal ? close - (atr1 * atrMult) : longStop[1]
shortStop = 0.0
shortStop := long_signal ? na : short_signal ? close + (atr1 * atrMult) : shortStop[1]
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("L", strategy.long, when=long)
strategy.entry("S", strategy.short, when=short)
strategy.exit("L SL", "L", stop=longStop, when=since_longEntry > 0)
strategy.exit("S SL", "S", stop=shortStop, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
p1 = plot(sslDown, linewidth = 1, color=color.red, title="SSL down")
p2 = plot(sslUp, linewidth = 1, color=color.lime, title="SSL up")
fill(p1, p2, color = not isMoving() ? color.white : sslDown < sslUp ? color.lime : color.red, transp=80)
plot(xLG1r, color=color.lime, title="LG1r")
plot(xLG1s, color=color.red, title="LG1s")
plot(strategy.position_size <= 0 ? na : longStop, title="Long Stop Loss", color=color.yellow, style=plot.style_circles, linewidth=1)
plot(strategy.position_size >= 0 ? na : shortStop, title="Short Stop Loss", color=color.orange, style=plot.style_circles, linewidth=1)
bgcolor(long ? color.green : short ? color.red : not isMoving() ? color.white : na, transp=80)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=60)