माध्य प्रत्यावर्तन गति रणनीति


निर्माण तिथि: 2023-11-15 17:40:59 अंत में संशोधित करें: 2023-11-15 17:40:59
कॉपी: 0 क्लिक्स: 833
1
ध्यान केंद्रित करना
1617
समर्थक

माध्य प्रत्यावर्तन गति रणनीति

अवलोकन

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

रणनीति सिद्धांत

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

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

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

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

Exit मोड को चुनने के लिए एक चलती औसत या एक रैखिक पुनरावृत्ति को तोड़ने के लिए चुना जा सकता है।

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

रणनीतिक लाभ

  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))