संसाधन लोड हो रहा है... लोड करना...
  1. वर्ग
  2. गति ब्रेकआउट रणनीति

गति ब्रेकआउट रणनीति

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

img

अवलोकन

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

रणनीति तर्क

इस रणनीति का मूल गति संकेतक पर आधारित है। गति संकेतक वर्तमान अवधि के समापन मूल्य को घटाकर N अवधि पहले के समापन मूल्य है। जब नवीनतम बार बंद N अवधि पहले की तुलना में अधिक होता है, तो गति सकारात्मक होती है, जो एक ऊपर की प्रवृत्ति को इंगित करती है; जब नवीनतम बार बंद N अवधि पहले की तुलना में कम होता है, तो गति नकारात्मक होती है, जो एक नीचे की प्रवृत्ति को इंगित करती है।

रणनीति पहले 18 अवधि गति की गणना करती है, जो वर्तमान बंद घटाकर 18 अवधि पहले बंद है, mom0 में संग्रहीत है। फिर यह mom0 के 1-अवधि गति की गणना करता है, mom1 में संग्रहीत है।

जब mom0>0 और mom1>0, एक लंबा संकेत उत्पन्न होता है, जो एक मजबूत ऊपर की ओर गति को दर्शाता है। जब mom0<0 और mom1<0, एक छोटा संकेत उत्पन्न होता है, जो एक मजबूत नीचे की ओर गति को दर्शाता है।

रणनीति सबसे हाल के लंबे और छोटे संकेतों के समय को रिकॉर्ड करती है। जब लंबा संकेत समय कम संकेत समय से अधिक हालिया होता है, तो यह एक लंबी स्थिति रखता है। जब छोटा संकेत समय लंबे संकेत समय से अधिक हालिया होता है, तो यह एक छोटी स्थिति रखता है।

लाभ विश्लेषण

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

  1. तर्क सरल और समझने में आसान है, जो मात्रात्मक व्यापार में शुरुआती लोगों के लिए उपयुक्त है।

  2. गति संकेतक मध्यम से दीर्घकालिक रुझानों को ट्रैक करते समय अपेक्षाकृत उच्च जीत दरों के साथ बाजार के रुझानों और ताकत को पकड़ सकते हैं।

  3. दोहरी गति फ़िल्टर झूठे ब्रेकआउट से नुकसान से बचने में मदद करता है।

  4. यह ट्रेंडिंग बाजारों के दौरान रुझान स्थितियों को स्थापित करने और अतिरिक्त रिटर्न प्राप्त करने के लिए संकेत के बाद पद जोड़ता है।

  5. समय पर स्टॉप लॉस एक्जिट से एकल ट्रेड के नुकसान का आकार नियंत्रित होता है और रिवर्स से बड़े नुकसान से बचा जाता है।

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

इस रणनीति के कुछ जोखिमों पर ध्यान दें:

  1. अपट्रेंड में अल्पकालिक पॉलबैक के दौरान स्टॉप लॉस एक्जिट, पूरे ट्रेंड को कैप्चर करने में असमर्थ। स्टॉप लॉस रेंज को चौड़ा करने पर विचार कर सकते हैं।

  2. विभिन्न बाजारों में लगातार खुले और बंद होने वाले ट्रेडों से कमीशन और स्लिपज की लागत बढ़ जाती है। ट्रेड आवृत्ति को कम करने के लिए फिल्टर ढीले करने पर विचार किया जा सकता है।

  3. रुझान उलटने के बाद मूल दिशा में होल्डिंग जारी रखने से घाटे बढ़ते हैं। रुझान बदलने का पता लगाने के लिए रुझान संकेतकों को शामिल कर सकते हैं।

  4. गलत पैरामीटर सेटिंग्स से सिग्नल गायब हो जाते हैं या गलत सिग्नल उत्पन्न होते हैं। विभिन्न बाजारों के लिए पैरामीटर को समायोजित करने की आवश्यकता होती है।

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

