Chiến lược dự báo xu hướng thích nghi nhiều chu kỳ

Tác giả:ChaoZhang, Ngày: 2024-02-01 14:34:38
Tags:

img

Tổng quan

Chiến lược này sử dụng trung bình động thích nghi nhiều chu kỳ và các chỉ số đánh giá rủi ro zigzag, kết hợp với các điểm phân đoạn trong hoạt động thị trường, để dự đoán xu hướng và tín hiệu giao dịch đầu ra.

Nguyên tắc chiến lược

Lập luận cốt lõi của chiến lược được chia thành hai đường chính. Đường chính đầu tiên sử dụng các trung bình động thích nghi nAMA với các tham số khác nhau để xây dựng một hệ thống đánh giá lọc đa chu kỳ. Đường chính thứ hai sử dụng hệ thống đánh giá rủi ro zigzag với các tham số khác nhau để xây dựng một hệ thống đánh giá rủi ro đa chu kỳ. Cuối cùng, hai đường chính được kết hợp. Khi đường chu kỳ ngắn vượt quá đường chu kỳ dài, một tín hiệu mua được tạo ra. Khi đường chu kỳ ngắn nằm dưới đường chu kỳ dài, một tín hiệu bán được tạo ra.

Cụ thể, đường chính đầu tiên thiết lập các đường trung bình động thích nghi lần lượt là 10 chu kỳ và 4, 24 tham số. Đường chính thứ hai thiết lập các đường đánh giá rủi ro zigzag lần lượt là 7 chu kỳ và 4, 300 tham số. Cuối cùng, đường 10 chu kỳ trong đường chính đầu tiên được so sánh với đường 31 chu kỳ trong đường chính thứ hai để tạo ra tín hiệu giao dịch. Khi đường 10 chu kỳ tăng trên đường 31 chu kỳ, một tín hiệu mua được tạo ra. Khi đường 10 chu kỳ giảm xuống dưới đường 31 chu kỳ, một tín hiệu bán được tạo ra.

Ngoài ra, chiến lược cũng thiết lập một mô-đun xác nhận giá khối lượng. Các tín hiệu giao dịch chỉ có giá trị khi khối lượng giao dịch lớn hơn khối lượng giao dịch trung bình 6 chu kỳ. Điều này có thể lọc ra các tín hiệu sai ở một mức độ nào đó. Cuối cùng, chiến lược vẽ các điểm phân đoạn của các mức chu kỳ khác nhau làm tín hiệu tham chiếu.

Phân tích lợi thế chiến lược

Lợi thế lớn nhất của chiến lược này là việc áp dụng các cấu trúc thích nghi đa chu kỳ, có thể điều chỉnh chu kỳ theo điều kiện thị trường để điều chỉnh chu kỳ một cách năng động.

Ngoài ra, chiến lược sử dụng bộ lọc chung nhiều chu kỳ của các hệ thống đánh giá rủi ro zigzag để kiểm soát hiệu quả rủi ro giao dịch và tránh thiết lập các vị trí trong các giai đoạn rủi ro cao.

Phân tích rủi ro chiến lược

Rủi ro lớn nhất của chiến lược này là nó đòi hỏi cùng một phán đoán về hướng của nhiều đường chu kỳ, do đó khả năng nắm bắt thị trường đảo ngược ngắn hạn kém. Khi đường chu kỳ ngắn và đường chu kỳ dài thay đổi cùng một lúc, các tín hiệu không rõ ràng có thể dễ dàng được tạo ra. Các chu kỳ tham số có thể được rút ngắn để tối ưu hóa.

Ngoài ra, giai đoạn chu kỳ chính của hệ thống đánh giá rủi ro đường trung bình chuyển động thích nghi và zigzag tương đối ngắn so với thị trường rộng hơn, và có một số sự chậm trễ do động lực của các mức độ dài hơn.

Hướng dẫn tối ưu hóa chiến lược

  1. Giảm các thông số chu kỳ chính của đường đánh giá rủi ro chuyển động thích nghi và đường đánh giá rủi ro zigzag xuống 5 chu kỳ và 20 chu kỳ để tăng khả năng nắm bắt sự đảo ngược thị trường ngắn hạn.

  2. Tăng các tham số chu kỳ chính lên 20 chu kỳ và 50 chu kỳ để giảm sự chậm trễ trong các trình điều khiển thị trường đồng đều lâu hơn.

  3. Tối ưu hóa các thông số kênh giao dịch lên 0,5 lần kênh ATR để giảm khả năng giao dịch ồn ào.

  4. Thêm các chỉ số xác minh kết quả như MACD để cải thiện độ tin cậy tín hiệu.

Tóm lại

Chiến lược này sử dụng nhiều chỉ số kỹ thuật như trung bình động thích nghi, đánh giá rủi ro zigzag và phân tích giá khối lượng để xây dựng một hệ thống quyết định giao dịch thích nghi nhiều chu kỳ. Thông qua tối ưu hóa và điều chỉnh các tham số, nó có thể được áp dụng cho các loại thị trường khác nhau, tự động xác định xu hướng và phạm vi.


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

