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

गौसियन चैनल अनुकूलनशील चलती औसत रणनीति

लेखक:चाओझांग, दिनांकः 2024-03-28 18:08:18
टैगः

अवलोकन

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

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

गौसियन चैनल अनुकूलनशील चलती औसत रणनीति के सिद्धांत इस प्रकार हैंः

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

लाभ विश्लेषण

गौसियन चैनल अनुकूलनशील चलती औसत रणनीति के निम्नलिखित फायदे हैंः

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

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

इसके अनेक लाभों के बावजूद, गाउसियन चैनल अनुकूलनशील चलती औसत रणनीति में अभी भी कुछ जोखिम हैंः

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

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

गौसियन चैनल अनुकूलनशील चलती औसत रणनीति के लिए अनुकूलन दिशाओं में शामिल हैंः

गतिशील पैरामीटर अनुकूलन मशीन सीखने और अन्य तकनीकों को पेश करके अनुकूलन क्षमता में सुधार के लिए स्वचालित अनुकूलन और रणनीति मापदंडों के गतिशील समायोजन को प्राप्त करें।
बहु-कारक संलयनः अधिक मजबूत व्यापार संकेत बनाने के लिए गौसियन चैनल के साथ अन्य प्रभावी तकनीकी संकेतकों या कारकों को मिलाएं।
स्थिति प्रबंधन का अनुकूलन। ड्रॉडाउन और जोखिमों को नियंत्रित करने के लिए रणनीति में उचित स्थिति प्रबंधन और धन प्रबंधन नियम शामिल करें।
बहु-उपकरण समन्वय: रणनीति को कई अलग-अलग व्यापारिक साधनों तक विस्तारित करें और परिसंपत्ति आवंटन और सहसंबंध विश्लेषण के माध्यम से जोखिमों को विविधता दें।

सारांश

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

