1. वर्ग
  2. बहु-समय-सीमा चलती औसत प्रणाली व्यापार रणनीति

बहु-समय-सीमा चलती औसत प्रणाली व्यापार रणनीति

लेखक:चाओझांग, दिनांक: 2023-12-12 16:07:18
टैगः

img

अवलोकन

यह रणनीति एक मल्टी-टाइमफ्रेम मूविंग एवरेज सिस्टम को अपनाती है, जो आरएसआई और अन्य तकनीकी संकेतकों के साथ संयुक्त है, ताकि लंबी और छोटी स्थिति के बीच स्वचालित स्विचिंग प्राप्त हो सके। रणनीति का नाम मल्टी-टाइमफ्रेम मूविंग एवरेज सिस्टम ट्रेडिंग रणनीति है। मुख्य विचार विभिन्न समय अवधि में मूल्य रुझानों की तुलना करके अधिक विश्वसनीय ट्रेडिंग संकेत उत्पन्न करना है।

सिद्धांत

इस रणनीति के मुख्य संकेतक चलती औसत प्रणाली हैं। रणनीति 15min, 30min, 60min जैसी विभिन्न अवधि में मूल्य रुझानों की गणना करने के लिए JMA, TEMA, DEMA जैसे कई चलती औसत संकेतक का उपयोग करती है। उदाहरण के लिए, 15min समय सीमा में JMA द्वारा गणना की गई MA प्रवृत्ति उस समय सीमा के भीतर मूल्य प्रवृत्ति निर्णय का प्रतिनिधित्व करती है। फिर रणनीति लंबी और छोटी प्रवृत्तियों के बीच विचलन की पहचान करने के लिए विभिन्न समय सीमाओं के बीच मूल्य प्रवृत्तियों की तुलना करती है। यदि महत्वपूर्ण विचलन का पता लगाया जाता है, तो ट्रेडिंग संकेत उत्पन्न किए जाएंगे। इसके अलावा, रणनीति में ट्रेडिंग संकेतों की विश्वसनीयता सुनिश्चित करने के लिए RSI और वेव ट्रेंड जैसे अन्य संकेतक भी शामिल हैं।

विशेष रूप से, रणनीति में रुझान, रुझान2 और रुझान3 चर क्रमशः 15 मिनट, 30 मिनट और 60 मिनट के समय सीमाओं के मूल्य रुझानों का प्रतिनिधित्व करते हैं। यदि 15 मिनट की मूल्य उलट है, जबकि 30 मिनट और 60 मिनट अभी तक उलट नहीं हुआ है, तो इसे कम और लंबे समय के रुझानों के बीच विचलन के रूप में माना जाता है, इस प्रकार एक ट्रेडिंग संकेत उत्पन्न होता है। यदि सभी समय सीमाओं के रुझान सुसंगत हैं तो कोई संकेत उत्पन्न नहीं होंगे।

कई समय सीमाओं के बीच संबंधों की तुलना करके और कुछ झूठे संकेतों को फ़िल्टर करके, अधिक विश्वसनीय ट्रेडिंग संकेत उत्पन्न किए जा सकते हैं यह रणनीति का मूल विचार है।

लाभ विश्लेषण

इस रणनीति के मुख्य लाभ इस प्रकार हैंः

  1. मल्टी टाइमफ्रेम विश्लेषण और झूठे संकेतों की फ़िल्टरिंग के माध्यम से सिग्नल विश्वसनीयता में सुधार;
  2. व्यापक आकलन के लिए कई संकेतकों को मिलाकर एकल संकेतकों के साथ समस्याओं से बचना।
  3. मैनुअल हस्तक्षेप के बिना लंबी और छोटी स्थिति के बीच स्वचालित स्विच, परिचालन कठिनाई को कम करता है।

जोखिम विश्लेषण

इस रणनीति के साथ कुछ जोखिम भी मौजूद हैंः

  1. बहु-समय-सीमा विश्लेषण व्यापार में प्रवेश के समय के बारे में अनिश्चितता पैदा करता है जिससे सर्वोत्तम प्रवेश मूल्यों की कमी हो सकती है;
  2. कई संकेतकों के संयोजन के दौरान अनुचित पैरामीटर सेटिंग्स से ट्रेडिंग सिग्नल की गुणवत्ता में गिरावट आ सकती है।
  3. ऑटोमैटिक पोजीशन स्विचिंग से ओवर-ऑप्टिमाइजेशन और बैकटेस्ट के मुकाबले कमज़ोर रियल ट्रेडिंग परफॉरमेंस का खतरा होता है।

