RSI Dikombinasikan dengan Bollinger Bands dan Strategi Kuantitatif Dukungan/Resistensi Dinamis

Penulis:ChaoZhang, Tanggal: 2024-01-24 15:19:22
Tag:

Gambaran umum

Strategi ini menggunakan indikator RSI untuk menilai tingkat overbought/oversold di pasar, dikombinasikan dengan Bollinger Bands untuk menentukan rentang fluktuasi harga. Selain itu, dukungan/resistensi dinamis dihasilkan berdasarkan harga tinggi/rendah untuk memicu pesanan beli/jual hanya ketika harga dekat dengan level support/resistance. Pengguna dapat mengatur kondisi filter tren, seperti moving average sederhana, untuk memastikan tren harga selaras dengan arah perdagangan. Strategi ini mengintegrasikan beberapa indikator teknis untuk akurasi sinyal yang kuat dan menangkap peluang pasar secara efektif.

Logika Strategi

Strategi ini terdiri dari 3 komponen utama RSI, Bollinger Bands dan Dynamic S/R.

Komponen RSI menilai tingkat overbought/oversold. RSI turun di bawah 30 menunjukkan kondisi oversold dan pemicu sinyal beli. RSI naik di atas 70 menunjukkan kondisi overbought dan pemicu sinyal jual.

Bollinger Bands adalah band atas/bawah yang dihitung dari rata-rata pergerakan harga dan standar deviasi, untuk menentukan apakah harga telah keluar dari kisaran fluktuasi normal.

Komponen S/R menggunakan metode perhitungan dinamis untuk menghasilkan tingkat S/R utama berdasarkan harga tinggi/rendah historis (atau harga tutup/terbuka) dalam periode pengamatan tertentu dan rentang persentase, serta titik pembalikan harga historis.

Singkatnya, strategi ini memulai perdagangan beli/jual hanya ketika RSI overbought/oversold, price breaking out of Bollinger Bands, serta proximity to dynamic S/R levels terpenuhi.

Keuntungan

Indikator dasar RSI dikombinasikan dengan indikator analisis teknis Bollinger Bands. RSI menilai tingkat overbought/oversold secara mendasar sedangkan Bollinger Bands menentukan pola harga teknis.
Perhitungan S/R dinamis lebih dekat dengan S/R aktual yang mengatur pergerakan harga.
Menambahkan filter tren lebih meningkatkan akurasi sinyal dengan menyaring kebisingan ketika dikombinasikan dengan RSI dan Bollinger Bands.

Risiko

Pengaturan parameter RSI yang tidak benar dapat menyebabkan penilaian yang salah. Panjang RSI yang terlalu pendek meningkatkan kebisingan. Pengaturan ambang overbought / oversold yang salah juga menyebabkan kesalahan.
Parameter Bollinger Bands yang salah seperti panjang, StdDev multiplier mempengaruhi akurasi penilaian.
Dynamic S/R bergantung pada harga tinggi/rendah historis sehingga cenderung tertinggal. Pengguna harus mengoptimalkan parameter S/R untuk relevansi yang lebih besar dengan harga saat ini.
Strategi ini memiliki logika yang relatif kompleks dengan beberapa indikator yang berpotensi menyebabkan gangguan. Pengguna harus menguji parameter untuk mengurangi konflik. Mempermudah kriteria entri juga membantu meminimalkan kesalahan.

Arahan Optimasi

Uji dan optimalkan parameter RSI termasuk panjang, ambang overbought/oversold.
Uji dan optimalkan parameter Bollinger Bands termasuk panjang dan StdDev multiplier.
Mengoptimalkan parameter S/R dinamis untuk menyelaraskan tingkat S/R lebih dekat dengan harga, seperti menggunakan periode mundur yang lebih pendek atau harga tinggi/rendah historis yang lebih sedikit.
Uji indikator tambahan tambahan dalam kombinasi dengan RSI, seperti KDJ, MACD dll untuk meningkatkan akurasi.
Uji dan optimalkan parameter filter tren, terutama panjang filter, untuk memperpanjang periode penyimpanan dan mengurangi pesanan terbalik yang tidak perlu.

Kesimpulan

Strategi ini memanfaatkan kekuatan dari beberapa indikator seperti RSI, Bollinger Bands dan Dynamic S/R, dengan verifikasi silang yang ekstensif untuk akurasi sinyal yang kuat. Menambahkan filter tren lebih mengurangi kebisingan. Dengan penyesuaian parameter yang fleksibel, pengguna dapat mengoptimalkan strategi ini agar paling sesuai dengan kebutuhan mereka. Pengujian dan pengoptimalan parameter yang tepat akan mengarah pada kinerja yang lebih jelas. Ini adalah strategi kuantitatif yang sangat menjanjikan.