/*backtest
start: 2023-03-22 00:00:00
end: 2024-03-27 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy(title="Gaussian Channel Strategy v1.0", overlay=true, calc_on_every_tick=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.1)

// Date condition inputs
startDate = input(title="Date Start", type=input.time, defval=timestamp("1 Jan 2018 00:00 +0000"), group="Dates")
endDate = input(title="Date End", type=input.time, defval=timestamp("31 Dec 2060 23:59 +0000"), group="Dates")
timeCondition = true

// This study is an experiment utilizing the Ehlers Gaussian Filter technique combined with lag reduction techniques and true range to analyze trend activity.
// Gaussian filters, as Ehlers explains it, are simply exponential moving averages applied multiple times.
// First, beta and alpha are calculated based on the sampling period and number of poles specified. The maximum number of poles available in this script is 9.
// Next, the data being analyzed is given a truncation option for reduced lag, which can be enabled with "Reduced Lag Mode".
// Then the alpha and source values are used to calculate the filter and filtered true range of the dataset.
// Filtered true range with a specified multiplier is then added to and subtracted from the filter, generating a channel.
// Lastly, a one pole filter with a N pole alpha is averaged with the filter to generate a faster filter, which can be enabled with "Fast Response Mode". 

//Custom bar colors are included.

//Note: Both the sampling period and number of poles directly affect how much lag the indicator has, and how smooth the output is.
//      Larger inputs will result in smoother outputs with increased lag, and smaller inputs will have noisier outputs with reduced lag.
//      For the best results, I recommend not setting the sampling period any lower than the number of poles + 1. Going lower truncates the equation.

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Updates:
// Huge shoutout to @e2e4mfck for taking the time to improve the calculation method!
// -> migrated to v4
// -> pi is now calculated using trig identities rather than being explicitly defined.
// -> The filter calculations are now organized into functions rather than being individually defined.
// -> Revamped color scheme.

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Functions - courtesy of @e2e4mfck
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
 
//Filter function 
f_filt9x (_a, _s, _i) => 
    int _m2 = 0, int _m3 = 0, int _m4 = 0, int _m5 = 0, int _m6 = 0, 
    int _m7 = 0, int _m8 = 0, int _m9 = 0, float _f = .0, _x = (1 - _a)
    // Weights. 
    // Initial weight _m1 is a pole number and equal to _i
    _m2 := _i == 9 ? 36  : _i == 8 ? 28 : _i == 7 ? 21 : _i == 6 ? 15 : _i == 5 ? 10 : _i == 4 ? 6 : _i == 3 ? 3 : _i == 2 ? 1 : 0
    _m3 := _i == 9 ? 84  : _i == 8 ? 56 : _i == 7 ? 35 : _i == 6 ? 20 : _i == 5 ? 10 : _i == 4 ? 4 : _i == 3 ? 1 : 0
    _m4 := _i == 9 ? 126 : _i == 8 ? 70 : _i == 7 ? 35 : _i == 6 ? 15 : _i == 5 ? 5  : _i == 4 ? 1 : 0
    _m5 := _i == 9 ? 126 : _i == 8 ? 56 : _i == 7 ? 21 : _i == 6 ? 6  : _i == 5 ? 1  : 0 
    _m6 := _i == 9 ? 84  : _i == 8 ? 28 : _i == 7 ? 7  : _i == 6 ? 1  : 0 
    _m7 := _i == 9 ? 36  : _i == 8 ? 8  : _i == 7 ? 1  : 0 
    _m8 := _i == 9 ? 9   : _i == 8 ? 1  : 0 
    _m9 := _i == 9 ? 1   : 0
    // filter
    _f :=   pow(_a, _i) * nz(_s) + 
      _i  *     _x      * nz(_f[1])      - (_i >= 2 ? 
      _m2 * pow(_x, 2)  * nz(_f[2]) : 0) + (_i >= 3 ? 
      _m3 * pow(_x, 3)  * nz(_f[3]) : 0) - (_i >= 4 ? 
      _m4 * pow(_x, 4)  * nz(_f[4]) : 0) + (_i >= 5 ? 
      _m5 * pow(_x, 5)  * nz(_f[5]) : 0) - (_i >= 6 ? 
      _m6 * pow(_x, 6)  * nz(_f[6]) : 0) + (_i >= 7 ? 
      _m7 * pow(_x, 7)  * nz(_f[7]) : 0) - (_i >= 8 ? 
      _m8 * pow(_x, 8)  * nz(_f[8]) : 0) + (_i == 9 ? 
      _m9 * pow(_x, 9)  * nz(_f[9]) : 0)

//9 var declaration fun
f_pole (_a, _s, _i) =>
    _f1 =            f_filt9x(_a, _s, 1),      _f2 = (_i >= 2 ? f_filt9x(_a, _s, 2) : 0), _f3 = (_i >= 3 ? f_filt9x(_a, _s, 3) : 0)
    _f4 = (_i >= 4 ? f_filt9x(_a, _s, 4) : 0), _f5 = (_i >= 5 ? f_filt9x(_a, _s, 5) : 0), _f6 = (_i >= 6 ? f_filt9x(_a, _s, 6) : 0)
    _f7 = (_i >= 2 ? f_filt9x(_a, _s, 7) : 0), _f8 = (_i >= 8 ? f_filt9x(_a, _s, 8) : 0), _f9 = (_i == 9 ? f_filt9x(_a, _s, 9) : 0)
    _fn = _i == 1 ? _f1 : _i == 2 ? _f2 : _i == 3 ? _f3 :
      _i == 4     ? _f4 : _i == 5 ? _f5 : _i == 6 ? _f6 :
      _i == 7     ? _f7 : _i == 8 ? _f8 : _i == 9 ? _f9 : na
    [_fn, _f1]

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Inputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Source
src = input(defval=hlc3, title="Source")

//Poles
int N = input(defval=4, title="Poles", minval=1, maxval=9)

//Period
int per = input(defval=144, title="Sampling Period", minval=2)

//True Range Multiplier
float mult = input(defval=1.414, title="Filtered True Range Multiplier", minval=0)

//Lag Reduction
bool modeLag  = input(defval=false, title="Reduced Lag Mode")
bool modeFast = input(defval=false, title="Fast Response Mode")

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Definitions
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Beta and Alpha Components
beta  = (1 - cos(4*asin(1)/per)) / (pow(1.414, 2/N) - 1)
alpha = - beta + sqrt(pow(beta, 2) + 2*beta)

//Lag
lag = (per - 1)/(2*N)

//Data
srcdata = modeLag ? src + (src - src[lag]) : src
trdata  = modeLag ? tr(true) + (tr(true) - tr(true)[lag]) : tr(true)

//Filtered Values
[filtn, filt1]     = f_pole(alpha, srcdata, N)
[filtntr, filt1tr] = f_pole(alpha, trdata,  N)

//Lag Reduction
filt   = modeFast ? (filtn + filt1)/2 : filtn
filttr = modeFast ? (filtntr + filt1tr)/2 : filtntr

//Bands
hband = filt + filttr*mult
lband = filt - filttr*mult

// Colors
color1   = #0aff68
color2   = #00752d
color3   = #ff0a5a
color4   = #990032
fcolor   = filt > filt[1] ? #0aff68 : filt < filt[1] ? #ff0a5a : #cccccc
barcolor = (src > src[1]) and (src > filt) and (src < hband) ? #0aff68 : (src > src[1]) and (src >= hband) ? #0aff1b : (src <= src[1]) and (src > filt) ? #00752d : 
           (src < src[1]) and (src < filt) and (src > lband) ? #ff0a5a : (src < src[1]) and (src <= lband) ? #ff0a11 : (src >= src[1]) and (src < filt) ? #990032 : #cccccc

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Outputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Filter Plot
filtplot = plot(filt, title="Filter", color=fcolor, linewidth=3)

//Band Plots
hbandplot = plot(hband, title="Filtered True Range High Band", color=fcolor)
lbandplot = plot(lband, title="Filtered True Range Low Band", color=fcolor)

//Channel Fill
fill(hbandplot, lbandplot, title="Channel Fill", color=fcolor, transp=80)

//Bar Color
barcolor(barcolor)


longCondition = crossover(close, hband) and timeCondition
closeAllCondition = crossunder(close, hband) and timeCondition

if longCondition
    strategy.entry("long", strategy.long)

if closeAllCondition
    strategy.close("long")

अधिक

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