अनुकूली एटीआर स्टॉप लॉस पर आधारित एमएसीडी ट्रेडिंग रणनीति


निर्माण तिथि: 2023-09-20 15:23:00 अंत में संशोधित करें: 2023-09-20 15:23:00
कॉपी: 1 क्लिक्स: 870
1
ध्यान केंद्रित करना
1621
समर्थक

अवलोकन

यह रणनीति MACD संकेतकों का उपयोग करके ट्रेडिंग सिग्नल उत्पन्न करती है और एटीआर-आधारित अनुकूली स्टॉप-लॉस का उपयोग करके जोखिम को नियंत्रित करती है।

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

  1. एमएसीडी सूचकांक का विचलन मूल्य डेल्ट ब्रेकडाउन 0 अक्ष को तोड़ने से खरीद और बेचने के संकेत मिलते हैं।

  2. गतिशील स्टॉप-लॉस की गणना एटीआर के आधार पर की जाती है, जो हाल के एन चक्रों के लिए है। एटीआर बाजार में उतार-चढ़ाव को दर्शाता है।

  3. स्टॉप लॉस का स्तर उतार-चढ़ाव के साथ समायोजित होता है, और उतार-चढ़ाव बढ़ने पर स्टॉप लॉस को कम किया जाता है।

  4. लाभ को लॉक करने और जोखिम को नियंत्रित करने के लिए सिग्नल रखने के दौरान वास्तविक समय में स्टॉपलॉस अपडेट करें।

  5. जब स्टॉप लॉस ट्रिगर होता है, तो स्थिति से बाहर निकलें और जोखिम नियंत्रण पूरा करें।

श्रेष्ठता विश्लेषण

  1. MACD सूचकांक ट्रेंड को ट्रैक करने के लिए अधिक संवेदनशील है।

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

  3. दृश्यमान स्टॉप लॉस रेखांकन, जो जोखिम की स्थिति को दर्शाता है

  4. इस नीति के नियम सरल, स्पष्ट और समझने में आसान हैं।

  5. वापस लेने पर नियंत्रण है, जोखिम प्रबंधन अच्छा है

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

  1. MACD सूचकांक में गलत संकेत हो सकते हैं जिससे अनावश्यक नुकसान हो सकता है।

  2. एटीआर पैरामीटर को गलत तरीके से सेट किया गया है, जो बहुत दूर है या बहुत दूर है।

  3. इस प्रकार, एक बार जब आप अपने डिवाइस को बंद कर देते हैं, तो यह आपके डिवाइस को बंद कर देता है।

  4. इस प्रकार, यह एक बहुत ही कठिन समय है जब रुझान बदलता है और जब रुझान रुक जाता है।

  5. पैरामीटर के अनुकूलन में अति-अनुरूपता का खतरा हो सकता है।

अनुकूलन दिशा

  1. विभिन्न मापदंडों के MACD के संयोजनों का परीक्षण करें और इष्टतम मापदंड खोजें।

  2. अन्य रोकथाम विधियों का प्रयास करें, जैसे कि रोकथाम का पता लगाना।

  3. स्टॉप लॉस पैरामीटर को अनुकूलित करें, स्टॉप लॉस आवृत्ति और जोखिम नियंत्रण को संतुलित करें।

  4. एक ट्रेंड डिसाइडर जोड़े जाने से रिवर्स स्टॉप लॉस से बचा जा सकता है।

  5. लेनदेन की लागत के प्रभाव को ध्यान में रखते हुए, अत्यधिक लेनदेन को रोकें।

  6. स्लाइड प्वाइंट या बढ़े हुए स्टॉप लॉस का उपयोग करें ताकि स्टॉप लॉस प्रभावी हो सके।

संक्षेप

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

रणनीति स्रोत कोड
/*backtest
start: 2023-01-01 00:00:00
end: 2023-02-14 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("MACD BF 🚀", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.0)

/////////////// Time Frame ///////////////
testStartYear = input(2017, "Backtest Start Year") 
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)

testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)

testPeriod() =>  true

///////////////  MACD  /////////////// 
fastLength = input(13) 
slowlength = input(30) 
MACDLength = input(12) 

MACD = ema(close, fastLength) - ema(close, slowlength)
aMACD = ema(MACD, MACDLength)
delta = MACD - aMACD

///////////////  Strategy  /////////////// 
long = crossover(delta, 0)
short = crossunder(delta, 0)

last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])

long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)

last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])

last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])

in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal

last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])

since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1]) 
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1]) 

/////////////// Dynamic ATR Stop Losses ///////////////
atrLkb = input(2, minval=1, title='ATR Stop Period')
atrMult = input(1.25, step=0.25, title='ATR Stop Multiplier') 
atr1 = atr(atrLkb)

longStop = 0.0
longStop :=  short_signal ? na : long_signal ? close - (atr1 * atrMult) : longStop[1]
shortStop = 0.0
shortStop := long_signal ? na : short_signal ? close + (atr1 * atrMult) : shortStop[1]

/////////////// Execution /////////////// 
if testPeriod()
    strategy.entry("Long", strategy.long, when=long)
    strategy.entry("Short", strategy.short, when=short)
    strategy.exit("Long SL", "Long", stop=longStop, when=since_longEntry > 0)
    strategy.exit("Short SL", "Short", stop=shortStop, when=since_shortEntry > 0)

/////////////// Plotting /////////////// 
barcolor(long ? color.lime : short ? color.red : na)
plot(strategy.position_size <= 0 ? na : longStop, title="Long Stop Loss", color=color.yellow, style=plot.style_circles, linewidth=2)
plot(strategy.position_size >= 0 ? na : shortStop, title="Short Stop Loss", color=color.orange, style=plot.style_circles, linewidth=2)
bgcolor(strategy.position_size > 0 ? color.lime : strategy.position_size < 0 ? color.red : color.white, transp=90)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=60)