RSI digabungkan dengan Bollinger Bands dan Strategi Kuantitatif Sokongan/Rintangan Dinamik

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

Ringkasan

Strategi ini menggunakan penunjuk RSI untuk menilai tahap overbought / oversold di pasaran, digabungkan dengan Bollinger Bands untuk menentukan julat turun naik harga. Di samping itu, sokongan / rintangan dinamik dihasilkan berdasarkan harga tinggi / rendah untuk mencetuskan pesanan beli / jual hanya apabila harga berhampiran dengan tahap sokongan / rintangan. Pengguna boleh menetapkan keadaan penapis trend, seperti purata bergerak mudah, untuk memastikan trend harga sejajar dengan arah perdagangan. Strategi ini mengintegrasikan beberapa penunjuk teknikal untuk ketepatan isyarat yang kukuh dan menangkap peluang pasaran dengan berkesan.

Logika Strategi

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

Komponen RSI menilai tahap overbought / oversold. RSI jatuh di bawah 30 menunjukkan keadaan oversold dan mencetuskan isyarat beli. RSI naik di atas 70 menunjukkan keadaan overbought dan mencetuskan isyarat jual.

Bollinger Bands adalah band atas/bawah yang dikira dari purata bergerak harga dan penyimpangan standard, untuk menentukan sama ada harga telah keluar dari julat turun naik biasa.

Komponen S / R menggunakan kaedah pengiraan dinamik untuk menjana tahap S / R utama berdasarkan harga tinggi / rendah sejarah (atau harga tutup / terbuka) dalam tempoh penglihatan dan julat peratusan tertentu, serta titik pembalikan harga sejarah.

Ringkasnya, strategi ini memulakan perdagangan beli/jual hanya apabila RSI overbought/oversold, harga keluar dari Bollinger Bands, serta kedekatan dengan tahap S/R dinamik dipenuhi.

Kelebihan

Penunjuk asas RSI digabungkan dengan penunjuk analisis teknikal Bollinger Bands. RSI menilai tahap overbought / oversold secara asas manakala Bollinger Bands menentukan corak harga teknikal.
Pengiraan S/R dinamik lebih rapat dengan S/R sebenar yang mengawal pergerakan harga.
Menambah penapis trend lebih meningkatkan ketepatan isyarat dengan menapis bunyi bising apabila digabungkan dengan RSI dan Bollinger Bands.

Risiko

Tetapan parameter RSI yang tidak betul boleh menyebabkan penilaian yang salah. Panjang RSI yang terlalu pendek meningkatkan bunyi bising. Tetapan ambang overbought / oversold yang salah juga membawa kepada kesilapan.
Parameter Bollinger Bands yang salah seperti panjang, pengganda StdDev mempengaruhi ketepatan penghakiman.
Dinamis S / R bergantung pada harga tinggi / rendah bersejarah sehingga cenderung untuk ketinggalan. Pengguna harus mengoptimumkan parameter S / R untuk relevansi yang lebih besar dengan harga semasa.
Strategi ini mempunyai logik yang agak kompleks dengan beberapa penunjuk yang berpotensi menyebabkan gangguan. Pengguna harus menguji parameter untuk mengurangkan konflik. Mempermudah kriteria kemasukan juga membantu meminimumkan kesilapan.

Arahan pengoptimuman

Uji dan optimumkan parameter RSI termasuk panjang, ambang overbought / oversold.
Uji dan optimumkan parameter Bollinger Bands termasuk panjang dan pengganda StdDev.
Mengoptimumkan parameter S/R dinamik untuk menyelaraskan tahap S/R lebih dekat dengan harga, seperti menggunakan tempoh melihat kembali yang lebih pendek atau harga tinggi/rendah sejarah yang lebih sedikit.
Uji penunjuk tambahan tambahan dalam kombinasi dengan RSI, seperti KDJ, MACD dan lain-lain untuk meningkatkan ketepatan.
Uji dan optimumkan parameter penapis trend, terutamanya panjang penapis, untuk memanjangkan tempoh tahan dan mengurangkan pesanan terbalik yang tidak perlu.

Kesimpulan

Strategi ini memanfaatkan kekuatan pelbagai penunjuk seperti RSI, Bollinger Bands dan Dynamic S / R, dengan pengesahan silang yang luas untuk ketepatan isyarat yang kukuh. Menambah penapis trend lebih mengurangkan bunyi bising. Dengan penyesuaian parameter yang fleksibel, pengguna dapat mengoptimumkan strategi ini untuk memenuhi keperluan mereka. Ujian dan pengoptimuman parameter yang betul akan membawa kepada prestasi yang lebih ketara. 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 lanjut

2019 FMZ - Semua hak dilindungi