रणनीति को अनुकूलित करने के कुछ तरीकेः

  1. समय सीमा और बाजार के आधार पर गति लंबाई गणना को समायोजित करके गति मापदंडों को अनुकूलित करें। संकेत की गुणवत्ता में सुधार करें।

  2. रुझान उलटने से नुकसान से बचने के लिए एमएसीडी, केडी जैसे अन्य सूचक फिल्टर जोड़ें।

  3. रुझानों में रुझानों को चौड़ा करके और गैर-रुझान बाजारों में रुझानों को कसकर स्टॉप लॉस रणनीति का अनुकूलन करना।

  4. अधिक लाभ प्राप्त करने के लिए नॉन-ट्रेंड्स में आकार कम करने और ट्रेंड्स में आकार बढ़ाने के लिए स्थिति आकार नियम जोड़ें।

  5. अनुकूलन क्षमता में सुधार के लिए विभिन्न उत्पादों के लिए अलग-अलग मापदंडों का अनुकूलन करें।

  6. गतिशील रूप से मापदंडों का अनुकूलन करने के लिए मशीन लर्निंग एल्गोरिदम शामिल करें।

निष्कर्ष

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

/*backtest
start: 2023-10-15 00:00:00
end: 2023-11-14 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

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

/////////////// Time Frame ///////////////
_0 = input(false,  "════════ Test Period ═══════")
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

///////////// Momentum /////////////
_1 = input(false, "═══════ Momentum ══════")
length = input(18)
price = close

momentum(seria, length) =>
    mom = seria - seria[length]
    mom

mom0 = momentum(price, length)
mom1 = momentum(mom0, 1)

/////////////// Strategy /////////////// 
long = mom0 > 0 and mom1 > 0
short = mom0 < 0 and mom1 < 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]) 

/////////////// Stop Losses Long ///////////////
_5 = input(false,  "═══════ Stop Loss L ══════")
SL_typel = input("Fixed", options=["Fixed", "ATR Derived"], title="Stop Loss Type")
sl_inpl = input(8.0, title='Fixed Stop Loss %') / 100
atrLkbl = input(20, minval=1, title='ATR Stop Period')
atrMultl = input(1.5, step=0.25, title='ATR Stop Multiplier') 
atr1l = atr(atrLkbl)

longStop1l = 0.0
longStop1l := short_signal ? na : long_signal ? close - (atr1l * atrMultl) : longStop1l[1]

slLongl = in_long_signal ? strategy.position_avg_price * (1 - sl_inpl) : na
long_sll = in_long_signal ? slLongl : na

/////////////// Stop Losses Short ///////////////
_6 = input(false, "═══════ Stop Loss S ══════")
SL_types = input("Fixed", options=["Fixed", "ATR Derived"], title="Stop Loss Type")
sl_inps = input(7.0, title='Fixed Stop Loss %') / 100
atrLkbs = input(20, minval=1, title='ATR Stop Period')
atrMults = input(1.5, step=0.25, title='ATR Stop Multiplier') 
atr1s = atr(atrLkbs)

shortStop1s = 0.0
shortStop1s := long_signal ? na : short_signal ? close + (atr1s * atrMults) : shortStop1s[1]

slShorts = strategy.position_avg_price * (1 + sl_inps)
short_sls = in_short_signal ? slShorts : na

_7 = input(false, "══════ Longs or Shorts ═════")
useLongs = input(true, title="Use Longs")
useShorts = input(true, title="Use Shorts")

/////////////// Execution ///////////////
if testPeriod()
    if useLongs
        strategy.entry("L", strategy.long, when=long)
        strategy.exit("L SL", "L", stop = SL_typel == "Fixed" ? long_sll : longStop1l, when=since_longEntry > 0)
    if useShorts
        strategy.exit("S SL", "S", stop = SL_types == "Fixed" ? short_sls : shortStop1s, when=since_shortEntry > 0)
        strategy.entry("S", strategy.short, when=short)
    if not useShorts
        strategy.close("L", when=short)
    if not useLongs
        strategy.close("S", when=long)

/////////////// Plotting /////////////// 
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=40)
p0 = plot(close)
p1 = plot(strategy.position_size <= 0 ? na : SL_typel == "Fixed" ? long_sll : longStop1l, title="Long Stop Loss", color=color.yellow, style=plot.style_linebr, linewidth=2)
p2 = plot(strategy.position_size >= 0 ? na : SL_types == "Fixed" ? short_sls : shortStop1s, title="Short Stop Loss", color=color.orange, style=plot.style_linebr, linewidth=2)
p3 = plot(strategy.position_size <= 0 ? na : strategy.position_avg_price, style=plot.style_linebr, title="Long Entry", color=color.green, linewidth=2)
p4 = plot(strategy.position_size >= 0 ? na : strategy.position_avg_price, style=plot.style_linebr, title="Short Entry", color=color.red, linewidth=2)
fill(p0, p3, color = color.lime, transp=60)
fill(p0, p4, color = color.red, transp=60)
अधिक

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