ianzeng123
개요
이 전략은 고스 채널 필터와 임의의 RSI 지표가 결합된 통합 거래 시스템이다. 고스 채널의 방향 변화와 가격 위치, 임의의 RSI의 오버 바이 오버 셀 신호와 결합하여 거래 기회를 결정한다. 이 전략은 복잡한 수학 모델을 사용하여 적응 채널을 구축하여 시장 소음을 효과적으로 필터링하고 중요한 가격 변화를 포착한다.
전략 원칙
전략의 핵심 논리는 다음과 같은 핵심 구성 요소를 기반으로 합니다.
- 고스 통로 계산: 다도 고스 필러를 사용하여 HLC3 가격 데이터를 처리하여 적응 통로를 만듭니다. 베타 및 알파 파라미터를 통해 필러 효과를 최적화하고, 선택적으로 지연을 줄일 수 있습니다.
- 통로 폭 조정: 실제 파도 (TR) 를 기반으로 통로 폭을 동적으로 조정하고, 1.414을 기본 계수로 사용합니다.
- 무작위 RSI 신호: 14주기 RSI와 무작위 지표가 결합되어 80 이상 또는 20 이하의 신호를 생성한다.
- 입시 조건: 고스 통로 상향, 가격 돌파 경로, 무작위 RSI 트리거 신호의 3가지 조건을 동시에 충족해야 한다.
- 출구 논리: 가격이 고스 통로 (Gauss Channel) 상대로 떨어질 때 평점.
전략적 이점
- 신호 신뢰성: 다중 지표 확인 메커니즘은 거래 신호의 신뢰성을 크게 향상시킵니다.
- 자기 적응력: 고스 통로는 시장의 변동에 따라 통로 폭을 자동으로 조정할 수 있다.
- 노이즈 필터: 고스 필터는 시장의 노이즈 영향을 효과적으로 감소시킵니다.
- 높은 유연성: 통로 주기, 극점 수, RSI 파라미터 등과 같은 여러 조정 가능한 파라미터를 제공합니다.
- 시각적 직관: 색깔의 변화를 통해 트렌드 방향과 거래 신호를 직관적으로 표시한다.
전략적 위험
- 매개 변수 민감성: 고스 채널의 극수 및 샘플링 사이클 설정이 정책 성능에 큰 영향을 미칩니다.
- 지연 위험: 지연을 줄이는 옵션이 제공되었지만 지표 자체는 다소 지연적입니다.
- 가짜 브레이크 위험: 가로판 시장에서 빈번한 가짜 브레이크 신호가 발생할 수 있다.
- 자금 관리 부족: 현재 버전에는 상세한 포지션 관리 메커니즘이 없습니다.
전략 최적화 방향
- 시장 환경 식별: 트렌드 강도 지표를 추가하여 다른 시장 환경에서 전략 매개 변수를 조정합니다.
- 동적 파라미터 최적화: 시장의 변동성에 따라 고스 채널의 파라미터 설정을 자동으로 조정한다.
- 포지션 관리 개선: 변동율에 기반한 동적 포지션 관리 시스템을 도입했다.
- 출전 메커니즘 강화: 이동 중지 및 일부 수익 결제 메커니즘을 증가시킵니다.
- 시간 프레임 최적화: 여러 시간 프레임에서 신호를 검증하여 거래 안정성을 향상시킵니다.
요약하다
이 전략은 고스 채널 필터와 무작위 RSI 지표를 결합하여 강력한 적응력을 갖춘 거래 시스템을 구축합니다. 고스 채널의 수학적 기반은 신호의 부드러움과 신뢰성을 보장하며, 무작위 RSI의 조합은 진입 시기의 정확성을 더욱 향상시킵니다. 전략의 주요 장점은 시장 소음을 효과적으로 필터링하고 동향을 정확하게 파악하는 데 있습니다.
전략 소스 코드
/*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")