Chiến lược giao dịch hai chiều dài và ngắn của RSI double track oscillator
Ngày tạo:
2023-10-25 11:57:46
sửa đổi lần cuối:
2023-10-25 11:57:46
sao chép:
1
Số nhấp chuột:
627
ChaoZhang
1
tập trung vào
1617
Người theo dõi
Tổng quan
Chiến lược giao dịch hai chiều dài của RSI là một chiến lược sử dụng chỉ số RSI để giao dịch hai chiều. Chiến lược này sử dụng nguyên tắc mua bán quá mức của chỉ số RSI, kết hợp với thiết lập hai quỹ đạo và tín hiệu giao dịch đồng nhất, để thực hiện các vị trí mở và đóng hai chiều hiệu quả.
Nguyên tắc chiến lược
Chiến lược này chủ yếu dựa trên nguyên tắc mua bán quá mức của chỉ số RSI để đưa ra quyết định giao dịch. Chiến lược này đầu tiên tính toán giá trị của chỉ số RSI, và đường đua sn và đường đua ln.
Chiến lược cũng phát hiện sự thay đổi của K-line và tạo ra thêm các tín hiệu longLocic khi K-line phá vỡ từ dưới lên trên và shortLogic khi K-line phá vỡ từ trên xuống dưới. Ngoài ra, chiến lược cung cấp một chuyển đổi tham số, chỉ có thể làm nhiều, chỉ có trống, hoặc đảo ngược.
Sau khi tạo ra nhiều tín hiệu giảm giá, chiến lược sẽ thống kê số lần tín hiệu và kiểm soát số lần mở vị trí. Các tham số có thể được thiết lập theo các quy tắc tăng giá khác nhau. Các điều kiện bán hàng bao gồm các cách dừng, dừng lỗ, dừng lỗ di chuyển, có thể được thiết lập tỷ lệ phần trăm dừng lỗ khác nhau.
Tóm lại, chiến lược này sử dụng nhiều phương tiện kỹ thuật như chỉ số RSI, đường chéo, đặt cược thống kê, dừng lỗ để thực hiện giao dịch hai chiều dài và ngắn tự động.
Lợi thế chiến lược
- Sử dụng các chỉ số RSI để mua và bán quá mức để tạo thêm các vị trí giảm giá ở các vị trí hợp lý.
- Cài đặt hai đường ray để tránh tín hiệu sai. Đường ray trên ngăn chặn vị trí nhiều đầu xếp hạng quá sớm và đường ray dưới ngăn chặn vị trí trống xếp hạng quá sớm.
- Đường trung bình giao dịch tín hiệu lọc phá vỡ giả. Giá cổ phiếu phá vỡ đường trung bình mới tạo ra tín hiệu, tránh tín hiệu giả.
- Số lần tín hiệu thống kê và số lần đặt hàng, kiểm soát rủi ro.
- Có thể tùy chỉnh tỷ lệ dừng lỗ, có thể kiểm soát rủi ro thu nhập.
- Di chuyển dừng theo dõi dừng để khóa lợi nhuận hơn nữa.
- Chỉ có thể làm nhiều hơn, chỉ có thể làm trống hoặc chuyển đổi tín hiệu, thích ứng với các môi trường thị trường khác nhau.
- Tự động hóa hệ thống giao dịch, giảm chi phí vận hành nhân công.
Rủi ro chiến lược
- Chỉ số RSI có nguy cơ đảo ngược thất bại. RSI đi vào vùng quá mua quá bán không nhất thiết phải đảo ngược.
- Các điểm dừng cố định có nguy cơ bị đặt. Thiết lập dừng không đúng có thể gây ra dừng hoặc dừng quá sớm.
- Tùy thuộc vào chỉ số kỹ thuật, có nguy cơ tối ưu hóa tham số. Thiết lập tham số chỉ số không đúng cách sẽ ảnh hưởng đến hiệu quả của chiến lược.
- Có nhiều điều kiện xảy ra cùng một lúc, có nguy cơ bị bỏ phiếu.
- Hệ thống giao dịch tự động có nguy cơ bị lỗi.
Đối với các rủi ro trên, có thể tối ưu hóa các thiết lập tham số, điều chỉnh chiến lược dừng lỗ, tăng lọc thanh khoản, tối ưu hóa logic tạo tín hiệu, tăng giám sát lỗi bất thường.
Hướng tối ưu hóa chiến lược
- Kiểm tra các tham số khác nhau để tối ưu hóa các tham số chỉ số RSI.
- Kiểm tra các thiết lập tỷ lệ phần trăm Stop Loss khác nhau.
- Tăng khối lượng giao dịch hoặc lọc lợi nhuận để tránh thiếu thanh khoản.
- Tối ưu hóa logic tạo tín hiệu, cải thiện phương thức giao nhau.
- Thêm nhiều lần thử nghiệm để xác minh tính ổn định.
- Xem xét thêm các chỉ số khác để tối ưu hóa hiệu quả tín hiệu.
- Tham gia chiến lược quản lý vị trí
- Thêm giám sát lỗi bất thường.
- Tối ưu hóa các thuật toán theo dõi tự động.
- Xem xét thêm chiến lược nâng cao học tập máy.
Tóm tắt
Chiến lược giao dịch hai chiều RSI được thực hiện bằng cách sử dụng nhiều phương tiện kỹ thuật như chỉ số RSI, nguyên tắc mở và dừng theo thống kê. Chiến lược này có khả năng tùy chỉnh mạnh mẽ, người dùng có thể điều chỉnh các tham số theo nhu cầu và thích ứng với môi trường thị trường khác nhau. Ngoài ra, chiến lược cũng có một số không gian cải tiến, có thể được tối ưu hóa từ các khía cạnh của thiết lập tham số tối ưu, chiến lược kiểm soát gió, logic tạo tín hiệu, để làm cho chiến lược ổn định hơn và đáng tin cậy hơn.
Mã nguồn chiến lược
/*backtest
start: 2023-09-24 00:00:00
end: 2023-10-24 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
// Learn more about Autoview and how you can automate strategies like this one here: https://autoview.with.pink/
// strategy("Autoview Build-a-bot - 5m chart", "Strategy", overlay=true, pyramiding=2000, default_qty_value=10000)
// study("Autoview Build-a-bot", "Alerts")
///////////////////////////////////////////////
//* Backtesting Period Selector | Component *//
///////////////////////////////////////////////
//* https://www.tradingview.com/script/eCC1cvxQ-Backtesting-Period-Selector-Component *//
//* https://www.tradingview.com/u/pbergden/ *//
//* Modifications made *//
testStartYear = input(1, "Backtest Start Year")
testStartMonth = input(11, "Backtest Start Month")
testStartDay = input(10, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear = input(77777777, "Backtest Stop Year")
testStopMonth = input(11, "Backtest Stop Month")
testStopDay = input(15, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)
testPeriod() => true
/////////////////////////////////////
//* Put your strategy logic below *//
/////////////////////////////////////
RSIlength = input(1,title="RSI Period Length")
price = close
vrsi = (rsi(price, RSIlength))
src = close
len = input(2, 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(12)
sn = 100 - rsin
ln = 0 + rsin
// Put your long and short rules here
longLocic = crossunder(rsi, ln)
shortLogic = crossover(rsi, sn)
//////////////////////////
//* Strategy Component *//
//////////////////////////
isLong = input(true, "Longs Only")
isShort = input(false, "Shorts Only")
isFlip = input(false, "Flip the Opens")
long = longLocic
short = shortLogic
if isFlip
long := shortLogic
short := longLocic
else
long := longLocic
short := shortLogic
if isLong
long := long
short := na
if isShort
long := na
short := short
////////////////////////////////
//======[ Signal Count ]======//
////////////////////////////////
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
//////////////////////////////
//======[ Pyramiding ]======//
//////////////////////////////
pyrl = input(2, "Pyramiding less than") // If your count is less than this number
pyre = input(1, "Pyramiding equal to") // If your count is equal to this number
pyrg = input(1000000, "Pyramiding greater than") // If your count is greater than this number
longCondition = long and sectionLongs <= pyrl or long and sectionLongs >= pyrg or long and sectionLongs == pyre ? 1 : 0 and vrsi < 20
shortCondition = short and sectionShorts <= pyrl or short and sectionShorts >= pyrg or short and sectionShorts == pyre ? 1 : 0
////////////////////////////////
//======[ Entry Prices ]======//
////////////////////////////////
last_open_longCondition = na
last_open_shortCondition = na
last_open_longCondition := longCondition ? close : nz(last_open_longCondition[1])
last_open_shortCondition := shortCondition ? close : nz(last_open_shortCondition[1])
////////////////////////////////////
//======[ Open Order Count ]======//
////////////////////////////////////
sectionLongConditions = 0
sectionLongConditions := nz(sectionLongConditions[1])
sectionShortConditions = 0
sectionShortConditions := nz(sectionShortConditions[1])
if longCondition
sectionLongConditions := sectionLongConditions + 1
sectionShortConditions := 0
if shortCondition
sectionLongConditions := 0
sectionShortConditions := sectionShortConditions + 1
///////////////////////////////////////////////
//======[ Position Check (long/short) ]======//
///////////////////////////////////////////////
last_longCondition = na
last_shortCondition = na
last_longCondition := longCondition ? time : nz(last_longCondition[1])
last_shortCondition := shortCondition ? time : nz(last_shortCondition[1])
in_longCondition = last_longCondition > last_shortCondition
in_shortCondition = last_shortCondition > last_longCondition
/////////////////////////////////////
//======[ Position Averages ]======//
/////////////////////////////////////
totalLongs = 0.0
totalLongs := nz(totalLongs[1])
totalShorts = 0.0
totalShorts := nz(totalShorts[1])
averageLongs = 0.0
averageLongs := nz(averageLongs[1])
averageShorts = 0.0
averageShorts := nz(averageShorts[1])
if longCondition
totalLongs := totalLongs + last_open_longCondition
totalShorts := 0.0
if shortCondition
totalLongs := 0.0
totalShorts := totalShorts + last_open_shortCondition
averageLongs := totalLongs / sectionLongConditions
averageShorts := totalShorts / sectionShortConditions
/////////////////////////////////
//======[ Trailing Stop ]======//
/////////////////////////////////
isTS = input(false, "Trailing Stop")
tsi = input(100, "Activate Trailing Stop Price (%). Divided by 100 (1 = 0.01%)") / 100
ts = input(100, "Trailing Stop (%). Divided by 100 (1 = 0.01%)") / 100
last_high = na
last_low = na
last_high_short = na
last_low_short = na
last_high := not in_longCondition ? na : in_longCondition and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_high_short := not in_shortCondition ? na : in_shortCondition and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_shortCondition ? na : in_shortCondition and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
last_low_short := not in_longCondition ? na : in_longCondition and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
long_ts = isTS and not na(last_high) and low <= last_high - last_high / 100 * ts and longCondition == 0 and last_high >= averageLongs + averageLongs / 100 * tsi
short_ts = isTS and not na(last_low) and high >= last_low + last_low / 100 * ts and shortCondition == 0 and last_low <= averageShorts - averageShorts/ 100 * tsi
///////////////////////////////
//======[ Take Profit ]======//
///////////////////////////////
isTP = input(true, "Take Profit")
tp = input(125, "Take Profit (%). Divided by 100 (1 = 0.01%)") / 100
long_tp = isTP and close > averageLongs + averageLongs / 100 * tp and not longCondition
short_tp = isTP and close < averageShorts - averageShorts / 100 * tp and not shortCondition
/////////////////////////////
//======[ Stop Loss ]======//
/////////////////////////////
isSL = input(true, "Stop Loss")
sl = input(140, "Stop Loss (%). Divided by 100 (1 = 0.01%)") / 100
long_sl = isSL and close < averageLongs - averageLongs / 100 * sl and longCondition == 0
short_sl = isSL and close > averageShorts + averageShorts / 100 * sl and shortCondition == 0
/////////////////////////////////
//======[ Close Signals ]======//
/////////////////////////////////
longClose = long_tp or long_sl or long_ts ? 1 : 0
shortClose = short_tp or short_sl or short_ts ? 1: 0
///////////////////////////////
//======[ Plot Colors ]======//
///////////////////////////////
longCloseCol = na
shortCloseCol = na
longCloseCol := long_tp ? purple : long_sl ? maroon : long_ts ? blue : longCloseCol[1]
shortCloseCol := short_tp ? purple : short_sl ? maroon : short_ts ? blue : shortCloseCol[1]
tpColor = isTP and in_longCondition ? purple : isTP and in_shortCondition ? purple : white
slColor = isSL and in_longCondition ? red : isSL and in_shortCondition ? red : white
//////////////////////////////////
//======[ Strategy Plots ]======//
//////////////////////////////////
plot(isTS and in_longCondition ? averageLongs + averageLongs / 100 * tsi : na, "Long Trailing Activate", blue, style=3, linewidth=2)
plot(isTS and in_longCondition and last_high >= averageLongs + averageLongs / 100 * tsi ? last_high - last_high / 100 * ts : na, "Long Trailing", fuchsia, style=2, linewidth=3)
plot(isTS and in_shortCondition ? averageShorts - averageShorts/ 100 * tsi : na, "Short Trailing Activate", blue, style=3, linewidth=2)
plot(isTS and in_shortCondition and last_low <= averageShorts - averageShorts/ 100 * tsi ? last_low + last_low / 100 * ts : na, "Short Trailing", fuchsia, style=2, linewidth=3)
plot(isTP and in_longCondition and last_high < averageLongs + averageLongs / 100 * tp ? averageLongs + averageLongs / 100 * tp : na, "Long TP", tpColor, style=3, linewidth=2)
plot(isTP and in_shortCondition and last_low > averageShorts - averageShorts / 100 * tp ? averageShorts - averageShorts / 100 * tp : na, "Short TP", tpColor, style=3, linewidth=2)
plot(isSL and in_longCondition and last_low_short > averageLongs - averageLongs / 100 * sl ? averageLongs - averageLongs / 100 * sl : na, "Long SL", slColor, style=3, linewidth=2)
plot(isSL and in_shortCondition and last_high_short < averageShorts + averageShorts / 100 * sl ? averageShorts + averageShorts / 100 * sl : na, "Short SL", slColor, style=3, linewidth=2)
///////////////////////////////
//======[ Alert Plots ]======//
///////////////////////////////
// plot(longCondition, "Long", green)
// plot(shortCondition, "Short", red)
// plot(longClose, "Long Close", longCloseCol)
// plot(shortClose, "Short Close", shortCloseCol)
///////////////////////////////////
//======[ Reset Variables ]======//
///////////////////////////////////
if longClose or not in_longCondition
averageLongs := 0
totalLongs := 0.0
sectionLongs := 0
sectionLongConditions := 0
if shortClose or not in_shortCondition
averageShorts := 0
totalShorts := 0.0
sectionShorts := 0
sectionShortConditions := 0
////////////////////////////////////////////
//======[ Strategy Entry and Exits ]======//
////////////////////////////////////////////
if testPeriod()
strategy.entry("Long", 1, when=longCondition)
strategy.entry("Short", 0, when=shortCondition)
strategy.close("Long", when=longClose)
strategy.close("Short", when=shortClose)