Tài nguyên đang được tải lên... tải...

RSI kết hợp với Bollinger Bands và Chiến lược số lượng hỗ trợ / kháng cự năng động

Tác giả:ChaoZhang, Ngày: 2024-01-24 15:19:22
Tags:

img

Tổng quan

Chiến lược này sử dụng chỉ số RSI để đánh giá mức mua quá mức / bán quá mức trên thị trường, kết hợp với Bollinger Bands để xác định phạm vi biến động giá. Ngoài ra, hỗ trợ / kháng cự năng động được tạo ra dựa trên giá cao / thấp để kích hoạt lệnh mua / bán chỉ khi giá gần mức hỗ trợ / kháng cự. Người dùng có thể đặt điều kiện lọc xu hướng, chẳng hạn như trung bình động đơn giản, để đảm bảo xu hướng giá phù hợp với hướng giao dịch. Chiến lược này tích hợp nhiều chỉ số kỹ thuật cho độ chính xác tín hiệu mạnh mẽ và nắm bắt các cơ hội thị trường hiệu quả.

Chiến lược logic

Chiến lược bao gồm 3 thành phần chính RSI, Bollinger Bands và Dynamic S/R.

Các thành phần RSI đánh giá mức mua quá mức / bán quá mức. RSI giảm xuống dưới 30 cho thấy tình trạng bán quá mức và kích hoạt tín hiệu mua. RSI tăng trên 70 cho thấy tình trạng mua quá mức và kích hoạt tín hiệu bán.

Bollinger Bands là các dải trên / dưới được tính toán từ giá trung bình động và độ lệch chuẩn, để xác định xem giá đã vượt ra khỏi phạm vi biến động bình thường hay không. Giá tiếp cận dải trên cho thấy bán trong khi dải dưới cho thấy mua.

Các thành phần S / R sử dụng một phương pháp tính toán năng động để tạo ra các mức S / R chính dựa trên giá cao / thấp trong lịch sử (hoặc giá đóng / mở) trong các khoảng thời gian nhìn lại và tỷ lệ phần trăm nhất định, cũng như các điểm đảo ngược giá trong lịch sử. Nó kích hoạt tín hiệu bán khi giá tăng lên mức kháng cự chính và tín hiệu mua khi giá giảm xuống mức hỗ trợ.

Tóm lại, chiến lược này chỉ bắt đầu giao dịch mua / bán khi RSI mua quá mức / bán quá mức, giá vượt ra khỏi Bollinger Bands, cũng như gần với mức S / R năng động được đáp ứng.

Ưu điểm

  1. Chỉ số cơ bản RSI kết hợp với chỉ số phân tích kỹ thuật Bollinger Bands. RSI đánh giá mức mua quá mức / bán quá mức về cơ bản trong khi Bollinger Bands xác định các mô hình giá kỹ thuật.

  2. Tính toán S / R động tuân thủ gần hơn với S / R thực tế điều chỉnh chuyển động giá.

  3. Thêm bộ lọc xu hướng sẽ cải thiện thêm độ chính xác tín hiệu bằng cách lọc ra tiếng ồn khi kết hợp với RSI và Bollinger Bands.

Rủi ro

  1. Cài đặt thông số RSI không chính xác có thể gây ra sự đánh giá sai. Độ dài RSI quá ngắn làm tăng tiếng ồn. Cài đặt ngưỡng mua/bán quá mức không chính xác cũng dẫn đến lỗi.

  2. Các thông số Bollinger Bands không chính xác như chiều dài, nhân StdDev ảnh hưởng đến độ chính xác đánh giá.

  3. Dynamic S/R dựa trên giá cao/dưới trong lịch sử do đó có xu hướng chậm trễ. Người dùng nên tối ưu hóa các thông số S/R để phù hợp hơn với giá hiện tại.

  4. Chiến lược này có logic tương đối phức tạp với nhiều chỉ số có khả năng gây nhiễu. Người dùng nên kiểm tra các tham số để giảm xung đột. Việc đơn giản hóa các tiêu chí nhập cũng giúp giảm thiểu lỗi.

Hướng dẫn tối ưu hóa

  1. Kiểm tra và tối ưu hóa các thông số RSI bao gồm chiều dài, ngưỡng mua quá mức / bán quá mức.

  2. Kiểm tra và tối ưu hóa các thông số Bollinger Bands bao gồm chiều dài và nhân StdDev.

  3. Tối ưu hóa các thông số S / R động để sắp xếp các mức S / R gần hơn với giá, chẳng hạn như sử dụng các khoảng thời gian xem lại ngắn hơn hoặc ít giá cao / thấp hơn trong lịch sử.

  4. Kiểm tra các chỉ số phụ trợ bổ sung kết hợp với RSI, chẳng hạn như KDJ, MACD vv để cải thiện độ chính xác.

  5. Kiểm tra và tối ưu hóa các thông số bộ lọc xu hướng, đặc biệt là chiều dài bộ lọc, để kéo dài thời gian giữ và giảm các lệnh ngược không cần thiết.

Kết luận

Chiến lược này tận dụng điểm mạnh của nhiều chỉ số như RSI, Bollinger Bands và Dynamic S / R, với xác minh chéo rộng rãi cho độ chính xác tín hiệu mạnh mẽ. Thêm bộ lọc xu hướng làm giảm thêm tiếng ồn. Với điều chỉnh tham số linh hoạt, người dùng có thể tối ưu hóa chiến lược này để phù hợp nhất với nhu cầu của họ. Kiểm tra và tối ưu hóa tham số thích hợp sẽ dẫn đến hiệu suất rõ rệt hơn. Đây là một chiến lược định lượng rất hứa hẹn.


/*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)

Thêm nữa