ianzeng123
2
tập trung vào
319
Người theo dõi
Tổng quan
Chiến lược này là một hệ thống giao dịch tổng hợp kết hợp các bộ lọc Gaussian channel và các chỉ số RSI ngẫu nhiên. Các cơ hội giao dịch được xác định thông qua sự thay đổi theo hướng và vị trí giá của Gaussian channel, kết hợp với tín hiệu mua quá mức của RSI ngẫu nhiên. Chiến lược sử dụng mô hình toán học phức tạp để xây dựng các kênh thích ứng, có thể lọc hiệu quả tiếng ồn thị trường và nắm bắt các biến động giá quan trọng.
Nguyên tắc chiến lược
Logic cốt lõi của chiến lược này dựa trên các thành phần chính sau:
- Tính toán kênh Gauss: Sử dụng bộ lọc Gauss đa cực để xử lý dữ liệu giá HLC3 và tạo ra một kênh thích ứng. Tối ưu hóa hiệu ứng lọc bằng các tham số beta và alpha và có thể giảm độ trễ.
- Điều chỉnh chiều rộng đường dẫn: Điều chỉnh chiều rộng đường dẫn động dựa trên tần số sóng thực ((TR), sử dụng 1.414 làm nhân mặc định.
- Tín hiệu RSI ngẫu nhiên: kết hợp 14 chu kỳ RSI và chỉ số ngẫu nhiên, tạo ra tín hiệu trên 80 hoặc dưới 20
- Điều kiện nhập cảnh: Phải đáp ứng cùng một lúc 3 điều kiện: đường Gauss lên, giá phá vỡ đường ray, và tín hiệu kích hoạt RSI ngẫu nhiên.
- Logic Exit: Khi giá giảm xuống đường Gaussian, giá sẽ bị dập tắt.
Lợi thế chiến lược
- Tín hiệu đáng tin cậy: Cơ chế xác nhận đa chỉ số đã cải thiện đáng kể độ tin cậy của tín hiệu giao dịch.
- Khả năng tự điều chỉnh: Gaussian Channel có thể tự động điều chỉnh chiều rộng theo biến động của thị trường.
- Bộ lọc tiếng ồn: Bộ lọc Gauss có hiệu quả trong việc giảm ảnh hưởng của tiếng ồn thị trường.
- Tính linh hoạt cao: cung cấp nhiều tham số có thể điều chỉnh, bao gồm chu kỳ đường dẫn, số điểm cực và tham số RSI.
- Hình ảnh trực quan: hiển thị trực quan hướng xu hướng và tín hiệu giao dịch thông qua sự thay đổi màu sắc.
Rủi ro chiến lược
- Tính nhạy cảm của tham số: Số điểm cực và chu kỳ lấy mẫu của kênh Gaussian có ảnh hưởng lớn đến hiệu suất của chiến lược.
- Rủi ro bị tụt hậu: Mặc dù cung cấp các tùy chọn để giảm thiểu sự tụt hậu, nhưng chỉ số này vẫn có một mức độ tụt hậu.
- Rủi ro phá vỡ giả: Có thể xảy ra các tín hiệu phá vỡ giả thường xuyên trong thị trường ngang.
- Thiếu quản lý tài chính: Phiên bản hiện tại thiếu cơ chế quản lý vị trí chi tiết.
Hướng tối ưu hóa chiến lược
- Xác định môi trường thị trường: Thêm các chỉ số cường độ xu hướng, điều chỉnh các tham số chiến lược trong các môi trường thị trường khác nhau.
- Tối ưu hóa tham số động: Cài đặt tham số của Gaussian Channel được điều chỉnh tự động theo biến động của thị trường.
- Quản lý vị thế được cải thiện: Hệ thống quản lý vị thế động dựa trên tỷ lệ biến động được giới thiệu.
- Cơ chế xuất phát được tăng cường: tăng cơ chế dừng di chuyển và kết thúc một phần lợi nhuận.
- Tối ưu hóa khung thời gian: Xác thực tín hiệu trên nhiều khung thời gian, tăng sự ổn định giao dịch.
Tóm tắt
Chiến lược này xây dựng một hệ thống giao dịch có khả năng thích ứng mạnh mẽ bằng cách kết hợp bộ lọc Gaussian channel và chỉ số RSI ngẫu nhiên. Cơ sở toán học của Gaussian channel đảm bảo sự trơn tru và đáng tin cậy của tín hiệu, trong khi sự kết hợp của RSI ngẫu nhiên làm tăng thêm độ chính xác của thời gian nhập cảnh. Ưu điểm chính của chiến lược nằm ở việc lọc hiệu quả tiếng ồn thị trường và nắm bắt chính xác xu hướng, nhưng cũng cần chú ý đến các vấn đề tối ưu hóa số và quản lý rủi ro.
Mã nguồn chiến lược
/*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")