/*backtest
start: 2023-01-17 00:00:00
end: 2024-01-23 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=5
strategy("RSI + BB + S/R Strategy with Trend Filter", shorttitle="RSI + BB + S/R + Trend Filter", overlay=true)

// RSI Settings
rsi_length = input.int(14, title="RSI Length")
overbought = input.int(70, title="Overbought Level")
oversold = input.int(30, title="Oversold Level")

// Bollinger Bands Settings
bb_length = input.int(20, title="BB Length")
bb_deviation = input.float(2.0, title="BB Deviation")

// Dynamic Support/Resistance Settings
pivot_period = input.int(10, title="Pivot Period")
pivot_source = input.string("High/Low", title="Pivot Source", options=["High/Low", "Close/Open"])
max_pivots = input.int(20, title="Maximum Number of Pivot", minval=5, maxval=100)
channel_width = input.int(10, title="Maximum Channel Width %", minval=1)
max_sr_levels = input.int(5, title="Maximum Number of S/R Levels", minval=1, maxval=10)
min_strength = input.int(2, title="Minimum Strength", minval=1, maxval=10)

// Trend Filter Settings
use_trend_filter = input.bool(false, title="Use Trend Filter")
trend_filter_length = input.int(50, title="Trend Filter Length")

// Calculate RSI and Bollinger Bands
rsi = ta.rsi(close, rsi_length)
basis = ta.sma(close, bb_length)
deviation = ta.stdev(close, bb_length)
upper_band = basis + bb_deviation * deviation
lower_band = basis - bb_deviation * deviation

// Plot Bollinger Bands on the chart
plot(upper_band, color=color.blue, title="Upper Bollinger Band")
plot(lower_band, color=color.red, title="Lower Bollinger Band")

// Dynamic Support/Resistance Calculation
float src1 = pivot_source == "High/Low" ? high : math.max(close, open)
float src2 = pivot_source == "High/Low" ? low : math.min(close, open)
float ph = ta.pivothigh(src1, pivot_period, pivot_period)
float pl = ta.pivotlow(src2, pivot_period, pivot_period)


// Calculate maximum S/R channel zone width
prdhighest = ta.highest(300)
prdlowest = ta.lowest(300)
cwidth = (prdhighest - prdlowest) * channel_width / 100

var pivotvals = array.new_float(0)

if ph or pl
    array.unshift(pivotvals, ph ? ph : pl)
    if array.size(pivotvals) > max_pivots
        array.pop(pivotvals)

get_sr_vals(ind) =>
    float lo = array.get(pivotvals, ind)
    float hi = lo
    int numpp = 0
    for y = 0 to array.size(pivotvals) - 1 by 1
        float cpp = array.get(pivotvals, y)
        float wdth = cpp <= lo ? hi - cpp : cpp - lo
        if wdth <= cwidth
            if cpp <= hi
                lo := math.min(lo, cpp)
            else
                hi := math.max(hi, cpp)
            numpp += 1
    [hi, lo, numpp]

var sr_up_level = array.new_float(0)
var sr_dn_level = array.new_float(0)
sr_strength = array.new_float(0)

find_loc(strength) =>
    ret = array.size(sr_strength)
    for i = ret > 0 ? array.size(sr_strength) - 1 : na to 0 by 1
        if strength <= array.get(sr_strength, i)
            break
        ret := i
    ret

check_sr(hi, lo, strength) =>
    ret = true
    for i = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
        if array.get(sr_up_level, i) >= lo and array.get(sr_up_level, i) <= hi or array.get(sr_dn_level, i) >= lo and array.get(sr_dn_level, i) <= hi
            if strength >= array.get(sr_strength, i)
                array.remove(sr_strength, i)
                array.remove(sr_up_level, i)
                array.remove(sr_dn_level, i)
            else
                ret := false
            break
    ret

if ph or pl
    array.clear(sr_up_level)
    array.clear(sr_dn_level)
    array.clear(sr_strength)
    for x = 0 to array.size(pivotvals) - 1 by 1
        [hi, lo, strength] = get_sr_vals(x)
        if check_sr(hi, lo, strength)
            loc = find_loc(strength)
            if loc < max_sr_levels and strength >= min_strength
                array.insert(sr_strength, loc, strength)
                array.insert(sr_up_level, loc, hi)
                array.insert(sr_dn_level, loc, lo)
                if array.size(sr_strength) > max_sr_levels
                    array.pop(sr_strength)
                    array.pop(sr_up_level)
                    array.pop(sr_dn_level)

// Calculate the Trend Filter
trend_filter = use_trend_filter ? ta.sma(close, trend_filter_length) : close

// Buy Condition (RSI + Proximity to Support + Trend Filter)
buy_condition = ta.crossover(rsi, oversold) and close <= ta.highest(high, max_sr_levels) and close >= ta.lowest(low, max_sr_levels) and (not use_trend_filter or close > trend_filter)

// Sell Condition (RSI + Proximity to Resistance + Trend Filter)
sell_condition = ta.crossunder(rsi, overbought) and close >= ta.lowest(low, max_sr_levels) and close <= ta.highest(high, max_sr_levels) and (not use_trend_filter or close < trend_filter)

// Strategy Orders
strategy.entry("Buy", strategy.long, when = buy_condition)
strategy.entry("Sell", strategy.short, when = sell_condition)

Lebih banyak

2019 FMZ - Semua hak dilindungi