संसाधन लोड हो रहा है... लोड करना...

आरएसआई विभेदन व्यापार रणनीति

लेखक:चाओझांग, दिनांकः 2023-10-25 16:47:14
टैगः

img

अवलोकन

आरएसआई विचलन ट्रेडिंग रणनीति आरएसआई संकेतक और मूल्य आंदोलन के बीच विचलन की पहचान करके खरीद और बिक्री संकेत उत्पन्न करती है। रणनीति में जोखिमों को प्रभावी ढंग से प्रबंधित करने के लिए स्टॉप लॉस, ले लाभ और ट्रेलिंग स्टॉप लॉस भी शामिल हैं।

सिद्धांत

यह रणनीति मुख्य रूप से व्यापार के अवसरों की पहचान करने के लिए आरएसआई संकेतक में विचलन का उपयोग करती है। विशेष रूप से, रणनीति पहले एक निश्चित अवधि में आरएसआई मूल्यों की गणना करती है, फिर आरएसआई संकेतक और मूल्य दोनों के लिए प्रवृत्ति रेखाओं को प्लॉट करती है। जब आरएसआई रेखा मूल्य रेखा से विचलित होती है, अर्थात आरएसआई बढ़ता है जबकि मूल्य गिरता है, या आरएसआई गिरता है जबकि मूल्य बढ़ता है, तो रणनीति इसे आसन्न प्रवृत्ति उलट के संकेत के रूप में लेती है और व्यापार संकेत उत्पन्न करती है।

यदि रणनीति मूल्य रेखा के शीर्ष पर आरएसआई रेखा के नीचे का पता लगाती है, तो एक खरीद संकेत उत्पन्न होता है। यदि आरएसआई रेखा शीर्ष पर है जबकि मूल्य रेखा तल पर है, तो एक बिक्री संकेत उत्पन्न होता है। एक बार ट्रेडिंग संकेत होने के बाद, रणनीति आरएसआई मूल्य आकार के अनुसार व्यापार कर सकती है।

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

लाभ

आरएसआई विचलन व्यापार रणनीति के निम्नलिखित फायदे हैंः

  1. आरएसआई विचलन का पता लगाने से प्रवृत्ति उलट का शीघ्र पता लगाया जा सकता है।

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

  3. आरएसआई पैरामीटर लचीले होते हैं और विभिन्न बाजार स्थितियों के लिए समायोजित किए जा सकते हैं।

  4. स्टॉप लॉस, टेक प्रॉफिट और ट्रेलिंग स्टॉप लॉस जोखिम को प्रभावी ढंग से नियंत्रित करते हैं।

  5. इस रणनीति में मध्यम संकेत आवृत्ति है, जिससे अधिक व्यापार से बचा जा सकता है।

  6. यह तर्क सरल और स्वचालन के लिए प्रोग्राम करने में आसान है।

जोखिम

इस रणनीति में कुछ जोखिम भी हैं:

  1. आरएसआई विचलन पूरी तरह से विश्वसनीय नहीं हैं और झूठे संकेत उत्पन्न कर सकते हैं। अन्य फिल्टर की आवश्यकता है।

  2. मजबूत रुझान वाले बाजारों में विचलन विफल हो सकता है, जिससे बचना चाहिए।

  3. अनुचित आरएसआई मापदंड प्रदर्शन को प्रभावित कर सकते हैं। बहुत कम अवधि आवृत्ति और जोखिम को बढ़ाती है।

  4. स्टॉप लॉस को बहुत सख्ती से सेट करने से मुनाफा कम होता है; बहुत ढीला जोखिम को सीमित करने में विफल रहता है। ठीक से समायोजित करने की आवश्यकता है।

  5. अस्थिर बाजारों के दौरान ट्रेलिंग स्टॉप समय से पहले बंद हो सकता है। अस्थिरता को ध्यान में रखते हुए उचित ट्रेलिंग चौड़ाई की आवश्यकता होती है।

