चलती औसत क्रॉसओवर रणनीति के नौ प्रकार

लेखक:चाओझांग, दिनांकः 2024-01-02 10:37:21
टैगः

img

अवलोकन

यह रणनीति क्रॉसओवर संचालन के लिए प्रवृत्ति की दिशा और खुली / बंद पदों को निर्धारित करने के लिए विभिन्न पैरामीटर सेटिंग्स के साथ दो चलती औसत का उपयोग करती है। यह रणनीति 9 विभिन्न प्रकार के चलती औसतों में से चुनने की अनुमति देती है, जिसमें सरल चलती औसत (एसएमए), घातीय चलती औसत (ईएमए), भारित चलती औसत (डब्ल्यूएमए), अर्नो लेगौक्स चलती औसत (एएलएमए), वॉल्यूम भारित चलती औसत (वीडब्ल्यूएमए), आदि शामिल हैं। यह रणनीति स्टॉप लॉस और लाभ ले ले के स्तरों को भी निर्धारित करती है।

रणनीति तर्क

इस रणनीति का मूल तर्क दो चलती औसत रेखाओं के मूल्यों की तुलना करना और उनके क्रॉसओवर के आधार पर बाजार की प्रवृत्ति दिशा निर्धारित करना है। विशेष रूप से, हम दो चलती औसत का उपयोग करके एक तेज रेखा और एक धीमी रेखा निर्धारित करते हैं। जब तेज रेखा धीमी रेखा के ऊपर पार करती है, तो हम मानते हैं कि बाजार एक ऊपर की प्रवृत्ति में है और लंबा जाता है। जब तेज रेखा धीमी रेखा के नीचे पार करती है, तो हम मानते हैं कि बाजार एक नीचे की प्रवृत्ति में है और छोटा जाता है।

स्थिति में प्रवेश करने के बाद, यदि कीमत स्टॉप लॉस लाइन को छूती है, तो हम नुकसान को काटने के लिए स्थिति से बाहर निकलते हैं। यदि कीमत लाभ लेने की रेखा को छूती है, तो हम लाभ में लॉक करने के लिए स्थिति से बाहर निकलते हैं। यह हमें लाभ में लॉक करने और नुकसान को आगे बढ़ने से रोकने की अनुमति देता है।

कोड तर्क से, रणनीति को चार भागों में विभाजित किया जा सकता हैः

  1. चलती औसत की गणना करें. चलती औसत के प्रकार के उपयोगकर्ता के चयन के आधार पर, तेज रेखा और धीमी रेखा चलती औसत की गणना करें।

  2. ट्रेडिंग सिग्नल उत्पन्न करें. फास्ट लाइन और स्लो लाइन के क्रॉसओवर स्थितियों के आधार पर लंबे और छोटे सिग्नल उत्पन्न करें.

  3. स्टॉप लॉस और ले लाभ स्तर सेट करें. प्रवेश मूल्य और सेट स्टॉप लॉस/ले लाभ प्रतिशत के आधार पर, वास्तविक समय में स्टॉप लॉस और ले लाभ मूल्य स्तरों की गणना करें.

  4. लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्ग/शॉर्ट सिग्नल के आधार पर लॉन्।

लाभ विश्लेषण

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

एक और लाभ यह है कि स्टॉप लॉस और ले लाभ तंत्र सेट किए जाते हैं। यह प्रभावी रूप से आगे के नुकसान को रोक सकता है और मुनाफे में लॉक कर सकता है। कुल मिलाकर, यह रणनीति उच्च अनुकूलन क्षमता के साथ काफी लचीली है, जो विभिन्न जरूरतों वाले उपयोगकर्ताओं के लिए उपयुक्त है।

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

इस रणनीति का मुख्य जोखिम यह है कि चलती औसत में पिछड़ती है। जब कीमतें अचानक हिंसक रूप से उतार-चढ़ाव करती हैं, तो चलती औसत समय पर प्रतिक्रिया नहीं दे सकती हैं, जिससे सबसे अच्छा प्रवेश या निकास समय चूक सकता है। इससे बड़े नुकसान हो सकते हैं।

