Chiến lược giao dịch đảo ngược trung bình dựa trên đường trung bình động

Tác giả:ChaoZhang, Ngày: 2023-10-26 15:38:14
Tags:

Tổng quan

Chiến lược giao dịch đảo ngược trung bình dựa trên độ lệch giá từ trung bình động để đưa ra quyết định giao dịch. Nó tận dụng lợi thế của độ lệch ngắn hạn và mô hình đảo ngược dài hạn của giá đối với trung bình bằng cách thiết lập các vị trí khi giá thấp hơn hoặc cao hơn đáng kể so với trung bình động và đóng các vị trí khi giá quay trở lại.

Chiến lược logic

Chiến lược đầu tiên tính toán một đường trung bình động trong một khoảng thời gian nhất định để đại diện cho xu hướng giá dài hạn. Sau đó nó xác định thời gian và kích thước các vị trí dựa trên độ lệch của giá so với đường trung bình động.

Khi giá giảm xuống dưới mức trung bình động một tỷ lệ phần trăm nhất định, nó báo hiệu giá lệch khỏi xu hướng dài hạn. Trong trường hợp này, các vị trí dài được xây dựng dần dần với kích thước ngày càng tăng khi độ lệch mở rộng. Khi giá bật trở lại trên mức trung bình động, cho thấy sự đảo ngược đến mức trung bình, các vị trí dài được đóng để kiếm lợi nhuận.

Tương tự như vậy, khi giá tăng trên mức trung bình động một ngưỡng, các vị trí ngắn được xây dựng. Khi giá giảm trở lại hướng tới mức trung bình động, các vị trí ngắn được đóng lại với lợi nhuận.

Phân tích lợi thế

Sử dụng khả năng xác định xu hướng của các đường trung bình động để theo dõi xu hướng cân bằng dài hạn của giá cổ phiếu và xác định hướng xu hướng chính.
Giảm chi phí trung bình bằng cách mở rộng các vị trí, nhận được giá nhập cảnh tốt hơn.
Sử dụng lợi nhuận theo giai đoạn để đảm bảo lợi nhuận ở các mức độ đảo ngược trung bình khác nhau, giảm rủi ro.
Định giá vị trí theo tỷ lệ phần trăm cố định để hạn chế kích thước lỗ giao dịch duy nhất.
Cài đặt tham số linh hoạt như thời gian trung bình động và kích thước vị trí tùy thuộc vào các sản phẩm khác nhau.

Phân tích rủi ro

Có thể mở rộng phạm vi dừng lỗ hoặc thêm các bộ lọc khác.
Xu hướng mạnh có thể phá vỡ đường trung bình động, không thể đóng ở mức đảo ngược trung bình. Có thể làm giảm kích thước vị trí được xác định bởi các chỉ số sức mạnh xu hướng.
Cài đặt tham số không chính xác có thể dẫn đến các mục nhập hoặc dừng quá mạnh.
Tần suất giao dịch cao dẫn đến chi phí giao dịch đáng kể Các yếu tố chi phí nên được xem xét trong tối ưu hóa tham số.

Hướng dẫn cải thiện

Tối ưu hóa thời gian trung bình động để thích nghi với các đặc điểm của sản phẩm.
Tối ưu hóa kích thước vị trí để cân bằng rủi ro và lợi nhuận.
Thêm các bộ lọc kỹ thuật khác để tránh giao dịch không cần thiết.
Bao gồm các biện pháp biến động để điều chỉnh kích thước vị trí dựa trên mức biến động thị trường.
Giới thiệu mục tiêu lợi nhuận để giảm rủi ro và tăng lợi nhuận.

Kết luận

Chiến lược đảo ngược trung bình sử dụng xu hướng đảo ngược cân bằng của cổ phiếu bằng cách đi vào lệch so với trung bình động và kiếm lợi nhuận khi đảo ngược. Với điều chỉnh tham số và bộ lọc thích hợp, nó có thể thích nghi với những thay đổi của thị trường và đạt được lợi nhuận tốt dưới sự kiểm soát rủi ro. Chiến lược này kết hợp cả việc theo dõi xu hướng và quản lý rủi ro, làm cho nó đáng nghiên cứu và áp dụng cho các nhà đầu tư.

