ianzeng123
2
fokus pada
319
Pengikut
Gambaran keseluruhan
Strategi ini adalah sistem perdagangan komprehensif yang menggabungkan penapis Gaussian Channel dan RSI acak. Peluang perdagangan ditentukan melalui perubahan arah dan kedudukan harga Gaussian Channel, yang digabungkan dengan isyarat overbought dan oversold RSI acak. Strategi ini menggunakan model matematik yang rumit untuk membina saluran penyesuaian yang dapat menyaring kebisingan pasaran dengan berkesan dan menangkap perubahan harga yang penting.
Prinsip Strategi
Logik teras strategi adalah berdasarkan komponen utama berikut:
- Pengiraan Saluran Gaus: Menggunakan Saringan Gaus multi-polar untuk memproses data harga HLC3 dan mencipta Saluran Adaptif. Mengoptimumkan kesan saringan melalui parameter beta dan alpha, dan secara pilihan mengurangkan keterlambatan.
- Penyesuaian lebar saluran: Sesuaikan lebar saluran secara dinamik berdasarkan gelombang sebenar (TR), menggunakan 1.414 sebagai pengganda lalai.
- Isyarat RSI rawak: Gabungan 14 kitaran RSI dan penunjuk rawak, menghasilkan isyarat di atas 80 atau di bawah 20
- Syarat kemasukan: Tiga syarat mesti dipenuhi secara serentak: Gaussian ke atas, harga menembusi landasan, dan isyarat pemicu RSI secara rawak.
- Logik Keluar: Apabila harga jatuh ke bawah saluran Gauss dan melangkaui kedudukan.
Kelebihan Strategik
- Kebolehpercayaan isyarat: mekanisme pengesahan pelbagai indikator meningkatkan kebolehpercayaan isyarat perdagangan.
- Keupayaan untuk menyesuaikan diri: Gauss Channel dapat menyesuaikan lebar saluran secara automatik mengikut turun naik pasaran.
- Penapisan bunyi bising: Penapisan Gauss berkesan mengurangkan kesan bunyi bising pasaran.
- Fleksibiliti yang tinggi: menyediakan pelbagai parameter yang boleh disesuaikan, termasuk kitaran laluan, bilangan titik kutub dan parameter RSI.
- Intuisi visual: Intuisi menunjukkan arah trend dan isyarat perdagangan dengan perubahan warna.
Risiko Strategik
- Sensitiviti parameter: jumlah titik Gaussian dan setup kitaran sampel mempunyai kesan yang besar terhadap prestasi strategi.
- Risiko ketinggalan: Walaupun terdapat pilihan untuk mengurangkan ketinggalan, indikator itu sendiri masih mempunyai ketinggalan.
- Risiko penembusan palsu: Isyarat penembusan palsu yang mungkin sering berlaku di pasaran horizontal.
- Kekurangan pengurusan dana: Versi semasa tidak mempunyai mekanisme pengurusan kedudukan terperinci.
Arah pengoptimuman strategi
- Pengiktirafan keadaan pasaran: Tambah indikator kekuatan trend, menyesuaikan parameter strategi dalam keadaan pasaran yang berbeza.
- Pengoptimuman parameter dinamik: Tetapan parameter saluran Gaussian disesuaikan secara automatik mengikut turun naik pasaran.
- Pengurusan kedudukan yang lebih baik: memperkenalkan sistem pengurusan kedudukan dinamik berdasarkan kadar turun naik.
- Peningkatan mekanisme keluar: meningkatkan stop loss bergerak dan sebahagian daripada mekanisme penutupan keuntungan.
- Optimasi bingkai masa: mengesahkan isyarat pada pelbagai bingkai masa, meningkatkan kestabilan perdagangan.
ringkaskan
Strategi ini membina sistem perdagangan yang mempunyai daya serasi yang kuat dengan menggabungkan penapis Gaussian Channel dan RSI acak. Dasar matematik Gaussian Channel menjamin kehalusan dan kebolehpercayaan isyarat, manakala gabungan RSI acak meningkatkan lagi ketepatan masa masuk. Kelebihan utama strategi ini adalah penapisan bunyi pasaran yang berkesan dan pengendalian trend yang tepat, tetapi juga memerlukan perhatian terhadap masalah pengoptimuman berangka dan pengurusan risiko.
Kod sumber strategi
/*backtest
start: 2024-02-22 00:00:00
end: 2025-02-19 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Binance","currency":"SOL_USDT"}]
*/
//@version=5
strategy(title="Gaussian Channel Strategy v3.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=0, fill_orders_on_standard_ohlc=true)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Filter Functions (Must be declared first)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
f_filt9x(_a, _s, _i) =>
var int _m2 = 0, var int _m3 = 0, var int _m4 = 0, var int _m5 = 0, var int _m6 = 0,
var int _m7 = 0, var int _m8 = 0, var int _m9 = 0, var float _f = .0
_x = 1 - _a
_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
_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)
f_pole(_a, _s, _i) =>
_f1 = f_filt9x(_a, _s, 1)
_f2 = _i >= 2 ? f_filt9x(_a, _s, 2) : 0.0
_f3 = _i >= 3 ? f_filt9x(_a, _s, 3) : 0.0
_f4 = _i >= 4 ? f_filt9x(_a, _s, 4) : 0.0
_f5 = _i >= 5 ? f_filt9x(_a, _s, 5) : 0.0
_f6 = _i >= 6 ? f_filt9x(_a, _s, 6) : 0.0
_f7 = _i >= 7 ? f_filt9x(_a, _s, 7) : 0.0
_f8 = _i >= 8 ? f_filt9x(_a, _s, 8) : 0.0
_f9 = _i == 9 ? f_filt9x(_a, _s, 9) : 0.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
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Channel
int poles = input.int(4, "Poles", 1, 9, group="Gaussian Channel")
int period = input.int(144, "Sampling Period", 2, group="Gaussian Channel")
float mult = input.float(1.414, "True Range Multiplier", group="Gaussian Channel")
bool reducedLag = input.bool(false, "Reduced Lag Mode", group="Gaussian Channel")
bool fastResponse = input.bool(false, "Fast Response Mode", group="Gaussian Channel")
// Stochastic RSI
smoothK = input.int(3, "K", 1, group="Stochastic RSI")
smoothD = input.int(3, "D", 1, group="Stochastic RSI")
lengthRSI = input.int(14, "RSI Length", 1, group="Stochastic RSI")
lengthStoch = input.int(14, "Stochastic Length", 1, group="Stochastic RSI")
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Calculations
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Channel
beta = (1 - math.cos(4*math.asin(1)/period)) / (math.pow(1.414, 2/poles) - 1)
alpha = -beta + math.sqrt(math.pow(beta, 2) + 2*beta)
lag = (period - 1)/(2*poles)
src = hlc3
srcData = reducedLag ? src + (src - src[lag]) : src
trData = reducedLag ? ta.tr + (ta.tr - ta.tr[lag]) : ta.tr
[filterMain, filter1] = f_pole(alpha, srcData, poles)
[filterTRMain, filterTR1] = f_pole(alpha, trData, poles)
finalFilter = fastResponse ? (filterMain + filter1)/2 : filterMain
finalTR = fastResponse ? (filterTRMain + filterTR1)/2 : filterTRMain
hband = finalFilter + finalTR * mult
lband = finalFilter - finalTR * mult
// Stochastic RSI
rsi = ta.rsi(close, lengthRSI)
k = ta.sma(ta.stoch(rsi, rsi, rsi, lengthStoch), smoothK)
d = ta.sma(k, smoothD)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Trading Logic
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
gaussianGreen = finalFilter > finalFilter[1]
priceAbove = close > hband
stochCondition = k > 80 or k < 20
longCondition = gaussianGreen and priceAbove and stochCondition
exitCondition = ta.crossunder(close, hband)
strategy.entry("Long", strategy.long, when=longCondition)
strategy.close("Long", when=exitCondition)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Visuals
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
filterColor = finalFilter > finalFilter[1] ? #0aff68 : #ff0a5a
plot(finalFilter, "Filter", filterColor, 2)
plot(hband, "High Band", filterColor)
plot(lband, "Low Band", filterColor)
fill(plot(hband), plot(lband), color.new(filterColor, 90), "Channel Fill")