//@version=2
strategy("Best Rabbit Strategy", shorttitle="Rabbit God",overlay=true)
Length = input(10, minval=1)
xPrice = close
xvnoise = abs(xPrice - xPrice[1])
Fastend = input(2)
Slowend = input(30)
nfastend = 2/(Fastend + 1)
nslowend = 2/(Slowend + 1)
nsignal = abs(xPrice - xPrice[Length])
nnoise = sum(xvnoise, Length)
nefratio = iff(nnoise != 0, nsignal / nnoise, 0)
nsmooth = pow(nefratio * (nfastend - nslowend) + nslowend, 2) 
nAMA = nz(nAMA[1]) + nsmooth * (xPrice - nz(nAMA[1]))

Length2 = input(10, minval=1)
xPrice2 = close
xvnoise2 = abs(xPrice2 - xPrice2[1])
Fastend2 = input(4)
Slowend2 = input(24)
nfastend2 = 2/(Fastend2 + 1)
nslowend2 = 2/(Slowend2 + 1)
nsignal2 = abs(xPrice2 - xPrice2[Length2])
nnoise2 = sum(xvnoise, Length2)
nefratio2 = iff(nnoise2 != 0, nsignal2 / nnoise2, 0)
nsmooth2 = pow(nefratio2 * (nfastend2 - nslowend2) + nslowend2, 2) 
nAMA2 = nz(nAMA2[1]) + nsmooth2 * (xPrice2 - nz(nAMA2[1]))

price = input(hl2)
len = input(defval=7,minval=1)
FC = input(defval=4,minval=1)
SC = input(defval=300,minval=1)
len1 = len/2
w = log(2/(SC+1))
H1 = highest(high,len1)
L1 = lowest(low,len1)
N1 = (H1-L1)/len1
H2 = highest(high,len)[len1]
L2 = lowest(low,len)[len1]
N2 = (H2-L2)/len1
H3 = highest(high,len)
L3 = lowest(low,len)
N3 = (H3-L3)/len
dimen1 = (log(N1+N2)-log(N3))/log(2)
dimen = iff(N1>0 and N2>0 and N3>0,dimen1,nz(dimen1[1]))
alpha1 = exp(w*(dimen-1))
oldalpha = alpha1>1?1:(alpha1<0.01?0.01:alpha1)
oldN = (2-oldalpha)/oldalpha
N = (((SC-FC)*(oldN-1))/(SC-1))+FC
alpha_ = 2/(N+1)
alpha = alpha_<2/(SC+1)?2/(SC+1):(alpha_>1?1:alpha_)
out = (1-alpha)*nz(out[1]) + alpha*price

price2 = input(hl2)
len2 = input(defval=31,minval=1)
FC2 = input(defval=40,minval=1)
SC2 = input(defval=300,minval=1)
len12 = len2/2
w2 = log(2/(SC2+1))
H12 = highest(high,len12)
L12 = lowest(low,len12)
N12 = (H1-L1)/len12
H22 = highest(high,len2)[len12]
L22 = lowest(low,len2)[len12]
N22 = (H22-L22)/len12
H32 = highest(high,len2)
L32 = lowest(low,len2)
N32 = (H32-L32)/len2
dimen12 = (log(N12+N22)-log(N32))/log(2)
dimen2 = iff(N12>0 and N22>0 and N32>0,dimen12,nz(dimen12[1]))
alpha12 = exp(w*(dimen2-1))
oldalpha2 = alpha12>1?1:(alpha12<0.01?0.01:alpha12)
oldN2 = (2-oldalpha2)/oldalpha2
N4 = (((SC2-FC2)*(oldN2-1))/(SC2-1))+FC2
alpha_2 = 2/(N4+1)
alpha2 = alpha_2<2/(SC2+1)?2/(SC2+1):(alpha_2>1?1:alpha_2)
out2 = (1-alpha2)*nz(out2[1]) + alpha2*price2

tf = input(title="Resolution",  defval = "current")
vamp = input(title="VolumeMA",  defval=6)
vam = sma(volume, vamp)

up = high[3]>high[4] and high[4]>high[5] and high[2]<high[3] and high[1]<high[2] and volume[3]>vam[3]
down = low[3]<low[4] and low[4]<low[5] and low[2]>low[3] and low[1]>low[2] and volume[3]>vam[3]
fractalup =  up ? high[3] : fractalup[1] 
fractaldown = down ? low[3] : fractaldown[1]

fuptf = request.security(syminfo.tickerid,tf == "current" ? timeframe.period : tf, fractalup)
fdowntf = request.security(syminfo.tickerid,tf == "current" ? timeframe.period : tf, fractaldown)

plot(fuptf, "FractalUp", color=lime, linewidth=1, style=cross, transp=0, offset =-3, join=false)
plot(fdowntf, "FractalDown", color=red, linewidth=1, style=cross, transp=0, offset=-3, join=false)

buyEntry= nAMA[0]>nAMA2[0] and out[0]>out2[0]
sellEntry= nAMA[0]<nAMA2[0] and out[0]<out2[0]

if (buyEntry)
    strategy.entry("Buy", strategy.long, comment="Long Position Entry")


if (sellEntry)
    strategy.entry("Sell", strategy.short, comment="Short Position Entry")

Thêm nữa