औसत प्रतिवर्ती गति रणनीति

लेखक:चाओझांग, दिनांक: 2023-11-15 17:40:59
टैगः

img

अवलोकन

औसत प्रतिगमन गति रणनीति एक प्रवृत्ति व्यापार रणनीति है जो अल्पकालिक मूल्य औसत को ट्रैक करती है। यह मध्यम अवधि के बाजार प्रवृत्ति का न्याय करने के लिए औसत प्रतिगमन संकेतक और गति संकेतक को जोड़ती है।

रणनीति तर्क

रणनीति पहले औसत प्रतिगमन रेखा और मूल्य के मानक विचलन की गणना करती है। फिर, ऊपरी सीमा और निचली सीमा मापदंडों द्वारा निर्धारित सीमा मानों के साथ संयुक्त, यह गणना करती है कि क्या मूल्य औसत प्रतिगमन रेखा से एक मानक विचलन की सीमा से अधिक है। यदि हां, तो एक ट्रेडिंग संकेत उत्पन्न होता है।

लॉन्ग सिग्नल के लिए, कीमत को एक मानक विचलन द्वारा औसत प्रतिगमन रेखा से नीचे होना चाहिए, क्लोज मूल्य LENGTH अवधि के SMA से नीचे है, और TREND SMA से ऊपर है, यदि ये तीन शर्तें पूरी हो जाती हैं, तो एक लंबी स्थिति खोली जाएगी। समापन शर्त तब होती है जब कीमत LENGTH अवधि के SMA से ऊपर टूट जाती है।

शॉर्ट सिग्नल के लिए, कीमत को एक मानक विचलन द्वारा औसत प्रतिगमन रेखा से ऊपर होने की आवश्यकता होती है, क्लोज मूल्य LENGTH अवधि के SMA से ऊपर होता है, और TREND SMA से नीचे होता है, यदि ये तीन शर्तें पूरी होती हैं, तो एक शॉर्ट स्थिति खोली जाएगी। समापन शर्त तब होती है जब कीमत LENGTH अवधि के SMA से नीचे टूट जाती है।

इस रणनीति में लाभ लेने और स्टॉप लॉस प्रबंधन के लिए प्रतिशत लाभ लक्ष्य और प्रतिशत स्टॉप लॉस का भी संयोजन किया गया है।

बाहर निकलने की विधि चलती औसत क्रॉसओवर या रैखिक प्रतिगमन क्रॉसओवर के बीच चयन कर सकती है।

दो-दिशात्मक व्यापार, प्रवृत्ति फ़िल्टरिंग, लाभ लेने और स्टॉप लॉस आदि के संयोजन के माध्यम से, यह मध्यम अवधि के बाजार के रुझानों का न्याय और ट्रैकिंग करता है।

लाभ

  1. औसत प्रतिगमन सूचक मूल्य केंद्र से मूल्य के विचलन का प्रभावी ढंग से न्याय कर सकता है।

  2. गति सूचक एसएमए अल्पकालिक बाजार शोर को फ़िल्टर कर सकता है।

  3. द्विदिशात्मक व्यापार सभी दिशाओं में रुझान के अवसरों को पूरी तरह से पकड़ सकता है।

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

  5. चयन योग्य निकास विधियां बाजार स्थितियों के अनुकूल होने के लिए लचीली हो सकती हैं।

  6. एक पूर्ण ट्रेंड ट्रेडिंग रणनीति जो मध्यम अवधि के रुझानों को बेहतर ढंग से पकड़ती है।

जोखिम

  1. औसत प्रतिगमन सूचक पैरामीटर सेटिंग्स के प्रति संवेदनशील है, गलत सीमा सेटिंग्स गलत संकेत का कारण बन सकती हैं।

  2. अस्थिर बाजार स्थितियों में, स्टॉप लॉस को बहुत बार ट्रिगर किया जा सकता है।

  3. साइडवेज रुझानों में, ट्रेडिंग आवृत्ति बहुत अधिक हो सकती है, जिससे ट्रेडिंग लागत और फिसलने के जोखिम बढ़ते हैं।

  4. जब व्यापारिक साधन में अपर्याप्त तरलता होती है, तो फिसलने पर नियंत्रण अपर्याप्त हो सकता है।

  5. द्विदिशात्मक व्यापार में अधिक जोखिम होता है, इसलिए सावधानीपूर्वक धन प्रबंधन की आवश्यकता होती है।

इन जोखिमों को पैरामीटर अनुकूलन, स्टॉप लॉस समायोजन, धन प्रबंधन आदि के माध्यम से नियंत्रित किया जा सकता है।

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

  1. विभिन्न व्यापारिक साधनों के अनुकूल होने के लिए औसत प्रतिगमन और गति संकेतकों की पैरामीटर सेटिंग्स को अनुकूलित करें।

  2. रुझान पहचानने की क्षमता में सुधार के लिए रुझान पहचानने वाले संकेतक जोड़ें।

  3. बाजार के महत्वपूर्ण उतार-चढ़ावों के अनुकूल स्टॉप लॉस रणनीति का अनुकूलन करना।

  4. बाजार की स्थितियों के आधार पर स्थिति के आकार को समायोजित करने के लिए स्थिति आकार मॉड्यूल जोड़ें।

  5. जोखिम प्रबंधन के अधिक मॉड्यूल जोड़ें, जैसे अधिकतम निकासी नियंत्रण, इक्विटी वक्र नियंत्रण आदि।

  6. स्वचालित रूप से रणनीति मापदंडों का अनुकूलन करने के लिए मशीन लर्निंग विधियों को जोड़ने पर विचार करें।