जोखिमों को निम्न के द्वारा कम किया जा सकता हैः

  1. सिग्नल को फ़िल्टर करने और झूठे सिग्नल को कम करने के लिए एमएसीडी, बोलिंगर बैंड जैसे अन्य संकेतक जोड़ना।

  2. इस रणनीति का प्रयोग केवल सीमा-बंद साइडवेज बाजारों के दौरान करें, मजबूत रुझानों से बचें।

  3. आरएसआई मापदंडों का अनुकूलन, इष्टतम लुकबैक अवधि का चयन विभिन्न बाजारों के लिए मापदंडों का परीक्षण।

  4. ऐतिहासिक बैकटेस्टिंग के आधार पर उचित स्टॉप लॉस और लाभ स्तर निर्धारित करना।

  5. बाजार की अस्थिरता और जोखिम की इच्छा के आधार पर पीछे की स्टॉप दूरी को समायोजित करना।

अनुकूलन

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

  1. संकेतों को फ़िल्टर करने और विश्वसनीयता में सुधार के लिए अन्य संकेतकों को शामिल करें।

  2. आरएसआई मापदंडों को स्वचालित रूप से अनुकूलित करने के लिए मशीन लर्निंग का उपयोग करें।

  3. बाजार व्यवस्थाओं के अनुसार गतिशील स्टॉप लॉस एल्गोरिदम डिजाइन करें। रेंज के लिए व्यापक स्टॉप, ट्रेंडिंग बाजारों के लिए तंग स्टॉप।

  4. स्थिति के आकार को समायोजित करने के लिए अस्थिरता के आधार पर गतिशील स्थिति आकार मॉडल का निर्माण करें।

  5. मूल्य उतार-चढ़ाव के आधार पर ट्रेलिंग स्टॉप में उतार-चढ़ाव को सेट करने के लिए ट्रेलिंग दूरी।

  6. विदेशी मुद्रा और क्रिप्टो मुद्राओं जैसे अन्य बाजारों में रणनीति तैनात करें।

  7. स्वचालन के लिए एक मात्रात्मक व्यापार प्रणाली विकसित करना।

निष्कर्ष

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


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

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © faytterro

//@version=5
// strategy("RSI Divergence Strategy", overlay=true, scale = scale.none)
rsilen=input.int(14, title="rsi length")
rsisrc=input(close, title="source")
x=ta.rsi(rsisrc,rsilen)
len=input.int(14, title="RSI Divergence length", maxval=500)
tpb = input.float(25, title="take profit", group = "buy", step = 0.5)
sb = input.float(5, title="stop", group = "buy", step = 0.5)
tsb = input.float(0.25, title="trailing stop", group = "buy", step = 0.5)
tps = input.float(25, title="take profit", group = "sell", step = 0.5)
ss =input.float(5, title="stop", group = "sell", step = 0.5)
tss = input.float(0.25, title="trailing stop", group = "sell", step = 0.5)
src=close
extrapolation=0
zoom=input.int(0, title="zoom", maxval=27, minval=-27)
hline(300-zoom*10, color=color.rgb(54, 58, 69, 100))
hline(10, color=color.rgb(54, 58, 69, 100))
// for ax+b
xo=0.0
yo=0.0
xyo=0.0
xxo=0.0
for i=0 to len-1
    xo:= xo + i/(len)
    yo:= yo + x[len-1-i]/(len)
    xyo:= xyo + i*x[len-1-i]/(len)
    xxo:= xxo + i*i/(len)
dnm=ta.lowest(low,200)
dizi=array.new_float(len*2+1+extrapolation)
// linedizi=array.new_line()
a=(xo*yo-xyo)/(xo*xo-xxo)
b=yo-a*xo
for i=0 to len-1+extrapolation
    array.set(dizi,i,a*i+b)
//// for src
// for ax+b
xo2=0.0
yo2=0.0
xyo2=0.0
xxo2=0.0
for i=0 to len-1
    xo2:= xo2 + i/(len)
    yo2:= yo2 + src[len-1-i]/(len)
    xyo2:= xyo2 + i*src[len-1-i]/(len)
    xxo2:= xxo2 + i*i/(len)

dizi2=array.new_float(len*2+1+extrapolation)
// linedizi2=array.new_line()
a2=(xo2*yo2-xyo2)/(xo2*xo2-xxo2)
b2=yo2-a*xo2
for i=0 to len-1+extrapolation
    array.set(dizi2,i,a2*i+b2)
