संसाधन लोड हो रहा है... लोड करना...

एटीआर और ब्रेकआउट आधारित ईटीएफ ट्रेडिंग रणनीति

लेखक:चाओझांग, दिनांक: 2023-12-26 16:05:55
टैगः

img

अवलोकन

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

रणनीति तर्क

यह रणनीति मुख्यतः निम्नलिखित सिद्धांतों पर आधारित हैः

  1. मूल्य प्रवृत्ति और दिशा निर्धारित करने के लिए एक निश्चित अवधि (जैसे 20 मोमबत्तियों) के उच्चतम और निम्नतम मूल्य का उपयोग करें। जब मूल्य अवधि के उच्चतम मूल्य को तोड़ता है, तो लंबे समय तक जाएं, और जब मूल्य सबसे कम मूल्य को तोड़ता है, तो शॉर्ट करें।

  2. गतिशील रूप से स्टॉप लॉस स्तर की गणना करने के लिए एटीआर का प्रयोग करें। स्टॉप लॉस को एटीआर अवधि के एटीआर मूल्य की दूरी पर रखा जाता है जो प्रवेश मूल्य से गुणांक (जैसे 2) से गुणा किया जाता है।

  3. लाभ लेने के स्तर को निर्धारित करने के लिए एटीआर का प्रयोग करें। लाभ लेने को एटीआर अवधि के एटीआर मूल्य की दूरी पर रखा जाता है जो प्रवेश मूल्य से गुणांक (जैसे 1) से गुणा किया जाता है।

  4. ट्रेलर स्टॉप लॉस को ट्रेल करने के लिए एटीआर ट्रेलर गुणक का प्रयोग करें। जब कीमत प्रतिकूल दिशा की ओर ट्रेलर स्टॉप लॉस स्तर के माध्यम से टूटती है तो स्टॉप लॉस के साथ पदों को बंद करें।

रणनीति सरल और विश्वसनीय है, क्योंकि यह समय पर मूल्य आंदोलनों को पकड़ने के लिए मूल्य प्रवृत्ति दिशा दोनों को ध्यान में रखती है, और लाभ लेने और जोखिम नियंत्रण के लिए स्टॉप लॉस और ले लाभ सेट करती है।

लाभ विश्लेषण

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

  1. रणनीति का तर्क सरल और स्पष्ट है, इसे समझना और लागू करना आसान है।

  2. अनुकूलन स्टॉप लॉस और लाभ लेने के स्तरों की गणना करने के लिए एटीआर का उपयोग करने से लचीली स्थिति आकार और जोखिम नियंत्रण में मदद मिलती है।

  3. ब्रेकआउट रणनीतियाँ मूल्य प्रवृत्तियों को पकड़ने में अच्छी होती हैं, जिससे अच्छा रिटर्न मिलता है।

  4. ट्रेलर स्टॉप लॉस समय पर पदों को बंद कर सकता है, अत्यधिक नुकसान से बच सकता है।

  5. यह ईटीएफ और स्टॉक जैसे स्पष्ट रुझान वाले उत्पादों के लिए उपयुक्त है।

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

इस रणनीति के जोखिमों में निम्नलिखित शामिल हैंः

  1. मूल्य समेकन के दौरान अधिक झूठे संकेत और रिवर्स ओपनिंग हो सकते हैं।

  2. अनुचित पैरामीटर ट्यूनिंग से मूल्य के रुझानों में कमी या बहुत अधिक अनावश्यक ट्रेड हो सकती है।

  3. चरम पैरामीटर मानों के परिणामस्वरूप अत्यधिक आक्रामक या अत्यधिक रूढ़िवादी स्टॉप लॉस और लाभ ले सकते हैं, जो रणनीति लाभप्रदता को प्रभावित करते हैं।

  4. नीति और प्रीमियम जोखिम जैसे ईटीएफ के अंतर्निहित जोखिम भी रणनीति के प्रदर्शन को प्रभावित कर सकते हैं।

संबंधित समाधान:

  1. अनावश्यक व्यापारों को कम करने के लिए मापदंडों को अनुकूलित करें।
  2. ट्रेडिंग संकेतों की पुष्टि करने के लिए अधिक कारक और फ़िल्टर जोड़ें।
  3. विभिन्न बाजारों के लिए अनुकूलित रूप से मापदंडों को समायोजित करें।
  4. एक ही ईटीएफ के निवेश और नियंत्रण स्थिति के आकार को विविधता प्रदान करना।

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

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

  1. झूठे संकेतों को फ़िल्टर करने के लिए चलती औसत जैसे संकेतक जोड़ें।

  2. विभिन्न अवधियों और उत्पादों के लिए ऑटो-ट्यून मापदंडों के लिए अनुकूलनशील पैरामीटर अनुकूलन मॉड्यूल विकसित करना।

  3. ब्रेकआउट सिग्नल निर्धारित करने के लिए अगली मोमबत्ती के उच्चतम और निम्नतम मूल्य की भविष्यवाणी करने के लिए मशीन लर्निंग मॉडल को अपनाएं।

  4. झूठे ब्रेकआउट से बचने के लिए ट्रेडिंग वॉल्यूम ओवरफ्लो पर विचार करें।

  5. विभिन्न उत्पादों और बाजार व्यवस्थाओं के लिए अनुकूलनशील रूप से प्रारंभिक स्थिति आकार और आवंटन प्रतिशत को अनुकूलित करना।

निष्कर्ष

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


