त्रिकोणीय चलती औसत क्रॉसओवर ट्रेडिंग रणनीति

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

img

अवलोकन

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

रणनीति तर्क

टीएमए रणनीति मुख्य रूप से प्रवृत्ति की दिशा निर्धारित करने के लिए तीन चलती औसत रेखाओं पर निर्भर करती है। अल्पकालिक चलती औसत मूल्य परिवर्तनों के प्रति संवेदनशील रूप से प्रतिक्रिया करती है; मध्यमकालिक चलती औसत प्रवृत्ति का स्पष्ट न्याय प्रदान करती है; दीर्घकालिक चलती औसत बाजार शोर को फ़िल्टर करती है और दीर्घकालिक प्रवृत्ति की दिशा निर्धारित करती है।

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

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

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

लाभ विश्लेषण

  • न्याय की सटीकता में सुधार के लिए तीन चलती औसत का उपयोग करें
  • व्यापार जोखिम के अनुसार प्रभावी ढंग से नियंत्रण करने के लिए स्टॉप-लॉस और ले-प्रॉफिट सेट करें
  • विभिन्न उत्पादों के लिए उपयुक्त अनुकूलन योग्य चलती औसत पैरामीटर
  • चलती औसत प्रकारों, विविध रणनीति प्रकारों के लिए सात विकल्प

जोखिम विश्लेषण और समाधान

  • जब तीन एमए समेकित हो रहे हों तो गलत संकेत

    समाधानः गलत संकेतों से बचने के लिए एमए पैरामीटर को ठीक से समायोजित करें

  • अत्यधिक आक्रामक स्टॉप-लॉस/टेक-प्रॉफिट प्रतिशत

    समाधानः सूक्ष्म-संरेखण प्रतिशत; बहुत बड़ा या बहुत छोटा नहीं हो सकता

  • गलत पैरामीटर सेटिंग्स से बहुत अधिक या बहुत कम ट्रेड होते हैं

    समाधानः इष्टतम खोजने के लिए विभिन्न पैरामीटर संयोजनों का परीक्षण करें

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

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

  • इष्टतम खोजने के लिए विभिन्न प्रकार और लंबाई संयोजनों का परीक्षण करें

    सर्वोत्तम परिणामों के लिए विभिन्न एमए लंबाई या प्रकार के संयोजनों का परीक्षण करें

  • सिग्नल फ़िल्टर के रूप में अन्य तकनीकी संकेतक जोड़ें

    बहु-कारक सत्यापन के लिए केडीजे, एमएसीडी आदि जैसे संकेतक जोड़ें

  • उत्पाद की विशेषताओं के आधार पर मापदंडों का चयन करें

    अस्थिर उत्पादों के लिए एमए अवधि को छोटा करना; स्थिर उत्पादों के लिए अवधि को लंबा करना

  • इष्टतम मापदंडों को खोजने के लिए मशीन लर्निंग का उपयोग करें

    ऑटो पैरामीटर तेजी से इष्टतम का पता लगाने के लिए sweeping

निष्कर्ष

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


/*backtest
start: 2024-01-08 00:00:00
end: 2024-01-15 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=3
strategy("Kozlod - 3 MA strategy with SL/PT", shorttitle="kozlod_3ma", overlay = true, default_qty_type = strategy.percent_of_equity, default_qty_value = 5)

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

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

ma_type        = input(title = "MA Type",            defval = "SMA", options = ['SMA', 'EMA', 'WMA', 'VWMA', 'HMA', 'SMMA', 'DEMA'])
short_ma_len   = input(title = "Short MA Length",    defval = 5,     minval = 1)
short_ma_src   = input(title = "Short MA Source",    defval = close)
medium_ma_len  = input(title = "Medium MA Length",   defval = 20,    minval = 2)
medium_ma_src  = input(title = "Medium MA Source",   defval = close)
long_ma_len    = input(title = "Long MA Length",     defval = 100,   minval = 3)
long_ma_src    = input(title = "Long MA Source",     defval = close)

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
medium_ma = 0.0

// Simple Moving Average (SMA)
if ma_type == 'SMA' 
    short_ma  := sma(short_ma_src,  short_ma_len)
    medium_ma := sma(medium_ma_src, medium_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)
    medium_ma := ema(medium_ma_src, medium_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)
    medium_ma := wma(medium_ma_src, medium_ma_len)
    long_ma   := wma(long_ma_src,   long_ma_len)

// 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)))
    medium_ma := wma(2*wma(medium_ma_src, medium_ma_len / 2) - wma(medium_ma_src, medium_ma_len), round(sqrt(medium_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)
    medium_ma := vwma(medium_ma_src, medium_ma_len)
    long_ma   := vwma(long_ma_src,   long_ma_len)

// 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
    medium_ma := na(medium_ma[1]) ? sma(medium_ma_src, medium_ma_len) : (medium_ma[1] * (medium_ma_len - 1) + medium_ma_src) / medium_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_medium = ema(medium_ma_src, medium_ma_len)
    e1_long   = ema(long_ma_src,   long_ma_len)
    
    short_ma  := 2 * e1_short  - ema(e1_short,  short_ma_len)
    medium_ma := 2 * e1_medium - ema(e1_medium, medium_ma_len)
    long_ma   := 2 * e1_long   - ema(e1_long,   long_ma_len)

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

long_signal  = crossover( short_ma, medium_ma) and medium_ma > long_ma
short_signal = crossunder(short_ma, medium_ma) and medium_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] and nz(last_signal[2]) != 1) or (short_signal[1] and nz(last_signal[2]) != -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(medium_ma, color = green,  linewidth = 2)
plot(long_ma,   color = yellow, 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)

अधिक