Chiến lược dài hạn và ngắn hạn của chỉ báo RSI
ChaoZhang
Tổng quan
Chiến lược này được đánh giá dựa trên chỉ số tương đối mạnh yếu (RSI) và được thực hiện khi RSI cao hơn khi thiết lập giới hạn trên và khi RSI thấp hơn khi thiết lập giới hạn dưới. Chiến lược này thuộc về chiến lược giao dịch đảo ngược RSI điển hình. Chiến lược này cũng có các chức năng như tối ưu hóa tham số, chiến lược dừng lỗ, có thể điều chỉnh tham số để thích ứng với môi trường thị trường khác nhau.
Nguyên tắc chiến lược
Các logic cốt lõi của chiến lược bao gồm:
- Tính RSI
- Thiết lập RSI up and down
- Khi RSI bị giới hạn, bạn có thể nhìn trần khi vào.
- Khi RSI vượt qua giới hạn thấp, hãy xem thêm vào.
- Cài đặt điều kiện dừng, dừng
- RSI sẽ đóng cửa khi bước vào một khoảng hoặc khi điều kiện dừng lỗ được kích hoạt
Chỉ số RSI có thể cho thấy thị trường đang ở trạng thái quá mua hoặc quá bán. Khi RSI cao hơn 70, nó được coi là quá mua, và khi RSI thấp hơn 30, nó được coi là quá bán. Chiến lược giao dịch là dựa trên trạng thái quá mua quá bán của RSI để xác định xem có nên thiết lập một vị trí trống hay một vị trí nhiều đầu.
Chiến lược này sử dụng logic cổ điển của chỉ số RSI để xác định hướng đặt vị trí dựa trên giá trị của RSI và mối quan hệ giữa giới hạn trên và dưới. Đồng thời, chiến lược có các tham số có thể điều chỉnh, có thể tối ưu hóa giới hạn trên và dưới của RSI, stop loss, v.v., để thích ứng với sự thay đổi của thị trường.
Lợi thế chiến lược
- Sử dụng chỉ số RSI để đánh giá hiệu quả tình trạng thị trường quá mua quá bán
- Các chỉ số RSI được chấp nhận rộng rãi theo lý thuyết
- Các tham số chiến lược có thể điều chỉnh để phù hợp với các giống và môi trường thị trường khác nhau
- Khả năng kiểm soát rủi ro
Rủi ro chiến lược và ứng phó
- RSI có thể phát tín hiệu sai dẫn đến tổn thất không cần thiết
- Cần tối ưu hóa liên tục khoảng RSI
- Vấn đề của việc ngừng hoạt động có thể được kích hoạt bởi frequent
Biện pháp đối phó:
- Xác nhận đa yếu tố kết hợp với các chỉ số khác để tránh tín hiệu giả
- Phạm vi tham số RSI được tối ưu hóa cho các đặc tính khác nhau của giống
- Điều chỉnh vị trí dừng lỗ để giảm rủi ro bị che đậy
Hướng tối ưu hóa chiến lược
Chiến lược này có thể được mở rộng và tối ưu hóa theo các khía cạnh sau:
Sử dụng học máy để tự động tối ưu hóa phạm vi tham số RSI
Tăng xác nhận giao dịch, tránh đột phá giả mạo
Xác thực đa yếu tố kết hợp với các chỉ số như đường trung bình di chuyển
Thiết lập chiến lược dừng lỗ thích ứng, điều chỉnh mức dừng lỗ theo biến động của thị trường
Nghiên cứu sự thay đổi của khối lượng giao dịch để xác định dòng tiền vào và ra
Kết hợp các chiến lược không liên quan khác để giảm sự rút lui tổng thể
Tóm tắt
Chiến lược này sử dụng chỉ số RSI để đánh giá quá mua quá bán, là một chiến lược đảo ngược đơn giản và thực tế. Chiến lược có thể điều chỉnh tham số theo thay đổi của thị trường, cũng có thể mở rộng và tối ưu hóa nhiều chiều.
/*backtest
start: 2023-08-19 00:00:00
end: 2023-09-18 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
strategy("4All V3", shorttitle="Strategy", overlay=true)
/////////////// Component Code Start ///////////////
testStartYear = input(2011, "Backtest Start Year")
testStartMonth = input(8, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear = input(2018, "Backtest Stop Year")
testStopMonth = input(9, "Backtest Stop Month")
testStopDay = input(29, "Backtest Stop Day")
// testStopDay = testStartDay + 1
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)
// A switch to control background coloring of the test period
testPeriodBackground = input(title="Color Background?", type=bool, defval=true)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)
testPeriod() => true
/////////////// Component Code Stop ///////////////
src = close
len = input(4, minval=1, title="Length")
up = rma(max(change(src), 0), len)
down = rma(-min(change(src), 0), len)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))
rsin = input(5)
sn = 100 - rsin
ln = 0 + rsin
/////////////// STRATEGY ///////////////
ts = input(99999, "Trailing Stop") / 10000
tp = input(15, "Take Profit") / 10000
sl = input(23, "Stop Loss") / 10000
pyr = input(1, "Pyramiding")
short = crossover(rsi, sn)
long = crossunder(rsi, ln)
totalLongs = 0
totalLongs := nz(totalLongs[1])
totalShorts = 0
totalShorts := nz(totalShorts[1])
totalLongsPrice = 0
totalLongsPrice := nz(totalLongsPrice[1])
totalShortsPrice = 0
totalShortsPrice := nz(totalShortsPrice[1])
sectionLongs = 0
sectionLongs := nz(sectionLongs[1])
sectionShorts = 0
sectionShorts := nz(sectionShorts[1])
if long
sectionLongs := sectionLongs + 1
sectionShorts := 0
if short
sectionLongs := 0
sectionShorts := sectionShorts + 1
longCondition = long and sectionLongs >= pyr
shortCondition = short and sectionShorts >= pyr
last_long = na
last_short = na
last_long := longCondition ? time : nz(last_long[1])
last_short := shortCondition ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = na
last_open_short_signal = na
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 = na
last_short_signal = na
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 = na
last_low = na
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])
long_ts = not na(last_high) and high <= (last_high - ts) //and high >= last_open_long_signal
short_ts = not na(last_low) and low >= (last_low + ts) //and low <= last_open_short_signal
long_tp = high >= (last_open_long_signal + tp)
short_tp = low <= (last_open_short_signal - tp)
long_sl = low <= (last_open_long_signal - sl)
short_sl = high >= (last_open_short_signal + sl)
leverage = input(1, "Leverage")
long_call = last_open_long_signal - (0.8 + 0.2 * (1/leverage)) / leverage * last_open_long_signal
short_call = last_open_short_signal + (0.78 + 0.2 * (1/leverage)) / leverage * last_open_short_signal
long_call_signal = low <= long_call
short_call_signal = high >= short_call
if testPeriod()
strategy.entry("Long", strategy.long, when=longCondition)
strategy.entry("Short", strategy.short, when=shortCondition)
strategy.close("Long", when=long_call_signal)
strategy.close("Short", when=short_call_signal)
strategy.close("Long", when=long_tp)
strategy.close("Short", when=short_tp)
strategy.close("Long", when=long_sl)
strategy.close("Short", when=short_sl)
strategy.close("Long", when=long_ts)
strategy.close("Short", when=short_ts)