उपरोक्त जोखिमों को कम करने के लिए हम निम्नलिखित उपाय कर सकते हैंः

  1. समय पर प्रवेश के लिए अल्पकालिक संकेतों को पकड़ने के लिए समय सीमा मापदंडों को ठीक से समायोजित करना;
  2. संकेतक मापदंडों को लगातार अनुकूलित करने के लिए व्यापक बैकटेस्टिंग;
  3. स्वचालित प्रणालियों द्वारा अंधेरे व्यापार को रोकने के लिए वास्तविक व्यापार में उचित हस्तक्षेप।

अनुकूलन दिशाएँ

इस रणनीति को और अधिक अनुकूलित करने की गुंजाइश हैः

  1. मॉडल प्रशिक्षण के माध्यम से कई संकेतकों पर मापदंडों को स्वचालित रूप से अनुकूलित करने के लिए मशीन लर्निंग एल्गोरिदम पेश करना;
  2. वास्तविक ट्रेडिंग प्रदर्शन में सुधार के लिए बाजार अस्थिरता के स्तरों के आधार पर अनुकूलनशील फिसलन सेटिंग्स जोड़ें;
  3. तेजी से रुझान उलटने से होने वाले नुकसान से बचने के लिए मूल्य-मात्रा पुष्टि तंत्र शामिल करें।

निष्कर्ष

यह रणनीति दीर्घकालिक बनाम अल्पकालिक संबंधों की पहचान करने के लिए बहु-समय-सीमा मूल्य रुझानों की तुलना करती है, और कई संकेतकों का विश्लेषण करके ट्रेडिंग संकेत उत्पन्न करती है अच्छे बैकटेस्ट परिणामों के साथ लॉन्ग और शॉर्ट्स के बीच स्वचालित स्विचिंग प्राप्त करना। हमने वास्तविक ट्रेडिंग प्रदर्शन को और बढ़ाने के लिए मशीन लर्निंग, अनुकूलनशील फिसलन और वॉल्यूम पुष्टि जैसी विधियों के माध्यम से सुधार के कुछ क्षेत्रों की भी पहचान की।

