चलती औसत पर आधारित प्रवृत्ति व्यापार रणनीति

लेखक:चाओझांग, दिनांक: 2023-10-30 15:53:25
टैगः

img

अवलोकन

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

रणनीति तर्क

  1. एक निश्चित अवधि (डिफ़ॉल्ट 400 अवधि) के लिए चलती औसत सूचक के रूप में भारित चलती औसत vwma की गणना करें।

  2. निर्धारित करें कि चलती औसत vwma बढ़ रही है, यदि बढ़ रही है तो लंबी संकेत अपट्रेंड सेट करें; यदि गिर रही है तो छोटी संकेत डाउनट्रेंड सेट करें।

  3. जब ऊपर की ओर रुझान सही हो, तो लंबा करें; जब नीचे की ओर रुझान सही हो, तो लंबा बंद करें और छोटा करें।

  4. प्रत्येक बार के लिए रणनीति रिटर्न bar_pnl और buy & hold रिटर्न bar_bh की गणना करें.

  5. त्रैमासिक और वार्षिक समय-स्टैम्प के अनुसार त्रैमासिक रणनीति रिटर्न quarter_pnl, वार्षिक रिटर्न year_pnl और संबंधित buy & hold returns quarter_bh, year_bh की गणना कीजिए।

  6. एक तालिका में तिमाही रणनीति रिटर्न बनाम खरीद और पकड़ रिटर्न दिखाएं।

लाभ विश्लेषण

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

  1. संचालित करने में सरल, चलती औसत से बाजार की प्रवृत्ति का निर्धारण करना, समझने में आसान।

  2. ड्रॉआउट को नियंत्रित करने में अच्छा है। ट्रेंड का अनुसरण करने से गैर-ट्रेंडिंग बाजारों में नुकसान कम होता है।

  3. कुछ समायोज्य मापदंड. मुख्य रूप से चलती औसत अवधि समायोजित, परीक्षण और अनुकूलन करने के लिए आसान.

  4. परिणाम स्पष्ट रूप से दिखाने के लिए सहज ज्ञान युक्त रिटर्न तालिका।

  5. तुलना के लिए तालिका में buy & hold return जोड़ें, अधिक रिटर्न दिखाता है।

  6. लचीली मेज की स्थिति, अन्य रणनीतियों के साथ एकीकृत करने में आसान।

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

कुछ जोखिम भी हैं:

  1. दीर्घकालिक बैल बाजार में खरीद और पकड़ की तुलना में कम प्रदर्शन। चलती औसत अवधि का अनुकूलन कर सकता है।

  2. सीमाबद्ध बाजार में उच्च व्हीपसा जोखिम, लेनदेन को कम करने के लिए पिछले उच्च को तोड़ने जैसी फ़िल्टर स्थितियां जोड़ सकता है।

  3. चलती औसत में घटता वक्र फिट करने की क्षमता कम होती है, प्रवृत्ति मोड़ बिंदुओं को याद कर सकता है। विभिन्न प्रकार के चलती औसत का परीक्षण कर सकता है।

  4. कोई स्टॉप लॉस तंत्र नहीं, भारी ड्रॉडाउन का जोखिम। गतिशील स्टॉप लॉस या स्थिति आकार सेट कर सकते हैं।

  5. तालिका के लिए, शार्प अनुपात, अधिकतम ड्रॉडाउन जैसे जोखिम मेट्रिक्स जोड़ सकते हैं।

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

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

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

  2. Whipsaws को कम करने के लिए पिछले उच्च को तोड़ने जैसे फ़िल्टर जोड़ें।

  3. विभिन्न प्रकार के चलती औसत की कोशिश करो, जैसे WMA, DEMA आदि

  4. स्टॉप लॉस तंत्र जोड़ें, जैसे गतिशील स्टॉप या स्थिति आकार।

  5. तालिका सामग्री को समृद्ध करें, शार्प अनुपात, अधिकतम ड्रॉडाउन जैसे मीट्रिक जोड़ें।

  6. प्रवृत्तियों को निर्धारित करने के लिए एमएसीडी, बोलिंगर बैंड जैसे अन्य संकेतकों के साथ संयोजन करें।

  7. स्थिति आकार अनुकूलित करें, बाजार की स्थितियों के आधार पर स्थिति को गतिशील रूप से समायोजित करें।

  8. विभिन्न उत्पादों पर परीक्षण करें, सर्वोत्तम अनुप्रयोग का दायरा खोजें।

निष्कर्ष

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


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

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Dannnnnnny

//@version=4
strategy(title="Quarterly Returns in Strategies vs Buy & Hold", initial_capital= 1000, overlay=true,default_qty_type = strategy.percent_of_equity, default_qty_value = 100, commission_type = strategy.commission.percent, commission_value = 0.1)
maLength= input(400)

wma= vwma(hl2,maLength)
uptrend= rising(wma, 5)
downtrend= falling(wma,5)

plot(wma)

if uptrend
    strategy.entry("Buy", strategy.long)
else
    strategy.close("Buy")//

