Tren Saluran Gaussian Mengikuti Strategi

Penulis:ChaoZhang, Tarikh: 2024-03-29 16:26:26
Tag:

Ringkasan

Gaussian Channel Trend Following Strategy adalah strategi perdagangan trend-mengikuti berdasarkan penunjuk Gaussian Channel. Strategi ini bertujuan untuk menangkap trend utama di pasaran, membeli dan memegang kedudukan semasa trend menaik dan menutup kedudukan semasa trend menurun. Ia menggunakan penunjuk Gaussian Channel untuk mengenal pasti arah dan kekuatan trend dengan menganalisis hubungan antara harga dan jalur atas dan bawah saluran. Matlamat utama strategi adalah untuk memaksimumkan keuntungan semasa trend yang berterusan sambil meminimumkan kekerapan semasa pasaran perdagangan terhad jangkauan.

Prinsip Strategi

Inti dari Gaussian Channel Trend Following Strategy ialah Gaussian Channel indicator, yang dicadangkan oleh Ehlers. Ia menggabungkan teknik penapisan Gaussian dengan True Range untuk menganalisis aktiviti trend. Indikator pertama mengira nilai beta dan alpha berdasarkan tempoh pengambilan sampel dan bilangan kutub, kemudian menggunakan penapisan ke data untuk mendapatkan lengkung yang halus (garis tengah). Seterusnya, strategi mengalikan Julat Benar yang halus dengan pengganda untuk menjana saluran atas dan bawah. Apabila harga melintasi di atas / di bawah saluran atas / bawah, ia menjana isyarat beli / jual.

Kelebihan Strategi

Mengikuti trend: Strategi ini cemerlang dalam menangkap trend utama di pasaran, melabur ke arah trend, yang membantu mencapai pulangan stabil jangka panjang.
Frekuensi Perdagangan yang Dikurangkan: Strategi hanya memasuki kedudukan apabila trend disahkan dan mengekalkan kedudukan semasa trend, dengan itu mengurangkan kos perdagangan dan transaksi yang tidak perlu.
Pengurangan Lag: Melalui mod lag yang dikurangkan dan mod tindak balas cepat, strategi dapat bertindak balas dengan lebih cepat terhadap perubahan pasaran.
Parameter Fleksibel: Pengguna boleh menyesuaikan parameter strategi mengikut keperluan mereka, seperti tempoh pengambilan sampel, bilangan tiang, pengganda Julat Benar, dll., untuk mengoptimumkan prestasi strategi.

Risiko Strategi

Risiko pengoptimuman parameter: Tetapan parameter yang tidak betul boleh menyebabkan prestasi strategi yang buruk. Adalah disyorkan untuk melakukan pengoptimuman parameter dan pengujian belakang dalam persekitaran pasaran yang berbeza untuk mencari kombinasi parameter yang optimum.
Risiko Pembalikan Trend: Apabila trend pasaran tiba-tiba berbalik, strategi mungkin mengalami penurunan yang ketara. Ini boleh dikurangkan dengan menetapkan stop-loss atau memperkenalkan penunjuk lain untuk mengawal risiko.
Risiko Pasaran Berhadapan Julat: Dalam pasaran berhadapan Julat, strategi boleh menghasilkan isyarat perdagangan yang kerap, yang membawa kepada pulangan yang berkurangan. Ini boleh ditangani dengan mengoptimumkan parameter atau menggabungkan dengan penunjuk teknikal lain untuk menapis isyarat.

Arahan Pengoptimuman Strategi

Memasukkan Penunjuk Teknikal Lain: Gabungkan dengan penunjuk trend atau pengayun lain, seperti MACD, RSI, dll., untuk meningkatkan ketepatan dan kebolehpercayaan isyarat.
Pengoptimuman Parameter Dinamik: Sesuaikan parameter strategi secara dinamik berdasarkan perubahan dalam keadaan pasaran untuk menyesuaikan diri dengan persekitaran pasaran yang berbeza.
Tambah Modul Kawalan Risiko: Tetapkan peraturan stop-loss dan mengambil keuntungan yang munasabah untuk mengawal risiko perdagangan individu dan tahap pengambilan keseluruhan.
Analisis Pelbagai Jangka Masa: Gabungkan isyarat dari jangka masa yang berbeza, seperti carta harian dan 4 jam, untuk mendapatkan maklumat pasaran yang lebih komprehensif.

Ringkasan

Gaussian Channel Trend Following Strategy adalah strategi perdagangan trend-mengikuti berdasarkan teknik penapisan Gaussian, yang bertujuan untuk menangkap trend pasaran utama untuk pulangan stabil jangka panjang. Strategi ini menggunakan penunjuk Saluran Gaussian untuk mengenal pasti arah trend dan kekuatan sambil menawarkan ciri untuk mengurangkan kelewatan dan memberikan tindak balas yang cepat. Kelebihan strategi terletak pada keupayaan trend-mengikuti yang kuat dan kekerapan perdagangan yang rendah. Walau bagaimanapun, ia juga menghadapi risiko seperti pengoptimuman parameter, pembalikan trend, dan pasaran terhad. Pengoptimuman masa depan boleh merangkumi menggabungkan penunjuk teknikal lain, pengoptimuman parameter dinamik, menambah modul kawalan risiko, dan analisis pelbagai jangka masa untuk meningkatkan lagi kekuatan dan keuntungan strategi.

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

//@version=5
strategy(title="Gaussian Channel Strategy v2.0", overlay=true, calc_on_every_tick=false, initial_capital=1000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.1, slippage=3)

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Channel Indicaor - courtesy of @DonovanWall
//----------------------------------------------------------------------------------------------------------------------------------------------------------------- 

// Date condition inputs
startDate = input(timestamp("1 January 2018 00:00 +0000"), "Date Start", group="Main Algo Settings")
endDate = input(timestamp("1 January 2060 00:00 +0000"), "Date Start", group="Main Algo Settings")
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 :=   math.pow(_a, _i) * nz(_s) + 
      _i  *     _x      * nz(_f[1])      - (_i >= 2 ? 
      _m2 * math.pow(_x, 2)  * nz(_f[2]) : 0) + (_i >= 3 ? 
      _m3 * math.pow(_x, 3)  * nz(_f[3]) : 0) - (_i >= 4 ? 
      _m4 * math.pow(_x, 4)  * nz(_f[4]) : 0) + (_i >= 5 ? 
      _m5 * math.pow(_x, 5)  * nz(_f[5]) : 0) - (_i >= 6 ? 
      _m6 * math.pow(_x, 6)  * nz(_f[6]) : 0) + (_i >= 7 ? 
      _m7 * math.pow(_x, 7)  * nz(_f[7]) : 0) - (_i >= 8 ? 
      _m8 * math.pow(_x, 8)  * nz(_f[8]) : 0) + (_i == 9 ? 
      _m9 * math.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.int(defval=4, title="Poles", minval=1, maxval=9)

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

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

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

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

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

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

// Data
srcdata = modeLag ? src + (src - src[lag]) : src
trdata  = modeLag ? ta.tr(true) + (ta.tr(true) - ta.tr(true)[lag]) : ta.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=color.new(fcolor, 80))

// Bar Color
barcolor(barcolor)

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

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

if closeAllCondition
    strategy.close("long")

Lebih lanjut

2019 FMZ - Semua hak dilindungi