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

गतिशील एटीआर स्टॉप लॉस सेंटर लाइन रणनीति

लेखक:चाओझांग, दिनांकः 2023-10-16 16:20:06
टैगः

अवलोकन

यह रणनीति दो हरी और लाल रेखाओं से मिलकर मूल्य चैनल की गणना करने के लिए एक रैखिक प्रतिगमन फ़ंक्शन और न्यूनतम वर्ग विधि का उपयोग करती है। यह हाल के एटीआर के आधार पर एक गतिशील स्टॉप लॉस का उपयोग करती है।

रणनीति तर्क

रणनीति लंबाई 25 और शिफ्ट 5 के साथ रैखिक प्रतिगमन का उपयोग करके केंद्र रेखा xLG की गणना करती है। फिर यह केंद्र रेखा के ऊपर और नीचे 6% को चैनल रेंज के रूप में लेता है, जिसमें xLG1r ऊपरी रेखा और xLG1s निचली रेखा है।

जब कीमत xLG1r से ऊपर होती है, तो यह लंबी जाती है। जब कीमत xLG1s से नीचे होती है, तो यह छोटी जाती है। यह अंतिम लंबे और छोटे समय को रिकॉर्ड करती है। एक लंबा संकेत तब उत्पन्न होता है जब अंतिम लंबा समय अंतिम छोटे समय से बड़ा होता है। एक छोटा संकेत तब उत्पन्न होता है जब अंतिम छोटा समय अंतिम लंबे समय से बड़ा होता है।

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

लाभ विश्लेषण

लंबी अवधि के रुझानों को ट्रैक करने के लिए रैखिक प्रतिगमन चैनल का उपयोग करता है
एटीआर आधारित स्टॉप लॉस स्टॉप बहुत चौड़े या बहुत तंग होने से बचने के लिए गतिशील रूप से समायोजित करता है
मूल्य ब्रेकआउट संकेत गलत संकेतों से बचने में मदद करते हैं

जोखिम और सुधार

प्रतिगमन चैनल मापदंडों अनुकूलन की जरूरत है, वर्तमान सीमा बहुत संकीर्ण हो सकता है
एटीआर गुणक भी इष्टतम पैरामीटर खोजने के लिए परीक्षण की जरूरत है
झूठे ब्रेकआउट से बचने के लिए ब्रेकआउट पर पुष्टि जोड़ने पर विचार करें

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

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

निष्कर्ष

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

/*backtest
start: 2023-01-01 00:00:00
end: 2023-06-24 00:00:00
period: 4h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
// Thanks to HPotter for the original code for Center of Gravity Backtest
strategy("Center of Gravity BF 🚀", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.15)

/////////////// Time Frame ///////////////
testStartYear = input(2017, "Backtest Start Year") 
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)

testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)

testPeriod() => true

///////////// Center of Gravity /////////////
Length = input(25, minval=1)
m = input(5, minval=0)
Percent = input(6, minval=0, title="COG %")

xLG = linreg(close, Length, m)
xLG1r = xLG + ((close * Percent) / 100)
xLG1s = xLG - ((close * Percent) / 100)

pos = 0.0
pos := iff(close > xLG1r, 1, iff(close < xLG1s, -1, nz(pos[1], 0))) 
possig = iff(pos == 1, 1, iff(pos == -1, -1, pos))

/////////////// Srategy ///////////////
long = possig == 1 
short = possig == -1 

last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])

long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)

last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])

last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])

in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal

last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])

since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1]) 
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1]) 

/////////////// Dynamic ATR Stop Losses ///////////////
atrLkb = input(1, minval=1, title='ATR Stop Period')
atrMult = input(2, step=0.25, title='ATR Stop Multiplier') 
atr1 = atr(atrLkb)

longStop = 0.0
longStop :=  short_signal ? na : long_signal ? close - (atr1 * atrMult) : longStop[1]
shortStop = 0.0
shortStop := long_signal ? na : short_signal ? close + (atr1 * atrMult) : shortStop[1]

/////////////// Execution ///////////////
if testPeriod()
    strategy.entry("Long",  strategy.long, when=long)
    strategy.entry("Short", strategy.short, when=short)
    strategy.exit("Long SL", "Long", stop=longStop, when=since_longEntry > 0)
    strategy.exit("Short SL", "Short", stop=shortStop, when=since_shortEntry > 0)

/////////////// Plotting ///////////////
plot(xLG1r, color=color.lime, title="LG1r")
plot(xLG1s, color=color.red, title="LG1s")
plot(strategy.position_size <= 0 ? na : longStop, title="Long Stop Loss", color=color.yellow, style=plot.style_circles, linewidth=1)
plot(strategy.position_size >= 0 ? na : shortStop, title="Short Stop Loss", color=color.orange, style=plot.style_circles, linewidth=1)
bgcolor(strategy.position_size > 0 ? color.lime : strategy.position_size < 0 ? color.red : color.white, transp=90)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=60)

अधिक

2019 FMZ - सभी अधिकार सुरक्षित