///////////////////
// QUARTERLY TABLE //
enableQuarterlyTable = input(title="Enable Quarterly Return table", type=input.bool, defval=false)
enableCompareWithMarket = input(title="Compare with Market Benchmark", type=input.bool, defval=false)
table_position = input(title="Table Position", type=input.string, defval='bottom_right', options=['bottom_right','bottom_left','top_right', 'top_left'])
precision = 2
new_quarter = ceil(month(time)/3)  != ceil(month(time[1])/3)
new_year  = year(time)  != year(time[1])

eq = strategy.equity

bar_pnl = eq / eq[1] - 1
bar_bh = (close-close[1])/close[1]

cur_quarter_pnl = 0.0
cur_year_pnl  = 0.0
cur_quarter_bh = 0.0
cur_year_bh  = 0.0

// Current Quarterly P&L
cur_quarter_pnl := new_quarter ? 0.0 : 
                 (1 + cur_quarter_pnl[1]) * (1 + bar_pnl) - 1 
cur_quarter_bh := new_quarter ? 0.0 : 
                 (1 + cur_quarter_bh[1]) * (1 + bar_bh) - 1

// Current Yearly P&L
cur_year_pnl := new_year ? 0.0 : 
                 (1 + cur_year_pnl[1]) * (1 + bar_pnl) - 1
cur_year_bh := new_year ? 0.0 : 
                 (1 + cur_year_bh[1]) * (1 + bar_bh) - 1

// Arrays to store Yearly and Quarterly P&Ls
var quarter_pnl  = array.new_float(0)
var quarter_time = array.new_int(0)
var quarter_bh  = array.new_float(0)

var year_pnl  = array.new_float(0)
var year_time = array.new_int(0)
var year_bh  = array.new_float(0)

end_time = false

end_time:= time_close + (time_close - time_close[1]) > timenow or barstate.islastconfirmedhistory

if (not na(cur_quarter_pnl[1]) and (new_quarter or end_time))
    if (end_time[1])
        array.pop(quarter_pnl)
        array.pop(quarter_time)
        
    array.push(quarter_pnl , cur_quarter_pnl[1])
    array.push(quarter_time, time[1])
    array.push(quarter_bh , cur_quarter_bh[1])

if (not na(cur_year_pnl[1]) and (new_year or end_time))
    if (end_time[1])
        array.pop(year_pnl)
        array.pop(year_time)
        
    array.push(year_pnl , cur_year_pnl[1])
    array.push(year_time, time[1])
    array.push(year_bh , cur_year_bh[1])

// Quarterly P&L Table    
var quarterly_table = table(na)

getCellColor(pnl, bh)  => 
    if pnl > 0
        if bh < 0 or pnl > 2 * bh
            color.new(color.green, transp = 20)
        else if pnl > bh
            color.new(color.green, transp = 50)
        else
            color.new(color.green, transp = 80)
    else
        if bh > 0 or pnl < 2 * bh
            color.new(color.red, transp = 20)
        else if pnl < bh
            color.new(color.red, transp = 50)
        else
            color.new(color.red, transp = 80)

if (end_time and enableQuarterlyTable)
    quarterly_table := table.new(table_position, columns = 14, rows = array.size(year_pnl) + 1, border_width = 1)

    table.cell(quarterly_table, 0,  0, "",     bgcolor = #cccccc)
    table.cell(quarterly_table, 1,  0, "Q1",  bgcolor = #cccccc)
    table.cell(quarterly_table, 2,  0, "Q2",  bgcolor = #cccccc)
    table.cell(quarterly_table, 3,  0, "Q3",  bgcolor = #cccccc)
    table.cell(quarterly_table, 4,  0, "Q4",  bgcolor = #cccccc)
    table.cell(quarterly_table, 5,  0, "Year", bgcolor = #999999)


    for yi = 0 to array.size(year_pnl) - 1
        table.cell(quarterly_table, 0,  yi + 1, tostring(year(array.get(year_time, yi))), bgcolor = #cccccc)
        
        y_color = getCellColor(array.get(year_pnl, yi), array.get(year_bh, yi))
        table.cell(quarterly_table, 5, yi + 1, enableCompareWithMarket ? tostring(round(array.get(year_pnl, yi) * 100, precision)) + " (" + tostring(round(array.get(year_bh, yi) * 100, precision)) + ")" : tostring(round(array.get(year_pnl, yi) * 100, precision)), bgcolor = y_color, text_color=#bfbfbf)
        
    for mi = 0 to array.size(quarter_time) - 1
        m_row   = year(array.get(quarter_time, mi))  - year(array.get(year_time, 0)) + 1
        m_col   = ceil(month(array.get(quarter_time, mi)) / 3)
        m_color = getCellColor(array.get(quarter_pnl, mi), array.get(quarter_bh, mi))
        
        table.cell(quarterly_table, m_col, m_row, enableCompareWithMarket ?  tostring(round(array.get(quarter_pnl, mi) * 100, precision)) + " (" + tostring(round(array.get(quarter_bh, mi) * 100,precision)) +")" : tostring(round(array.get(quarter_pnl, mi) * 100, precision)), bgcolor = m_color, text_color=#bfbfbf)

अधिक