Strategi Purata Pergerakan Adaptif Saluran Gaussian


Tarikh penciptaan: 2024-03-28 18:08:18 Akhirnya diubah suai: 2024-03-28 18:08:18
Salin: 0 Bilangan klik: 1117
avatar of ChaoZhang ChaoZhang
1
fokus pada
1617
Pengikut

Strategi Purata Pergerakan Adaptif Saluran Gaussian

Gambaran keseluruhan

Strategi Gauss Channel Adaptive Equilibrium adalah strategi perdagangan kuantitatif yang menggunakan teknik Gauss Wave dan set parameter adaptif. Strategi ini berdasarkan teori Gauss Wave yang dikemukakan oleh John Ehlers, menghasilkan isyarat perdagangan yang lancar dan adaptif dengan pengiraan purata bergerak indeks berulang pada data harga.

Prinsip Strategi

Prinsip-prinsip penyesuaian saluran Gaussian untuk strategi garis sejajar adalah seperti berikut:

  1. Mengira nilai Gaussian harga. Bergantung pada kitaran sampel dan bilangan titik titik yang ditetapkan oleh pengguna, parameter Beta dan Alpha dikira, dan kemudian data harga digeserkan Gaussian, mendapatkan urutan harga yang diproses dengan lancar.
  2. Hitung nilai Gaussian untuk amplitudo turun naik sebenar. Rawatan Gaussian yang sama dilakukan untuk amplitudo turun naik sebenar harga, untuk mendapatkan urutan amplitudo turun naik yang lancar.
  3. Membina saluran Gaussian. Dengan harga Gaussian selepas gelombang gelombang, saluran atas ditambah oleh saluran tengah ditambah dengan amplitudo gelombang sebenar dengan kelipatan yang ditetapkan oleh pengguna, saluran bawah dikurangkan oleh saluran tengah dan membentuk saluran dinamik.
  4. Menjana isyarat dagangan. Apabila harga naik, ia menghasilkan isyarat beli. Apabila harga turun, ia menghasilkan isyarat jual.
  5. Masukkan parameter tempoh masa. Pengguna boleh menetapkan masa permulaan dan pengakhiran strategi, di mana strategi akan bertindak berdasarkan isyarat perdagangan.

Analisis kelebihan

Kaedah penyesuaian garis lurus saluran Gaussian mempunyai kelebihan berikut:

  1. Strategi menggunakan parameter yang disesuaikan secara dinamik, dapat menyesuaikan diri dengan keadaan pasaran dan jenis perdagangan yang berbeza, tanpa perlu melakukan pengendalian manual yang kerap.
  2. Dengan membina saluran harga, strategi dapat menangkap dan mengikuti trend pasaran dengan lebih baik, dan dengan berkesan mengelakkan isyarat palsu di pasaran yang bergolak.
  3. Kualiti yang baik. Menggunakan teknik gelombang Gaussian untuk memproses data harga dengan lebih banyak kelancaran, menghilangkan sebahagian besar bunyi pasaran, menjadikan isyarat perdagangan lebih dipercayai.
  4. Fleksibiliti yang tinggi. Pengguna boleh menyesuaikan parameter strategi seperti kitaran sampel, bilangan titik titik, kelipatan gelombang, dan sebagainya untuk mengoptimumkan prestasi strategi.
  5. Keupayaan yang kuat. Dengan pengenalan parameter tempoh masa, strategi dapat dijalankan dalam jangka masa yang ditetapkan, memudahkan aplikasi lapangan dan kajian retrospeksi.

Analisis risiko

Walaupun terdapat banyak kelebihan dalam strategi adaptasi garis lurus saluran Gaussian, terdapat juga risiko:

  1. Pengaturan parameter berisiko. Pengaturan parameter yang tidak sesuai boleh menyebabkan strategi gagal atau berkinerja buruk, oleh itu perlu diuji dan dioptimumkan berulang kali dalam aplikasi sebenar.
  2. Risiko insiden yang tidak dijangka. Dalam menghadapi beberapa insiden yang tidak dijangka, strategi mungkin tidak dapat bertindak balas dengan tepat dan tepat pada masanya, menyebabkan kerugian.
  3. Risiko terlalu sesuai. Jika parameter ditetapkan terlalu sesuai dengan data sejarah, ia boleh menyebabkan strategi tidak berfungsi dengan baik pada masa akan datang dan perlu mengambil kira prestasi dalaman dan luaran sampel.
  4. Risiko Leverage. Strategi ini digunakan terutamanya untuk pasaran yang sedang tren, dan risiko leverage yang lebih besar mungkin berlaku jika anda sering berdagang di pasaran yang bergolak.

Arah pengoptimuman

Kaedah pengoptimuman untuk menyesuaikan diri dengan strategi Goss Channel termasuk:

  1. Pengoptimuman parameter dinamik. Dengan memperkenalkan teknologi seperti pembelajaran mesin, pengoptimuman automatik dan penyesuaian dinamik parameter strategi dapat dicapai, meningkatkan daya serap.
  2. Penyepaduan pelbagai faktor: menggabungkan indikator atau faktor teknikal lain yang berkesan dengan saluran Gaussian untuk membentuk isyarat perdagangan yang lebih mantap.
  3. Pengurusan kedudukan yang dioptimumkan. Menambah peraturan pengurusan kedudukan dan pengurusan wang yang munasabah berdasarkan strategi, mengawal penarikan balik dan risiko.
  4. Koordinasi pelbagai jenis: memperluaskan strategi ke pelbagai jenis perdagangan yang berbeza untuk menyebarkan risiko melalui penempatan aset dan analisis relevansi.

ringkaskan

Kaedah beradaptasi garis rata Gaussian adalah strategi perdagangan kuantitatif berdasarkan gelombang Gaussian dan parameter beradaptasi, menghasilkan isyarat perdagangan yang lancar dan boleh dipercayai dengan membina saluran harga secara dinamik. Kaedah ini mempunyai kelebihan seperti penyesuaian yang kuat, pengesanan trend yang baik, kelancaran yang tinggi, fleksibiliti yang tinggi, dan kepraktisan yang kuat, tetapi juga menghadapi risiko parameter, kejadian yang tidak dijangka, overfit dan lelang di masa depan.

Kod sumber strategi 
/*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")
Forums
PINE Language FAQ Summary MyLanguage Web3 About Us
Product
Robot Strategy Node Platforms Tickets
API
Syntax guide User guide Trading api Blockchain Indicator

© 2015 - ∞ INVENTOR PTE LTD (SG)