Strategi Rata-rata Pergerakan Adaptif Saluran Gaussian
Tanggal Pembuatan:
2024-03-28 18:08:18
Akhirnya memodifikasi:
2024-03-28 18:08:18
menyalin:
0
Jumlah klik:
1117
ChaoZhang
1
fokus pada
1617
Pengikut
Ringkasan
Strategi Gauss Channel Adaptive Equilibrium adalah strategi perdagangan kuantitatif yang menggunakan teknik Gauss Wave dan pengaturan parameter adaptif. Strategi ini didasarkan pada teori Gauss Wave yang dikemukakan oleh John Ehlers, yang menghasilkan sinyal perdagangan yang halus dan adaptif dengan menghitung rata-rata bergerak indeks beberapa kali pada data harga.
Prinsip Strategi
Prinsip-prinsip dari adaptasi saluran Gaussian terhadap strategi linier adalah sebagai berikut:
- Perhitungan nilai Gaussian dari harga. Berdasarkan periode sampling dan jumlah titik polar yang ditetapkan pengguna, parameter Beta dan Alpha dihitung, kemudian data harga diukur dengan Gaussian, dan kemudian mendapatkan urutan harga yang telah diproses dengan halus.
- Menghitung nilai Gaussian dari amplitudo fluktuasi riil. Proses Gaussian yang sama dilakukan pada amplitudo fluktuasi riil dari harga, dan mendapatkan urutan amplitudo fluktuasi yang halus.
- Konstruksi saluran Gaussian. Dengan harga Gaussian setelah gelombang, jalur tengah, jalur atas ditambah dengan jalur tengah ditambah dengan amplitudo gelombang nyata dengan kelipatan yang ditetapkan oleh pengguna, jalur bawah dikurangi dengan jalur tengah nilai ini, membentuk sebuah saluran dinamis.
- Menciptakan sinyal perdagangan. Ketika harga naik melewati saluran atas, menghasilkan sinyal beli; Ketika harga turun melewati saluran bawah, menghasilkan sinyal jual
- Masukkan parameter jangka waktu. Pengguna dapat mengatur waktu mulai dan berhenti dari operasi strategi, dan hanya dalam jangka waktu tertentu strategi akan beroperasi berdasarkan sinyal perdagangan.
Analisis Keunggulan
Strategi adaptasi garis rata Goss Channel memiliki keuntungan sebagai berikut:
- Adaptif. Strategi menggunakan parameter yang disesuaikan secara dinamis, dapat beradaptasi dengan berbagai kondisi pasar dan varietas perdagangan, tanpa perlu sering melakukan debugging manual.
- Dengan membangun saluran harga, strategi dapat menangkap dan mengikuti tren pasar dengan lebih baik dan secara efektif menghindari sinyal palsu di pasar yang bergoyang.
- Hal ini dilakukan dengan menggunakan teknik Goslin Wave untuk memperlancar data harga beberapa kali, menghilangkan sebagian besar kebisingan pasar, membuat sinyal perdagangan lebih dapat diandalkan.
- Fleksibilitas tinggi. Pengguna dapat menyesuaikan parameter kebijakan sesuai dengan kebutuhan, seperti periode sampling, jumlah titik polaritas, kelipatan fluktuasi, dan lain-lain, untuk mengoptimalkan kinerja kebijakan.
- Kepraktisan yang kuat. Dengan parameter jangka waktu yang diperkenalkan, strategi dapat dijalankan dalam jangka waktu yang ditentukan, untuk memudahkan aplikasi di lapangan dan penelitian retrospektif.
Analisis risiko
Meskipun ada banyak keuntungan dari strategi adaptasi garis rata Goss Channel, ada beberapa risiko:
- Risiko pengaturan parameter. Pengaturan parameter yang tidak tepat dapat menyebabkan kegagalan strategi atau kinerja yang buruk, sehingga perlu pengujian dan pengoptimalan berulang dalam aplikasi nyata.
- Risiko insiden mendadak. Dalam menghadapi beberapa insiden mendadak, strategi mungkin tidak dapat bereaksi dengan tepat dan tepat waktu, menyebabkan kerugian.
- Risiko overfit. Jika parameter disetel terlalu dekat dengan data historis, itu dapat menyebabkan kinerja strategi yang buruk di masa depan, yang perlu dipertimbangkan dalam dan luar sampel.
- Risiko Leverage. Strategi ini terutama berlaku untuk pasar yang sedang tren, dan jika Anda sering berdagang di pasar yang bergolak, Anda mungkin menghadapi risiko leverage yang lebih besar.
Arah optimasi
Salah satu arah optimasi dari strategi adaptasi Goss Channel adalah:
- Optimasi parameter dinamis. Optimasi otomatis dan penyesuaian dinamis parameter kebijakan, meningkatkan adaptasi dengan memperkenalkan teknologi seperti pembelajaran mesin.
- Fusi multi-faktor: mengkombinasikan indikator atau faktor teknis lain yang efektif dengan saluran Gaussian untuk membentuk sinyal perdagangan yang lebih kuat.
- Optimalisasi manajemen posisi. Menambahkan manajemen posisi yang masuk akal dan aturan pengelolaan dana berdasarkan strategi, mengendalikan penarikan dan risiko.
- Multi Variety Synergy: memperluas strategi ke berbagai varietas perdagangan yang berbeda untuk mendistribusikan risiko melalui penempatan aset dan analisis relevansi.
Meringkaskan
Strategi Gaussian Adaptive Equilibrium adalah strategi perdagangan kuantitatif yang didasarkan pada Gaussian Ripple dan parameter adaptif, menghasilkan sinyal perdagangan yang halus dan andal dengan membangun saluran harga secara dinamis. Strategi ini memiliki keunggulan seperti kemampuan beradaptasi yang kuat, pelacakan tren yang baik, kelancaran yang tinggi, fleksibilitas yang besar, dan kepraktisan yang kuat, tetapi juga menghadapi risiko seperti pengaturan parameter, kejadian yang tidak terduga, overadaptasi dan lelang di masa depan.
Kode 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")