/*backtest
start: 2023-11-11 00:00:00
end: 2023-12-11 00:00:00
period: 4h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=2
strategy("Drexel Strategy", overlay=true )
Length1=7
Length2=9
Multiplier=input(1.5,"Multiplier")
jma(src,length) =>
    beta = 0.45*(length-1)/(0.45*(length-1)+2)
    alpha = beta
    tmp0 = (1-alpha)*src + alpha*nz(tmp0[1])
    tmp1 = (src - tmp0[0])*(1-beta) + beta*nz(tmp1[1])
    tmp2 = tmp0[0] + tmp1[0]
    tmp3 = (tmp2[0] - nz(tmp4[1]))*((1-alpha)*(1-alpha)) + (alpha*alpha)*nz(tmp3[1])
    tmp4 = nz(tmp4[1]) + tmp3[0]
    JMA = tmp4
    JMA
rsx(src,length) =>
    f90_ = (nz(f90_[1]) == 0.0) ? 1.0 : (nz(f88[1]) <= nz(f90_[1])) ? nz(f88[1])+1 : nz(f90_[1])+1
    f88 = (nz(f90_[1]) == 0.0) and (length-1 >= 5) ? length-1.0 : 5.0 
    f8 =  100.0*(src) 
    f18 = 3.0 / (length + 2.0) 
    f20 = 1.0 - f18 
    f10 = nz(f8[1])
    v8 = f8 - f10 
    f28 = f20 * nz(f28[1]) + f18 * v8 
    f30 = f18 * f28 + f20 * nz(f30[1])
    vC = f28 * 1.5 - f30 * 0.5 
    f38 = f20 * nz(f38[1]) + f18 * vC 
    f40 = f18 * f38 + f20 * nz(f40[1])
    v10 = f38 * 1.5 - f40 * 0.5 
    f48 = f20 * nz(f48[1]) + f18 * v10 
    f50 = f18 * f48 + f20 * nz(f50[1])
    v14 = f48 * 1.5 - f50 * 0.5 
    f58 = f20 * nz(f58[1]) + f18 * abs(v8) 
    f60 = f18 * f58 + f20 * nz(f60[1])
    v18 = f58 * 1.5 - f60 * 0.5
    f68 = f20 * nz(f68[1]) + f18 * v18 
    f70 = f18 * f68 + f20 * nz(f70[1])
    v1C = f68 * 1.5 - f70 * 0.5 
    f78 = f20 * nz(f78[1]) + f18 * v1C 
    f80 = f18 * f78 + f20 * nz(f80[1])
    v20 = f78 * 1.5 - f80 * 0.5
    f0 = ((f88 >= f90_) and (f8 != f10)) ? 1.0  : 0.0
    f90 = ((f88 == f90_) and (f0 == 0.0))  ? 0.0  : f90_
    v4_ = ((f88 < f90) and (v20 > 0.0000000001)) ? (v14 / v20 + 1.0) * 50.0 : 50.0
    rsx = ((v4_ > 100.0) ? 100.0 : (v4_ < 0.0) ? 0.0 : v4_)-50
    rsx
xPrice=open
emaA = ema(xPrice, Length2)  
Xprice = rsx(open,14)
XPrice = high, xprice = low
xe1 = jma(xPrice, Length1)
xe11 = jma(Xprice[1],Length1)
xe111 = jma(XPrice[1],Length1)
xe1111=jma(xprice[1],Length1)
xe2 = jma(xe1, Length1)
xe21 = jma(xe111, Length1)
xe3 = jma(xe2, Length1)
xe31 = jma(xe1111,Length2)
xe3a = jma(xe2,Length1)
xe4 = jma(xe3, Length1)
xe5 = jma(xe4, Length1)
xe6 = jma(xe5, Length1)
b = 0.7
c1 = -b*b*b
c2 = 3*b*b+3*b*b*b
c3 = -6*b*b-3*b-3*b*b*b
c3a = nz(c3a[1])
c4 = 1+3*b+b*b*b+3*b*b
TEMA = c1 * xe6 + c2 * xe5 + c3 * xe4 + c4 * xe3
DEMA = 2 * emaA - ema(emaA, Length2)
Length(mod)=>(mod*c3a)+Length2
Trend1=TEMA/DEMA
a=rsx(open,Length(2))
b1=rsx(open,Length(3))
c=rsx(open,Length(5))
d=rsx(open,Length(8))
e=rsx(open,Length(13))
f=rsx(open,Length(21))
g=rsx(open,Length(34))
h=rsx(open,Length(55))
i=rsx(open,Length(89))
j=rsx(open,Length(144))
trend1 = (((a-b1)+(c-d)+(e-f)+(g-h)+(i-j))/10)
trend = trend1>0?avg(a,b,c4,c2):trend1==0?XPrice:avg(rsx(open,24),jma(open,24),rsx(jma(open,24),24))
trend2 = trend1>0?avg(d,e,c2,c1):trend1==0?XPrice:avg(rsx(open,48),jma(open,48),rsx(jma(open,48),48))
trend3 = trend1>0?avg(d,e,c2,c1):trend1==0?xprice:avg(rsx(open,96),jma(open,96),rsx(jma(open,96),96))
bc=request.security(syminfo.tickerid,'15',trend)
bc1=request.security(syminfo.tickerid,'15',trend2)
bc2=request.security(syminfo.tickerid,'15',trend3)
bd=request.security(syminfo.tickerid,'30',trend)
bd1=request.security(syminfo.tickerid,'30',trend2)
bd2=request.security(syminfo.tickerid,'30',trend3)
be=request.security(syminfo.tickerid,'60',trend)
be1=request.security(syminfo.tickerid,'60',trend2)
be2=request.security(syminfo.tickerid,'60',trend3)
bf=request.security(syminfo.tickerid,'120',trend)
bf1=request.security(syminfo.tickerid,'120',trend2)
bf2=request.security(syminfo.tickerid,'120',trend3)
bg=request.security(syminfo.tickerid,'240',trend)
bg1=request.security(syminfo.tickerid,'240',trend2)
bg2=request.security(syminfo.tickerid,'240',trend3)
bh=request.security(syminfo.tickerid,'D',trend)
bh1=request.security(syminfo.tickerid,'D',trend2)
bh2=request.security(syminfo.tickerid,'D',trend3)
Trend=((bc-bc1)+(bd-bd1)+(be-be1)+(bf-bf1)+(bg-bg1)+(bh))
Trend11=((bc-bc1)+(bd-bd1)+(be-be1)+(bf-bf1)+(bg-bg1)+(bh1))
Trend33 = max(min(min(min(bc2,bd2),min(be2,bf2)),bg2),bh2)
AverageTrend=sma(Trend1,1000)
StdDev=Multiplier*stdev(Trend1,1000)
TopBand=AverageTrend+StdDev
BotBand=AverageTrend-StdDev
ap=open
n1=10
n2=21
esa1 = jma(ap, n1)
d1 = jma(abs(ap - esa1), n1)
x1 = trend3==Trend33
y1 = trend2==Trend11 
ci = (ap - esa1) / (0.015 * d1)
tci = jma(ci, n2)
wt1=tci
wt2=sma(wt1,4)
fast=jma(open,5)
slow=jma(open,13)
macd=fast-slow
signal=sma(macd,4)
WaveTrend1=wt1-wt2
JMACD1=macd-signal
rsi = (((rsi(open,6))-50)*3)
g1=rsi>Trend1 and WaveTrend1>Trend1 and JMACD1>Trend1
h1=g1?tci*c3a:nz(h[1])
strategy.entry("Long",true,when=x1)
strategy.close("Long",y1)
strategy.entry("Short",false,when=y1)
strategy.close("Short",x1)
अधिक

2019 FMZ - सभी अधिकार सुरक्षित