बहु-समय फ़्रेम गतिशील बैकटेस्ट रणनीति


निर्माण तिथि: 2023-11-21 17:07:17 अंत में संशोधित करें: 2023-11-21 17:07:17
कॉपी: 1 क्लिक्स: 698
1
ध्यान केंद्रित करना
1617
समर्थक

बहु-समय फ़्रेम गतिशील बैकटेस्ट रणनीति

अवलोकन

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

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

यह रणनीति कस्टम फ़ंक्शन f_get_htfHighLow को कॉल करके अलग-अलग समय अवधि के लिए उच्चतम मूल्य nhigh और निम्नतम मूल्य nlow प्राप्त करती है। विशेष रूप से, उपयोगकर्ता द्वारा निर्धारित समय अवधि के लिए उच्चतम और निम्नतम मूल्य प्राप्त करने के लिए सुरक्षा फ़ंक्शन को कॉल करें।

उदाहरण के लिए, जब ऑफसेट 0 होता है, तो वर्तमान K लाइन के उच्चतम और निम्नतम मूल्य प्राप्त होते हैं; जब ऑफसेट 1 होता है, तो पिछले K लाइन के उच्चतम और निम्नतम मूल्य प्राप्त होते हैं। दो K लाइनों के बीच मूल्य परिवर्तन की तुलना करके, प्रवृत्ति की दिशा का न्याय करें।

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

रणनीतिक लाभ

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

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

  1. बहु-समय-सीमा निर्णयों में गलतफहमी का खतरा
  2. गलत रीडायरेक्ट पैरामीटर सेटिंग के कारण repainting हो सकता है
  3. ट्रेडिंग आवृत्ति अधिक हो सकती है, जिससे ट्रेडिंग लागत और स्लिप-ऑफ जोखिम बढ़ सकता है

समाधान:

  1. समय चक्र पैरामीटर का अनुकूलन, निर्णय की सटीकता में सुधार
  2. रिपेन्टिंग से बचने के लिए कठोर परीक्षण
  3. ट्रेडों की आवृत्ति को नियंत्रित करने के लिए स्थिति को ठीक से समायोजित करें

रणनीति अनुकूलन दिशा

  1. एआई का उपयोग करके ट्रेंड का आकलन करने के लिए मशीन लर्निंग मॉड्यूल जोड़ें
  2. स्टॉक मूल्य में उतार-चढ़ाव के साथ गतिशील समायोजन
  3. नुकसान के जोखिम को प्रभावी ढंग से नियंत्रित करने के लिए रोकथाम तंत्र में शामिल होना

संक्षेप

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

रणनीति स्रोत कोड
/*backtest
start: 2022-11-14 00:00:00
end: 2023-11-20 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/
// © HeWhoMustNotBeNamed

//@version=4
strategy("HTF High/Low Repaint Strategy", overlay=true, initial_capital = 20000, default_qty_type = strategy.percent_of_equity, default_qty_value = 100, commission_type = strategy.commission.percent, pyramiding = 1, commission_value = 0.01)

i_startTime = input(defval = timestamp("01 Jan 2010 00:00 +0000"), title = "Start Time", type = input.time)
i_endTime = input(defval = timestamp("01 Jan 2099 00:00 +0000"), title = "End Time", type = input.time)
inDateRange = true

resolution = input("3M", type=input.resolution)
HTFMultiplier = input(22, minval=1, step=1)
offset = input(0, minval=0, step=1)
lookahead = input(true)
gaps = false

f_secureSecurity_on_on(_symbol, _res, _src, _offset) => security(_symbol, _res, _src[_offset], lookahead = barmerge.lookahead_on, gaps=barmerge.gaps_on)
f_secureSecurity_on_off(_symbol, _res, _src, _offset) => security(_symbol, _res, _src[_offset], lookahead = barmerge.lookahead_on, gaps=barmerge.gaps_off)
f_secureSecurity_off_on(_symbol, _res, _src, _offset) => security(_symbol, _res, _src[_offset], lookahead = barmerge.lookahead_off, gaps=barmerge.gaps_on)
f_secureSecurity_off_off(_symbol, _res, _src, _offset) => security(_symbol, _res, _src[_offset], lookahead = barmerge.lookahead_off, gaps=barmerge.gaps_off)

f_multiple_resolution(HTFMultiplier) => 
    target_Res_In_Min = timeframe.multiplier * HTFMultiplier * (
      timeframe.isseconds   ? 1. / 60. :
      timeframe.isminutes   ? 1. :
      timeframe.isdaily     ? 1440. :
      timeframe.isweekly    ? 7. * 24. * 60. :
      timeframe.ismonthly   ? 30.417 * 24. * 60. : na)

    target_Res_In_Min     <= 0.0417       ? "1S"  :
      target_Res_In_Min   <= 0.167        ? "5S"  :
      target_Res_In_Min   <= 0.376        ? "15S" :
      target_Res_In_Min   <= 0.751        ? "30S" :
      target_Res_In_Min   <= 1440         ? tostring(round(target_Res_In_Min)) :
      tostring(round(min(target_Res_In_Min / 1440, 365))) + "D"

f_get_htfHighLow(resolution, HTFMultiplier, lookahead, gaps, offset)=>
    derivedResolution = resolution == ""?f_multiple_resolution(HTFMultiplier):resolution
    nhigh_on_on = f_secureSecurity_on_on(syminfo.tickerid, derivedResolution, high, offset) 
    nlow_on_on = f_secureSecurity_on_on(syminfo.tickerid, derivedResolution, low, offset)
    
    nhigh_on_off = f_secureSecurity_on_off(syminfo.tickerid, derivedResolution, high, offset) 
    nlow_on_off = f_secureSecurity_on_off(syminfo.tickerid, derivedResolution, low, offset)
    
    nhigh_off_on = f_secureSecurity_off_on(syminfo.tickerid, derivedResolution, high, offset) 
    nlow_off_on = f_secureSecurity_off_on(syminfo.tickerid, derivedResolution, low, offset)
    
    nhigh_off_off = f_secureSecurity_off_off(syminfo.tickerid, derivedResolution, high, offset) 
    nlow_off_off = f_secureSecurity_off_off(syminfo.tickerid, derivedResolution, low, offset)
    
    nhigh = lookahead and gaps ? nhigh_on_on :
             lookahead and not gaps ? nhigh_on_off :
             not lookahead and gaps ? nhigh_off_on :
             not lookahead and not gaps ? nhigh_off_off : na
    nlow = lookahead and gaps ? nlow_on_on :
             lookahead and not gaps ? nlow_on_off :
             not lookahead and gaps ? nlow_off_on :
             not lookahead and not gaps ? nlow_off_off : na
    [nhigh, nlow]
    
[nhigh, nlow] = f_get_htfHighLow(resolution, HTFMultiplier, lookahead, gaps, offset)
[nhighlast, nlowlast] = f_get_htfHighLow(resolution, HTFMultiplier, lookahead, gaps, offset+1)
plot(nhigh , title="HTF High",style=plot.style_circles, color=color.green, linewidth=1) 
plot(nlow , title="HTF Low",style=plot.style_circles, color=color.red, linewidth=1)

buyCondition = nhigh > nhighlast and nlow > nlowlast
sellCondition = nhigh < nhighlast and nlow < nlowlast

strategy.entry("Buy", strategy.long, when= buyCondition and inDateRange, oca_name="oca_buy")
strategy.entry("Sell", strategy.short, when= sellCondition and inDateRange, oca_name="oca_sell")