ttk=((array.get(dizi,0)<array.get(dizi,1)) and (array.get(dizi2,0)>array.get(dizi2,1)))? 1 : 
 ((array.get(dizi,0)>array.get(dizi,1)) and (array.get(dizi2,0)<array.get(dizi2,1)))? -1 : 0
cg=((array.get(dizi,0)<array.get(dizi,1)) and (array.get(dizi2,0)>array.get(dizi2,1)))// and ta.highest(ttk[1],len/2)<1)
cr=((array.get(dizi,0)>array.get(dizi,1)) and (array.get(dizi2,0)<array.get(dizi2,1)))// and ta.lowest(ttk[1],len/2)>-1)
bgcolor(color=(cg and ta.highest(ttk[1],len/2)<1)? color.rgb(76, 175, 79, 50) : 
 (cr and ta.lowest(ttk[1],len/2)>-1)? color.rgb(255, 82, 82, 50) : na, offset=0, display=display.none)
plot(x)

// for ax+b
xo3=0.0
yo3=0.0
xyo3=0.0
xxo3=0.0
for i=0 to len-1
    xo3:= xo3 + i/(len)
    yo3:= yo3 + x[len-1-i+(ta.barssince(cg))]/(len)
    xyo3:= xyo3 + i*x[len-1-i+(ta.barssince(cg))]/(len)
    xxo3:= xxo3 + i*i/(len)

dizi3=array.new_float(len*2+1+extrapolation)
// linedizi3=array.new_line()
a3=(xo3*yo3-xyo3)/(xo3*xo3-xxo3)
b3=yo3-a3*xo3
for i=0 to len-1+extrapolation
    array.set(dizi3,i,a3*i+b3)

// for ax+b
xo4=0.0
yo4=0.0
xyo4=0.0
xxo4=0.0
for i=0 to len-1
    xo4:= xo4 + i/(len)
    yo4:= yo4 + x[len-1-i+(ta.barssince(cr))]/(len)
    xyo4:= xyo4 + i*x[len-1-i+(ta.barssince(cr))]/(len)
    xxo4:= xxo4 + i*i/(len)

dizi4=array.new_float(len*2+1+extrapolation)
// linedizi4=array.new_line()
a4=(xo4*yo4-xyo4)/(xo4*xo4-xxo4)
b4=yo4-a4*xo4
for i=0 to len-1+extrapolation
    array.set(dizi4,i,a4*i+b4)

// line=line.new((last_bar_index-ta.barssince(cg)-len),
//  array.get(dizi3,0), 
//  last_bar_index-ta.barssince(cg),
//  array.get(dizi3,len-1), color=color.rgb(0,255,0), width=2)
// line2=line.new((last_bar_index-ta.barssince(cr)-len),
//  array.get(dizi4,0), 
//  last_bar_index-ta.barssince(cr),
//  array.get(dizi4,len-1), color=color.rgb(255, 0, 0, 0), width=2)
// line.delete(line[1])
// line.delete(line2[1])

alert=((array.get(dizi,0)<array.get(dizi,1)) and (array.get(dizi2,0)>array.get(dizi2,1)) and ta.highest(ttk[1],len/2)<1)
 or ((array.get(dizi,0)>array.get(dizi,1)) and (array.get(dizi2,0)<array.get(dizi2,1)) and ta.lowest(ttk[1],len/2)>-1)
alertcondition(alert)
hline(50)
rs=hline(30)
rss=hline(70)
fill(rs, rss, color=color.rgb(126, 87, 194, 90), title="RSI Background Fill")

longCondition = cg and ta.highest(ttk[1],len/2)<1 
if (longCondition)
    strategy.entry("Long", strategy.long)
    strategy.exit("exit long", "Long", limit = close*(100+tpb)/100 , stop =close*(100-sb)/100 , trail_price = close , trail_offset = close*tsb)

shortCondition = cr and ta.lowest(ttk[1],len/2)>-1 
if (shortCondition)
    strategy.entry("Short", strategy.short)
    strategy.exit("exit short", "Short", limit = close*(100-tps)/100, stop = close*(100+ss)/100, trail_price = close , trail_offset = close*tss)


अधिक