सारांश

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


/*backtest
start: 2023-10-15 00:00:00
end: 2023-11-14 00:00:00
period: 1h
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/
// © GlobalMarketSignals

//@version=4
strategy("GMS: Mean Reversion Strategy", overlay=true)

LongShort       = input(title="Long Only or Short Only or Both?", type=input.string, defval="Both", options=["Both", "Long Only", "Short Only"])
Lookback        = input(title="Length", type=input.integer, defval=10, minval=0)
LThr1           = input(title="Upper threshold", type=input.float, defval=1, minval=0)
LThr            = input(title="Lower threshold", type=input.float, defval=-1, maxval=0)
src             = input(title="Source", type=input.source, defval=close)
LongShort2      = input(title="Linear Regression Exit or Moving Average Exit?", type=input.string, defval="MA", options=["LR", "MA"])
SMAlenL         = input(title="MA/LR Exit Length", type = input.integer ,defval=10)
SMALen2         = input(title="Trend SMA Length", type = input.integer ,defval=200)
AboveBelow      = input(title="Above or Below Trend SMA?", type=input.string, defval="Above", options=["Above", "Below", "Don't Include"])
PTbutton        = input(title="Profit Target On/Off", type=input.bool, defval=true)
ProfitTarget    = input(title="Profit Target %", type=input.float, defval=1, step=0.1, minval=0)
SLbutton        = input(title="Stop Loss On/Off", type=input.bool, defval=true)
StopLoss        = input(title="Stop Loss %", type=input.float, defval=-1, step=0.1, maxval=0)

x               = (src-linreg(src,Lookback,0))/(stdev(src,Lookback))

plot(linreg(src,Lookback,0))

//PROFIT TARGET & STOPLOSS

if PTbutton == true and SLbutton == true
    strategy.exit("EXIT", profit=((close*(ProfitTarget*0.01))/syminfo.mintick), loss=((close*(StopLoss*-0.01))/syminfo.mintick))
else
    if PTbutton == true and SLbutton == false
        strategy.exit("PT EXIT", profit=((close*(ProfitTarget*0.01))/syminfo.mintick))
    else
        if PTbutton == false and SLbutton == true
            strategy.exit("SL EXIT", loss=((close*(StopLoss*-0.01))/syminfo.mintick))
        else    
            strategy.cancel("PT EXIT")


////////////////////////
//MOVING AVERAGE EXIT//
//////////////////////

if LongShort=="Long Only" and AboveBelow=="Above" and LongShort2 =="MA"
    strategy.entry("LONG", true, when = x<LThr and close<sma(close,SMAlenL) and close>sma(close,SMALen2))
    strategy.close("LONG", when = close>sma(close,SMAlenL))

if LongShort=="Long Only" and AboveBelow=="Below" and LongShort2 =="MA"
    strategy.entry("LONG", true, when = x<LThr and close<sma(close,SMAlenL) and close<sma(close,SMALen2))
    strategy.close("LONG", when = close>sma(close,SMAlenL))

if LongShort=="Long Only" and AboveBelow=="Don't Include" and LongShort2 =="MA"
    strategy.entry("LONG", true, when = x<LThr and close<sma(close,SMAlenL) )
    strategy.close("LONG", when = close>sma(close,SMAlenL))
    
///////    
    
if LongShort=="Short Only" and AboveBelow=="Above" and LongShort2 =="MA"
    strategy.entry("SHORT", false, when = x>LThr1 and close>sma(close,SMAlenL) and close>sma(close,SMALen2))
    strategy.close("SHORT", when = close<sma(close,SMAlenL))

if LongShort=="Short Only" and AboveBelow=="Below" and LongShort2 =="MA"
    strategy.entry("SHORT", false, when = x>LThr1 and close>sma(close,SMAlenL)   and close<sma(close,SMALen2))
    strategy.close("SHORT", when = close<sma(close,SMAlenL))

if LongShort=="Short Only" and AboveBelow=="Don't Include" and LongShort2 =="MA"
    strategy.entry("SHORT", false, when = x>LThr1  and close>sma(close,SMAlenL)  )
    strategy.close("SHORT", when = close<sma(close,SMAlenL))
    
//////

if LongShort=="Both" and AboveBelow=="Above" and LongShort2 =="MA"
    strategy.entry("LONG", true, when = x<LThr and close<sma(close,SMAlenL) and close>sma(close,SMALen2))
    strategy.close("LONG", when = close>sma(close,SMAlenL))

if LongShort=="Both" and AboveBelow=="Below" and LongShort2 =="MA"
    strategy.entry("LONG", true, when = x<LThr and close<sma(close,SMAlenL) and close<sma(close,SMALen2))
    strategy.close("LONG", when = close>sma(close,SMAlenL))

if LongShort=="Both" and AboveBelow=="Don't Include" and LongShort2 =="MA"
    strategy.entry("LONG", true, when = x<LThr and close<sma(close,SMAlenL) )
    strategy.close("LONG", when = close>sma(close,SMAlenL))
    
///////    
    
if LongShort=="Both" and AboveBelow=="Above" and LongShort2 =="MA"
    strategy.entry("SHORT", false, when = x>LThr1 and close>sma(close,SMAlenL) and close>sma(close,SMALen2))
    strategy.close("SHORT", when = close<sma(close,SMAlenL))

if LongShort=="Both" and AboveBelow=="Below" and LongShort2 =="MA"
    strategy.entry("SHORT", false, when = x>LThr1 and close>sma(close,SMAlenL) and close<sma(close,SMALen2))
    strategy.close("SHORT", when = close<sma(close,SMAlenL))

if LongShort=="Both" and AboveBelow=="Don't Include" and LongShort2 =="MA"
    strategy.entry("SHORT", false, when = x>LThr1 and close>sma(close,SMAlenL) )
    strategy.close("SHORT", when = close<sma(close,SMAlenL))
    
/////////////////
//LIN REG EXIT//
///////////////

if LongShort=="Long Only" and AboveBelow=="Above" and LongShort2 =="LR"
    strategy.entry("LONG", true, when = x<LThr and close<linreg(close,SMAlenL,0) and close>sma(close,SMALen2))
    strategy.close("LONG", when = close>linreg(close,SMAlenL,0))

if LongShort=="Long Only" and AboveBelow=="Below" and LongShort2 =="LR"
    strategy.entry("LONG", true, when = x<LThr and close<linreg(close,SMAlenL,0) and close<sma(close,SMALen2))
    strategy.close("LONG", when = close>linreg(close,SMAlenL,0))

if LongShort=="Long Only" and AboveBelow=="Don't Include" and LongShort2 =="LR"
    strategy.entry("LONG", true, when = x<LThr and close<linreg(close,SMAlenL,0) )
    strategy.close("LONG", when = close>linreg(close,SMAlenL,0))
    
///////    
    
if LongShort=="Short Only" and AboveBelow=="Above" and LongShort2 =="LR"
    strategy.entry("SHORT", false, when = x>LThr1 and close>linreg(close,SMAlenL,0) and close>sma(close,SMALen2))
    strategy.close("SHORT", when = close<linreg(close,SMAlenL,0))

if LongShort=="Short Only" and AboveBelow=="Below" and LongShort2 =="LR"
    strategy.entry("SHORT", false, when = x>LThr1 and close>linreg(close,SMAlenL,0)   and close<sma(close,SMALen2))
    strategy.close("SHORT", when = close<linreg(close,SMAlenL,0))

if LongShort=="Short Only" and AboveBelow=="Don't Include" and LongShort2 =="LR"
    strategy.entry("SHORT", false, when = x>LThr1  and close>linreg(close,SMAlenL,0)  )
    strategy.close("SHORT", when = close<linreg(close,SMAlenL,0))
    
//////

if LongShort=="Both" and AboveBelow=="Above" and LongShort2 =="LR"
    strategy.entry("LONG", true, when = x<LThr and close<linreg(close,SMAlenL,0) and close>sma(close,SMALen2))
    strategy.close("LONG", when = close>linreg(close,SMAlenL,0))

if LongShort=="Both" and AboveBelow=="Below" and LongShort2 =="LR"
    strategy.entry("LONG", true, when = x<LThr and close<linreg(close,SMAlenL,0) and close<sma(close,SMALen2))
    strategy.close("LONG", when = close>linreg(close,SMAlenL,0))

if LongShort=="Both" and AboveBelow=="Don't Include" and LongShort2 =="LR"
    strategy.entry("LONG", true, when = x<LThr and close<linreg(close,SMAlenL,0) )
    strategy.close("LONG", when = close>linreg(close,SMAlenL,0))
    
///////    
    
if LongShort=="Both" and AboveBelow=="Above" and LongShort2 =="LR"
    strategy.entry("SHORT", false, when = x>LThr1 and close>linreg(close,SMAlenL,0) and close>sma(close,SMALen2))
    strategy.close("SHORT", when = close<linreg(close,SMAlenL,0))

if LongShort=="Both" and AboveBelow=="Below" and LongShort2 =="LR"
    strategy.entry("SHORT", false, when = x>LThr1 and close>linreg(close,SMAlenL,0) and close<sma(close,SMALen2))
    strategy.close("SHORT", when = close<linreg(close,SMAlenL,0))

if LongShort=="Both" and AboveBelow=="Don't Include" and LongShort2 =="LR"
    strategy.entry("SHORT", false, when = x>LThr1 and close>linreg(close,SMAlenL,0) )
    strategy.close("SHORT", when = close<linreg(close,SMAlenL,0))






अधिक