कैंडलस्टिक पैटर्न पर आधारित मोमेंटम ब्रेकआउट ट्रेडिंग रणनीति


निर्माण तिथि: 2023-11-28 10:33:31 अंत में संशोधित करें: 2023-11-28 10:33:31
कॉपी: 0 क्लिक्स: 383
1
ध्यान केंद्रित करना
1237
समर्थक

कैंडलस्टिक पैटर्न पर आधारित मोमेंटम ब्रेकआउट ट्रेडिंग रणनीति

इस लेख में एक गतिशील ब्रेकआउट ट्रेडिंग रणनीति के बारे में बताया गया है, जो कि K-लाइन पैटर्न पर आधारित है। यह रणनीति बाजार की प्रवृत्ति और प्रवेश के समय को पहचानने के लिए स्टैम्प पैटर्न की पहचान करती है।

रणनीति अवलोकन

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

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

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

बहु-सिरों के सेवन का अर्थ है कि दिन के समापन की कीमत खुली कीमत से अधिक है, और पिछले K लाइन की समापन की कीमत पिछली K लाइन की खुली कीमत से कम है। यह आकृति आमतौर पर बाजार की भावना में बदलाव का संकेत देती है, बहु-अवकाश मनोविज्ञान में उलटफेर होता है, इसलिए यह उचित अनुवर्ती के लिए एक अच्छा समय है।

खाली सिर के सेवन के विपरीत, यह उस दिन के समापन की कीमत को खोलने की कीमत से कम करता है, और ऊपर की K लाइन की समापन कीमत ऊपर की K लाइन की कीमत से अधिक है। यह भी बाजार की भावना में बदलाव का संकेत देता है, और इसलिए खाली सिर के हस्तक्षेप का अवसर है।

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

रणनीतिक लाभ

  1. बाजार में बदलाव के समय का त्वरित आकलन करें और संभावित अवसरों को पकड़ें
  2. जोखिम-लाभ मिलान, उचित स्टॉप-लॉस सेटिंग
  3. विभिन्न जोखिम वरीयताओं को पूरा करने के लिए लीवरेज समायोज्य है
  4. पूरी तरह से स्वचालित लेनदेन, अधिक कुशल

रणनीतिक जोखिम

  1. यह केवल संदर्भ के लिए है और पूरी तरह से निश्चित नहीं है कि यह उलटा होगा
  2. रिवर्स विफलता की संभावना है, एक संकीर्ण झटका हो सकता है
  3. लीवरेज बहुत अधिक होने से स्थिति खराब हो सकती है
  4. पर्याप्त धन की आवश्यकता उचित स्थिति का समर्थन करने के लिए

जोखिमों के लिए अनुकूलन निम्नलिखित तरीकों से किया जा सकता हैः

  1. फ़िल्टर सिग्नल के साथ अन्य संकेतक
  2. लीवरेज को उचित रूप से समायोजित करना
  3. भंडारण के लिए कदम बढ़ाएं, लागत-औसत मूल्य को अलग-अलग करें
  4. स्टॉप-लॉस रणनीति को अनुकूलित करें और लाभ सुनिश्चित करें

रणनीति अनुकूलन

गतिशीलता को निम्नलिखित आयामों से अनुकूलित किया जा सकता हैः

  1. मल्टी फैक्टर सत्यापन संकेत विश्वसनीयता संकेतों की विश्वसनीयता सुनिश्चित करने के लिए, औसत रेखा, उतार-चढ़ाव और अन्य संकेतों को सत्यापित करने के लिए जोड़ा जा सकता है।

  2. भावनात्मक संकेतक के साथ बाजार मनोविज्ञान का आकलन करें बाजार के आतंक सूचकांक, लालच सूचकांक और अन्य भावनात्मक आकलन सूचकांकों के संयोजन के साथ, यह अधिक सटीक रूप से निर्धारित किया जा सकता है कि बाजार कब पलट सकता है।

  3. स्टॉप लॉस रणनीति को अनुकूलित करें लाभ को लॉक करने के लिए, और निकासी के जोखिम को कम करने के लिए, मोबाइल स्टॉप, क्रमिक स्टॉप और मोबाइल स्टॉप का उपयोग किया जा सकता है।

  4. एल्गोरिथम ट्रेडिंग ट्रेडिंग सिग्नल को समझने में मदद करने के लिए मशीन लर्निंग और अन्य एल्गोरिथम मॉडल का उपयोग करें, जिससे रणनीति को स्वचालित किया जा सके।

संक्षेप

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

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

//@version=5
strategy(title = "MomGulfing", shorttitle = "MomGulfing", overlay = true, initial_capital=10000, pyramiding=3, calc_on_order_fills=false, calc_on_every_tick=false, currency="USD", default_qty_type=strategy.cash, default_qty_value=1000, commission_type=strategy.commission.percent, commission_value=0.04)

syear = input(2021)
smonth = input(1)
sday = input(1)
fyear = input(2022)
fmonth = input(12)
fday = input(31)
start = timestamp(syear, smonth, sday, 01, 00)
finish = timestamp(fyear, fmonth, fday, 23, 59)
date = time >= start and time <= finish ? true : false