/*backtest
start: 2023-12-18 00:00:00
end: 2023-12-21 03:00:00
period: 1m
basePeriod: 1m
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/
// © FX_minds

//@version=4
strategy("ETF tradedr", overlay=true, pyramiding=100, default_qty_type=strategy.percent_of_equity, default_qty_value=100)

//------------------------------ get user input
lookback                   = input(title="HH LL lookback", type=input.integer, defval=20)
ATR_periode                = input(title="ATR period", type=input.integer, defval=14)
ATR_SL_multiplier          = input(title="ATR SL multiplier", type=input.float, defval=2)
ATR_TP_multiplier          = input(title="ATR TP multiplier", type=input.float, defval=1)
trailing_SL_ATR_multiplier = input(title="ATR trailing SL multiplier", type=input.float, defval=3.5)
lookback_trailing_SL       = input(title="trailing SL lookback", type=input.integer, defval=4)
max_sequel_trades          = input(title="max sequel trades", type=input.float, defval=1)
trade_long                 = input(title= "trade long ?", type=input.bool, defval=true)
trade_short                = input(title= "trade short ?", type=input.bool, defval=false)

//------------------------------ determine entry conditions
long_condition   = barstate.isconfirmed and crossover(high, highest(high, lookback)[1])
short_condition  = barstate.isconfirmed and crossunder(low, lowest(low, lookback)[1])


//------------------------------ count open long trades
count_open_longs = 0
count_open_longs := nz(count_open_longs[1])

if (long_condition) 
    count_open_longs := count_open_longs +1
    //label.new(bar_index, low, tostring(count_open_longs, "#"), xloc.bar_index, yloc.belowbar, color.green, label.style_none, color.green, size.large)

if (short_condition)
    count_open_longs := 0


//------------------------------ count open short trades
count_open_shorts = 0
count_open_shorts := nz(count_open_shorts[1])

if (short_condition)
    count_open_shorts := count_open_shorts +1
    //label.new(bar_index, low, tostring(count_open_shorts, "#"), xloc.bar_index, yloc.belowbar, color.red, label.style_none, color.red, size.large)

if (long_condition)
    count_open_shorts := 0


//------------------------------ calculate entryprice
entryprice_long = long_condition ? close : na
entryprice_short = short_condition ? close : na


//------------------------------ calculate SL & TP
SL_distance = atr(ATR_periode) * ATR_SL_multiplier
TP_distance  = atr(ATR_periode) * ATR_TP_multiplier
trailing_SL_distance = atr(ATR_periode) * trailing_SL_ATR_multiplier

SL_long = entryprice_long - SL_distance
SL_short = entryprice_short + SL_distance

trailing_SL_short = lowest(close, lookback_trailing_SL) + trailing_SL_distance
trailing_SL_long  = highest(close, lookback_trailing_SL) - trailing_SL_distance

trailing_SL_short_signal = crossover(high, trailing_SL_short[1])
trailing_SL_long_signal = crossunder(low, trailing_SL_long[1])


//------------------------------ plot entry price & SL  
plot(entryprice_long, style=plot.style_linebr, color=color.white)
plot(SL_long, style=plot.style_linebr, color=color.red)
plot(SL_short, style=plot.style_linebr, color=color.green)
plot(trailing_SL_short, style=plot.style_linebr, color=color.red)
plot(trailing_SL_long, style=plot.style_linebr, color=color.green)


//------------------------------ submit entry orders
if (long_condition) and (count_open_longs <= max_sequel_trades) and (trade_long == true)
    strategy.entry("Long" + tostring(count_open_longs, "#"), strategy.long)
    strategy.exit("SL Long"+ tostring(count_open_longs, "#"), 
     from_entry="Long" + tostring(count_open_longs, "#"), stop=SL_long)

if (short_condition) and (count_open_shorts <= max_sequel_trades) and (trade_short == true)
    strategy.entry("Short" + tostring(count_open_shorts, "#"), strategy.short)
    strategy.exit("SL Short" + tostring(count_open_shorts, "#"), 
     from_entry="Short" + tostring(count_open_shorts, "#"), stop=SL_short)
    

//------------------------------ submit exit conditions
if (trailing_SL_long_signal)
    strategy.close("Long" + tostring(count_open_longs, "#"))
    strategy.close("Long" + tostring(count_open_longs-1, "#"))
    strategy.close("Long" + tostring(count_open_longs-2, "#"))
    strategy.close("Long" + tostring(count_open_longs-4, "#"))
    strategy.close("Long" + tostring(count_open_longs-5, "#"))
    strategy.close("Long" + tostring(count_open_longs-6, "#"))
    strategy.close("Long" + tostring(count_open_longs-7, "#"))
    strategy.close("Long" + tostring(count_open_longs-8, "#"))
    strategy.close("Long" + tostring(count_open_longs-9, "#"))
    
if (trailing_SL_short_signal)
    strategy.close("Short" + tostring(count_open_shorts, "#"))
    strategy.close("Short" + tostring(count_open_shorts-1, "#"))
    strategy.close("Short" + tostring(count_open_shorts-2, "#"))
    strategy.close("Short" + tostring(count_open_shorts-3, "#"))
    strategy.close("Short" + tostring(count_open_shorts-4, "#"))
    strategy.close("Short" + tostring(count_open_shorts-5, "#"))
    strategy.close("Short" + tostring(count_open_shorts-6, "#"))
    strategy.close("Short" + tostring(count_open_shorts-7, "#"))
    strategy.close("Short" + tostring(count_open_shorts-8, "#"))
    strategy.close("Short" + tostring(count_open_shorts-9, "#"))



अधिक