एक और जोखिम स्टॉप लॉस और ले लाभ स्तरों की स्थापना है। यदि सीमा बहुत छोटी है, तो यह स्केलपर्स के लिए कमजोर हो सकती है। यदि बहुत बड़ी है, तो समय पर लाभ को लॉक करने में विफल होना आसान है। इसलिए, स्टॉप लॉस / ले लाभ मापदंडों को लाइव ट्रेडिंग के दौरान बाजार की स्थिति के अनुसार अनुकूलित करने की आवश्यकता है।

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

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

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

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

  2. चलती औसत मापदंडों को अनुकूलित करें. चलती औसत की लंबाई को समायोजित करें ताकि यह बाजार की विशेषताओं के साथ बेहतर फिट हो सके.

  3. फ़िल्टरिंग के लिए अन्य संकेतक जोड़ें। जब कोई स्पष्ट प्रवृत्ति नहीं होती है तो लगातार व्यापार से बचने के लिए एमएसीडी, आरएसआई और अन्य संकेतक जोड़े जा सकते हैं।

  4. स्टॉप लॉस/टेक प्रॉफिट रेशियो का अनुकूलन करें। ऐतिहासिक डेटा के आधार पर इष्टतम स्टॉप लॉस/टेक प्रॉफिट पैरामीटर की गणना करें।

  5. मशीन लर्निंग मॉडल जोड़ें. मूल्य आंदोलनों की भविष्यवाणी करने और ट्रेडिंग संकेत उत्पन्न करने में सहायता के लिए LSTM, यादृच्छिक वन एल्गोरिदम का उपयोग करें.

  6. ट्रेलिंग स्टॉप लॉस एल्गोरिदम को अपनाएं। हिट होने की संभावना को कम करने के लिए स्टॉप लॉस लाइन को मूल्य आंदोलनों के साथ धीरे-धीरे आगे बढ़ने के लिए सक्षम करें।

निष्कर्ष

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