longs = input(true)
shorts = input(true)
rr = input(2.5)
position_risk_percent = input(1)/100
signal_bar_check = input.string(defval="3", options=["1", "2", "3"])
margin_req = input(80)
sl_increase_factor = input(0.2)
tp_decrease_factor = input(0.0)
check_for_volume = input(true)
var long_sl = 0.0
var long_tp = 0.0
var short_sl = 0.0
var short_tp = 0.0
var long_lev = 0.0
var short_lev = 0.0

initial_capital = strategy.equity
position_risk = initial_capital * position_risk_percent

bullishEngulfing_st = close[1] < open[1] and close > open and high[1] < close and (check_for_volume ? volume[1]<volume : true)
bullishEngulfing_nd = close[2] < open[2] and close[1] > open[1] and close > open and high[2] > close[1] and high[2] < close and (check_for_volume ? volume[2]<volume : true)
bullishEngulfing_rd = close[3] < open[3] and close[2] > open[2] and close[1] > open[1] and close > open and high[3] > close[2] and high[3] > close[1] and high[3] < close and (check_for_volume ? volume[3]<volume : true)
bullishEngulfing = signal_bar_check == "1" ? bullishEngulfing_st : signal_bar_check == "2" ? bullishEngulfing_st or bullishEngulfing_nd : bullishEngulfing_st or bullishEngulfing_nd or bullishEngulfing_rd
long_stop_level = bullishEngulfing_st ? math.min(low[1], low) : bullishEngulfing_nd ? math.min(low[2], low[1], low) : bullishEngulfing_rd ? math.min(low[3], low[2], low[1], low) : na
rr_amount_long = close-long_stop_level
long_exit_level = close + rr*rr_amount_long
long_leverage = math.floor(margin_req/math.floor((rr_amount_long/close)*100))

bearishEngulfing_st = close[1] > open[1] and close < open and low[1] > close and (check_for_volume ? volume[1]<volume : true)
bearishEngulfing_nd = close[2] > open[2] and close[1] < open[1] and close < open and low[2] < close[1] and low[2] > close and (check_for_volume ? volume[2]<volume : true)
bearishEngulfing_rd = close[3] > open[3] and close[2] < open[2] and close[1] < open[1] and close < open and low[3] < close[2] and low[3] < close[1] and low[3] > close and (check_for_volume ? volume[3]<volume : true)
bearishEngulfing = signal_bar_check == "1" ? bearishEngulfing_st : signal_bar_check == "2" ? bearishEngulfing_st or bearishEngulfing_nd : bearishEngulfing_st or bearishEngulfing_nd or bearishEngulfing_rd
short_stop_level = bearishEngulfing_st ? math.max(high[1], high) : bearishEngulfing_nd ? math.max(high[2], high[1], high) : bearishEngulfing_rd ? math.max(high[3], high[2], high[1], high) : na
rr_amount_short = short_stop_level-close
short_exit_level = close - rr*rr_amount_short
short_leverage = math.floor(margin_req/math.floor((rr_amount_short/short_stop_level)*100))

long = longs and date and bullishEngulfing
short = shorts and date and bearishEngulfing
bgcolor(long[1] ? color.new(color.teal, 80) : (short[1] ? color.new(color.purple, 80) : na))

if long and strategy.position_size <= 0
    long_lev := long_leverage

if short and strategy.position_size >= 0
    short_lev := short_leverage

long_pos_size = long_lev * position_risk
long_pos_qty = long_pos_size/close
short_pos_size = short_lev * position_risk
short_pos_qty = short_pos_size/close

if long
    if strategy.position_size <= 0
        long_sl := long_stop_level
        long_tp := long_exit_level

    else if strategy.position_size > 0
        long_sl := long_stop_level + sl_increase_factor*rr_amount_long
        long_tp := long_exit_level - tp_decrease_factor*rr_amount_long

    strategy.entry("L"+str.tostring(long_lev)+"X", strategy.long, qty=long_pos_qty)
    label_text = str.tostring(long_lev)+"X\nSL:"+str.tostring(long_sl)+"\nTP:"+str.tostring(long_tp)
    label.new(bar_index+1, na, text=label_text, color=color.green, style=label.style_label_up, xloc=xloc.bar_index, yloc=yloc.belowbar)

else if short
    if strategy.position_size >= 0
        short_sl := short_stop_level
        short_tp := short_exit_level

    else if strategy.position_size < 0
        short_sl := short_stop_level - sl_increase_factor*rr_amount_short
        short_tp := short_exit_level + tp_decrease_factor*rr_amount_short

    strategy.entry("S"+str.tostring(short_lev)+"X", strategy.short, qty=short_pos_qty)
    label_text = str.tostring(short_lev)+"X\nSL:"+str.tostring(short_sl)+"\nTP:"+str.tostring(short_tp)
    label.new(bar_index+1, na, text=label_text, color=color.red, style=label.style_label_down, xloc=xloc.bar_index, yloc=yloc.abovebar)

if (strategy.position_size > 0)
    strategy.exit(id="L TP/SL", stop=long_sl, limit=long_tp)

if (strategy.position_size < 0)
    strategy.exit(id="S TP/SL", stop=short_sl, limit=short_tp)

sl_level = strategy.position_size > 0 ? long_sl : strategy.position_size < 0 ? short_sl : na
plot(sl_level, color=color.red, style=plot.style_linebr)

tp_level = strategy.position_size > 0 ? long_tp : strategy.position_size < 0 ? short_tp : na
plot(tp_level, color=color.green, style=plot.style_linebr)