/*backtest
start: 2022-10-19 00:00:00
end: 2023-10-25 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("YJ Mean Reversion", overlay=true)
//Was designed firstly to work on an index like the S&P 500 , which over time tends to go up in value. 
//Avoid trading too frequently (e.g. Daily, Weekly), to avoid getting eaten by fees. 
//If you change the underlying asset, or time frame, tweaking the moving average may be necessary. 
//Can work with a starting capital of just $1000, optimise the settings as necessary. 
//Accepts floating point values for the amount of units to purchase (e.g. Bitcoin ). 
//If price of units exceeds available capital, script will cancel the buy. 
//Adjusted the input parameters to be more intuitive.

//input variables
movingAverage = input(title="Moving Average (bars)", type=input.integer, defval=28, minval=1, maxval=1000)
//riskPercentage = input(title="Amount to Risk (%)", type=input.integer, defval=1, minval=1, maxval=50)
deviation = input(title="Deviation Increment (%)", type=input.float, defval=5, minval=0.01, maxval=100) / 100
unitsLevel1 = input(title="Level 1 (units)", type=input.float, defval=1, minval=0.0001, maxval=10000)
unitsLevel2 = input(title="Level 2 (units)", type=input.float, defval=2, minval=0.0001, maxval=10000)
unitsLevel3 = input(title="Level 3 (units)", type=input.float, defval=4, minval=0.0001, maxval=10000)
unitsLevel4 = input(title="Level 4 (units)", type=input.float, defval=8, minval=0.0001, maxval=10000)
unitsLevel5 = input(title="Level 5 (units)", type=input.float, defval=16, minval=0.0001, maxval=10000)

//moving average and ma slope (use on weekly chart)
ma = sma(close, movingAverage)
//sl = ma > ma[4]

//units to buy
//amount = riskPercentage / 100 * (strategy.initial_capital + strategy.netprofit)
//units = floor(amount / close)

//mode 1
//strategy.order("buy", true, 1, when = (close < 0.95 * ma) and (strategy.position_size < 10))
//strategy.order("sell", false, strategy.position_size, when = (close > 1.05 * ma) and (strategy.position_size > 0))

//mode 2
//strategy.order("buy", true, 1, when = close < 0.8 * ma)
//strategy.order("sell", false, strategy.position_size, when = (close > 310) and (strategy.position_size > 0))

//mode 3
//strategy.order("buy", true, 1, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("buy", true, 2, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("buy", true, 4, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("buy", true, 8, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("buy", true, 16, when = (close < 0.75 * ma))
//strategy.order("sell", false, strategy.position_size, when = (close > 310) and (strategy.position_size > 0))

//mode 4
//strategy.order("buy", true, 1, when = (close < 0.98 * ma) and (close > 0.96 * ma) and (sl))
//strategy.order("buy", true, 2, when = (close < 0.96 * ma) and (close > 0.94 * ma) and (sl))
//strategy.order("buy", true, 4, when = (close < 0.94 * ma) and (close > 0.92 * ma) and (sl))
//strategy.order("buy", true, 8, when = (close < 0.92 * ma) and (close > 0.90 * ma) and (sl))
//strategy.order("buy", true, 16, when = (close < 0.90 * ma) and (sl))
//strategy.order("sell", false, strategy.position_size, when = (close > 310) and (strategy.position_size > 0))

//mode 5
//strategy.order("buy", true, 1, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("buy", true, 2, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("buy", true, 4, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("buy", true, 8, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("buy", true, 16, when = (close < 0.75 * ma))

//strategy.order("sell", false, 1, when = (close > 1.05 * ma) and (close < 1.1 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 2, when = (close > 1.1 * ma) and (close < 1.15 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 4, when = (close > 1.15 * ma) and (close < 1.2 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 8, when = (close > 1.2 * ma) and (close < 1.25 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 16, when = (close > 1.25 * ma) and (close < 1.3 * ma) and (strategy.position_size > 0))

//mode 6
//strategy.order("B1", true, unitsLevel1 * units, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("B2", true, unitsLevel2 * units, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("B3", true, unitsLevel3 * units, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("B4", true, unitsLevel4 * units, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("B5", true, unitsLevel5 * units, when = (close < 0.75 * ma))

//strategy.order("S1", false, unitsLevel1 * units, when = (close > 1.05 * ma) and (close < 1.1 * ma) and (strategy.position_size > 0))
//strategy.order("S2", false, unitsLevel2 * units, when = (close > 1.1 * ma) and (close < 1.15 * ma) and (strategy.position_size > 0))
//strategy.order("S3", false, unitsLevel3 * units, when = (close > 1.15 * ma) and (close < 1.2 * ma) and (strategy.position_size > 0))
//strategy.order("S4", false, unitsLevel4 * units, when = (close > 1.2 * ma) and (close < 1.25 * ma) and (strategy.position_size > 0))
//strategy.order("S5", false, unitsLevel5 * units, when = (close > 1.25 * ma) and (close < 1.3 * ma) and (strategy.position_size > 0))

//mode 7
//strategy.order("B1", true, units, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("B2", true, units, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("B3", true, units, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("B4", true, units, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("B5", true, units, when = (close < 0.75 * ma))

//strategy.order("S1", false, units, when = (close > 1.05 * ma) and (close < 1.1 * ma) and (strategy.position_size > 0))
//strategy.order("S2", false, units, when = (close > 1.1 * ma) and (close < 1.15 * ma) and (strategy.position_size > 0))
//strategy.order("S3", false, units, when = (close > 1.15 * ma) and (close < 1.2 * ma) and (strategy.position_size > 0))
//strategy.order("S4", false, units, when = (close > 1.2 * ma) and (close < 1.25 * ma) and (strategy.position_size > 0))
//strategy.order("S5", false, units, when = (close > 1.25 * ma) and (close < 1.3 * ma) and (strategy.position_size > 0))

//banding calculations
aH = 1.0 - deviation
aL = aH - deviation
bH = aL
bL = bH - deviation
cH = bL
cL = cH - deviation
dH = cL
dL = dH - deviation
eH = dL
strategy.initial_capital = 50000
//mode 8
strategy.order("B1", true, unitsLevel1, when = (close < aH * ma) and (close > aL * ma) and (unitsLevel1 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B2", true, unitsLevel2, when = (close < bH * ma) and (close > bL * ma) and (unitsLevel2 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B3", true, unitsLevel3, when = (close < cH * ma) and (close > cL * ma) and (unitsLevel3 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B4", true, unitsLevel4, when = (close < dH * ma) and (close > dL * ma) and (unitsLevel4 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B5", true, unitsLevel5, when = (close < eH * ma) and (unitsLevel5 * close < (strategy.initial_capital + strategy.netprofit)))

//banding calculations
fL = 1.0 + deviation
fH = fL + deviation
gL = fH
gH = gL + deviation
hL = gH
hH = hL + deviation
iL = hH
iH = iL + deviation
jL = iH

strategy.order("S1", false, unitsLevel1, when = (close > fL * ma) and (close < fH * ma) and (strategy.position_size > 0))
strategy.order("S2", false, unitsLevel2, when = (close > gL * ma) and (close < gH * ma) and (strategy.position_size > 0))
strategy.order("S3", false, unitsLevel3, when = (close > hL * ma) and (close < hH * ma) and (strategy.position_size > 0))
strategy.order("S4", false, unitsLevel4, when = (close > iL * ma) and (close < iH * ma) and (strategy.position_size > 0))
strategy.order("S5", false, unitsLevel5, when = (close > jL * ma) and (strategy.position_size > 0))

plot(ma, color=#666666, linewidth=5)

Thêm nữa

2019 FMZ - Tất cả các quyền được bảo lưu