/*backtest
start: 2022-12-26 00:00:00
end: 2024-01-01 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=3
strategy("Kozlod - Yet Another Moving Average Cross Strategy", shorttitle="kozlod_yamacs", overlay = true)

// 
// author: Kozlod
// date: 2018-03-06
// 

////////////
// INPUTS //
////////////

ma_type      = input(title = "MA Type",          defval = "SMA", options = ['SMA', 'EMA', 'WMA', 'ALMA', 'VWMA', 'HMA', 'LSMA', 'SMMA', 'DEMA'])
short_ma_len = input(title = "Short MA Length",  defval = 5,     minval = 1)
short_ma_src = input(title = "Short MA Source",   defval = close)
long_ma_len  = input(title = "Long MA Length",   defval = 15,    minval = 2)
long_ma_src  = input(title = "Long MA Source",    defval = close)
alma_offset  = input(title = "ALMA Offset",     type = float,   defval = 0.85,  step = 0.01, minval = 0, maxval = 1)
alma_sigma   = input(title = "ALMA Sigma",      type = float,   defval = 6,     step = 0.01)
lsma_offset  = input(title = "LSMA Offset",      defval = 0,     step = 1)

sl_lev_perc  = input(title = "SL Level % (0 - Off)", type = float,   defval = 0,  minval = 0, step = 0.01)
pt_lev_perc  = input(title = "PT Level % (0 - Off)", type = float,   defval = 0,  minval = 0, step = 0.01)

// Set initial values to 0
short_ma = 0.0
long_ma  = 0.0

// Simple Moving Average (SMA)
if ma_type == 'SMA' 
    short_ma := sma(short_ma_src, short_ma_len)
    long_ma  := sma(long_ma_src,  long_ma_len)

// Exponential Moving Average (EMA)
if ma_type == 'EMA'
    short_ma := ema(short_ma_src, short_ma_len)
    long_ma  := ema(long_ma_src,  long_ma_len)

// Weighted Moving Average (WMA)
if ma_type == 'WMA'
    short_ma := wma(short_ma_src, short_ma_len)
    long_ma  := wma(long_ma_src,  long_ma_len)

// Arnaud Legoux Moving Average (ALMA)
if ma_type == 'ALMA'
    short_ma := alma(short_ma_src, short_ma_len,  alma_offset, alma_sigma)
    long_ma  := alma(long_ma_src,  long_ma_len,   alma_offset, alma_sigma)

// Hull Moving Average (HMA)
if ma_type == 'HMA'
    short_ma := wma(2*wma(short_ma_src, short_ma_len/2)-wma(short_ma_src, short_ma_len), round(sqrt(short_ma_len)))
    long_ma  := wma(2*wma(long_ma_src,  long_ma_len /2)-wma(long_ma_src,  long_ma_len),  round(sqrt(long_ma_len)))

// Volume-weighted Moving Average (VWMA)
if ma_type == 'VWMA'
    short_ma := vwma(short_ma_src, short_ma_len)
    long_ma  := vwma(long_ma_src,  long_ma_len)

// Least Square Moving Average (LSMA)
if ma_type == 'LSMA'
    short_ma := linreg(short_ma_src, short_ma_len, lsma_offset)
    long_ma  := linreg(long_ma_src,  long_ma_len,  lsma_offset)

// Smoothed Moving Average (SMMA)    
if ma_type == 'SMMA'
    short_ma := na(short_ma[1]) ? sma(short_ma_src, short_ma_len) : (short_ma[1] * (short_ma_len - 1) + short_ma_src) / short_ma_len
    long_ma  := na(long_ma[1])  ? sma(long_ma_src,  long_ma_len)  : (long_ma[1]  * (long_ma_len  - 1) + long_ma_src)  / long_ma_len

// Double Exponential Moving Average (DEMA)
if ma_type == 'DEMA'
    e1_short = ema(short_ma_src, short_ma_len)
    e1_long  = ema(long_ma_src,  long_ma_len)
    
    short_ma := 2 * e1_short - ema(e1_short, short_ma_len)
    long_ma  := 2 * e1_long  - ema(e1_long,  long_ma_len)

/////////////
// SIGNALS //
/////////////

long_signal  = crossover( short_ma, long_ma)
short_signal = crossunder(short_ma, long_ma)

// Calculate PT/SL levels 
// Initial values 
last_signal    = 0
prev_tr_price  = 0.0
pt_level       = 0.0
sl_level       = 0.0

// Calculate previous trade price
prev_tr_price := long_signal[1] or short_signal[1] ? open : nz(last_signal[1]) != 0 ? prev_tr_price[1] : na

// Calculate SL/PT levels 
pt_level := nz(last_signal[1]) == 1 ? prev_tr_price * (1 + pt_lev_perc / 100) : nz(last_signal[1]) == -1 ? prev_tr_price * (1 - pt_lev_perc / 100)  : na
sl_level := nz(last_signal[1]) == 1 ? prev_tr_price * (1 - sl_lev_perc / 100) : nz(last_signal[1]) == -1 ? prev_tr_price * (1 + sl_lev_perc / 100)  : na

// Calculate if price hit sl/pt 
long_hit_pt = pt_lev_perc > 0 and nz(last_signal[1]) ==  1 and close >= pt_level
long_hit_sl = sl_lev_perc > 0 and nz(last_signal[1]) ==  1 and close <= sl_level

short_hit_pt = pt_lev_perc > 0 and nz(last_signal[1]) ==  -1 and close <= pt_level
short_hit_sl = sl_lev_perc > 0 and nz(last_signal[1]) ==  -1 and close >= sl_level

// What is last active trade? 
last_signal := long_signal ? 1 : short_signal ? -1 : long_hit_pt or long_hit_sl or short_hit_pt or short_hit_sl ? 0 : nz(last_signal[1])

//////////////
// PLOTTING //
//////////////

// Plot MAs
plot(short_ma, color = red,   linewidth = 2)
plot(long_ma,  color = green, linewidth = 2)


// Plot Levels 
plotshape(prev_tr_price, style = shape.cross, color = gray, location  = location.absolute, size = size.small)


plotshape(sl_lev_perc > 0 ? sl_level : na, style = shape.cross, color = red,   location  = location.absolute, size = size.small)
plotshape(pt_lev_perc > 0 ? pt_level : na, style = shape.cross, color = green, location  = location.absolute, size = size.small)

//////////////
// STRATEGY //
//////////////

strategy.entry("long",  true,  when = long_signal)
strategy.entry("short", false, when = short_signal)

strategy.close("long",  when = long_hit_pt  or long_hit_sl)
strategy.close("short", when = short_hit_pt or short_hit_sl)

अधिक