동적 RSI 오시레이터 다항식 적정 지표 트렌드 양적 거래 전략
저자:차오장, 날짜: 2024-12-11 15:32:23태그:RSIDRSIQREMARMSEMSE
이 전략은 RSI 동적 오시일레이터를 기반으로 한 양적 거래 시스템이다. RSI 지표에 대한 다항식 적합성 및 시간 시리즈 분석을 수행함으로써 시장 동력을 파악하기 위해 RSI의 변화율을 계산합니다. 전략은 신호 처리를 위해 QR 분해와 같은 고급 수학적 방법을 사용하고 거래 결정을 위해 이동 평균 시스템과 결합합니다.
전략 원칙
이 전략의 핵심은 델타-RSI 오시레이터이며, 다음 단계로 구현됩니다.
- 먼저 기본 데이터로 전통적인 RSI 지표를 계산
- RSI를 부드럽게하고 소음을 줄이기 위해 다항식 부착을 사용
- RSI의 변화율을 반영하는 델타-RSI를 얻기 위해 RSI의 시간 파생수를 계산합니다.
- 거래 신호를 생성하기 위해 델타-RSI와 이동 평균을 비교하십시오.
- 근 평균 제곱 오류 (RMSE) 를 사용하여 적합 품질을 평가하고 필터링합니다.
거래 신호는 세 가지 방법으로 생성될 수 있습니다.
- 제로 라인 교차: 델타-RSI가 음에서 양으로 변할 때 길고, 양에서 음으로 변할 때 짧습니다.
- 신호선 교차: 델타-RSI가 이동 평균 이상/하위를 교차할 때 긴/단
- 방향 변경: 델타-RSI가 부정적인 영역에서 상승하기 시작하면 길고, 긍정적 영역에서 떨어지기 시작하면 짧습니다.
전략적 장점
- 탄탄한 수학적 기초: 신호 처리를 위해 QR 분해와 같은 고급 수학적 방법을 사용합니다.
- 신호 평형화: 다항식 부착은 시장 소음을 효과적으로 필터링하고 신호 품질을 향상시킬 수 있습니다.
- 높은 유연성: 다양한 시장 조건에 적응하기 위해 여러 가지 신호 생성 방법과 매개 변수 선택을 제공합니다.
- 통제 가능한 위험: 더 신뢰할 수 있는 신호를 차단하기 위한 RMSE 필터링 메커니즘을 포함합니다.
- 계산 효율: 매트릭스 연산은 높은 실행 효율을 위해 최적화된 알고리즘을 사용합니다.
전략 위험
- 매개 변수 민감성: 여러 가지 주요 매개 변수가 신중하게 조정되어야 하며, 매개 변수 선택이 좋지 않아 전략 성과에 심각한 영향을 미칩니다.
- 지연: 신호 평형화는 약간의 지연을 도입하고 빠른 시장 움직임을 놓칠 수 있습니다.
- 가짜 브레이크: 변동 시장에서 잘못된 신호를 생성하여 거래 비용을 증가시킬 수 있습니다.
- 계산 복잡성: 많은 행렬 연산을 포함하고, 고주파 거래에서 성능 병목을 가질 수 있습니다.
- 오버피팅: 매개 변수를 최적화 할 때 역사적 데이터의 오버피팅을 피해야 합니다.
전략 최적화 방향
- 적응 매개 변수: 시장 변동성에 기초하여 RSI 기간과 적절한 순서를 동적으로 조정합니다.
- 여러 시간 프레임: 교차 검증을 위해 더 많은 시간 프레임에서 신호를 통합
- 변동성 필터링: 신호 필터링을 위해 ATR와 같은 변동성 지표를 추가합니다.
- 시장 분류: 다른 시장 상태 (트렌드/오스칠레이션) 에 대해 다른 신호 생성 규칙을 사용하십시오.
- 스톱 로스 최적화: 지원/저항 수준에 기반한 동적 스톱 같은 더 똑똑한 스톱 로스 메커니즘을 추가
요약
이것은 탄탄한 이론적 기초를 가진 완전한 양적 거래 전략이다. 신호 처리을위한 현대적인 수학적 방법과 결합한 RSI의 동적 특성의 분석을 통해 시장 추세를 효과적으로 파악 할 수 있습니다. 매개 변수 민감성과 계산 복잡성에 대한 몇 가지 문제가 있지만 적절한 매개 변수 선택과 최적화 개선으로 전략은 좋은 실용적 가치를 가지고 있습니다. 라이브 거래를 적용 할 때 위험 통제에주의를 기울이고 합리적인 위치 크기를 설정하고 전략 성과를 지속적으로 모니터링하는 것이 좋습니다.
/*backtest
start: 2024-11-10 00:00:00
end: 2024-12-09 08:00:00
period: 4h
basePeriod: 4h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © tbiktag
//
// Delta-RSI Oscillator Strategy
//
// A strategy that uses Delta-RSI Oscillator (© tbiktag) as a stand-alone indicator:
// https://www.tradingview.com/script/OXQVFTQD-Delta-RSI-Oscillator/
//
// Delta-RSI is a smoothed time derivative of the RSI, plotted as a histogram
// and serving as a momentum indicator.
//
// Input parameters:
// RSI Length: The timeframe of the RSI that serves as an input to D-RSI.
// Length: The length of the lookback frame used for local regression.
// Polynomial Order: The order of the local polynomial function used to interpolate the RSI.
// Signal Length: The length of a EMA of the D-RSI series that is used as a signal line.
// Trade signals are generated based on three optional conditions:
// - Zero-crossing: bullish when D-RSI crosses zero from negative to positive values (bearish otherwise)
// - Signal Line Crossing: bullish when D-RSI crosses from below to above the signal line (bearish otherwise)
// - Direction Change: bullish when D-RSI was negative and starts ascending (bearish otherwise)
//
// Since D-RSI oscillator is based on polynomial fitting of the RSI curve, there is also an option
// to filter trade signal by means of the root mean-square error of the fit (normalized by the sample average).
//
//@version=5
strategy(title='Delta-RSI Oscillator Strategy-QuangVersion', shorttitle='D-RSI-Q', overlay=true)
// ---Subroutines---
matrix_get(_A, _i, _j, _nrows) =>
// Get the value of the element of an implied 2d matrix
//input:
// _A :: array: pseudo 2d matrix _A = [[column_0],[column_1],...,[column_(n-1)]]
// _i :: integer: row number
// _j :: integer: column number
// _nrows :: integer: number of rows in the implied 2d matrix
array.get(_A, _i + _nrows * _j)
matrix_set(_A, _value, _i, _j, _nrows) =>
// Set a value to the element of an implied 2d matrix
//input:
// _A :: array, changed on output: pseudo 2d matrix _A = [[column_0],[column_1],...,[column_(n-1)]]
// _value :: float: the new value to be set
// _i :: integer: row number
// _j :: integer: column number
// _nrows :: integer: number of rows in the implied 2d matrix
array.set(_A, _i + _nrows * _j, _value)
transpose(_A, _nrows, _ncolumns) =>
// Transpose an implied 2d matrix
// input:
// _A :: array: pseudo 2d matrix _A = [[column_0],[column_1],...,[column_(n-1)]]
// _nrows :: integer: number of rows in _A
// _ncolumns :: integer: number of columns in _A
// output:
// _AT :: array: pseudo 2d matrix with implied dimensions: _ncolums x _nrows
var _AT = array.new_float(_nrows * _ncolumns, 0)
for i = 0 to _nrows - 1 by 1
for j = 0 to _ncolumns - 1 by 1
matrix_set(_AT, matrix_get(_A, i, j, _nrows), j, i, _ncolumns)
_AT
multiply(_A, _B, _nrowsA, _ncolumnsA, _ncolumnsB) =>
// Calculate scalar product of two matrices
// input:
// _A :: array: pseudo 2d matrix
// _B :: array: pseudo 2d matrix
// _nrowsA :: integer: number of rows in _A
// _ncolumnsA :: integer: number of columns in _A
// _ncolumnsB :: integer: number of columns in _B
// output:
// _C:: array: pseudo 2d matrix with implied dimensions _nrowsA x _ncolumnsB
var _C = array.new_float(_nrowsA * _ncolumnsB, 0)
int _nrowsB = _ncolumnsA
float elementC = 0.0
for i = 0 to _nrowsA - 1 by 1
for j = 0 to _ncolumnsB - 1 by 1
elementC := 0
for k = 0 to _ncolumnsA - 1 by 1
elementC += matrix_get(_A, i, k, _nrowsA) * matrix_get(_B, k, j, _nrowsB)
elementC
matrix_set(_C, elementC, i, j, _nrowsA)
_C
vnorm(_X, _n) =>
//Square norm of vector _X with size _n
float _norm = 0.0
for i = 0 to _n - 1 by 1
_norm += math.pow(array.get(_X, i), 2)
_norm
math.sqrt(_norm)
qr_diag(_A, _nrows, _ncolumns) =>
//QR Decomposition with Modified Gram-Schmidt Algorithm (Column-Oriented)
// input:
// _A :: array: pseudo 2d matrix _A = [[column_0],[column_1],...,[column_(n-1)]]
// _nrows :: integer: number of rows in _A
// _ncolumns :: integer: number of columns in _A
// output:
// _Q: unitary matrix, implied dimenstions _nrows x _ncolumns
// _R: upper triangular matrix, implied dimansions _ncolumns x _ncolumns
var _Q = array.new_float(_nrows * _ncolumns, 0)
var _R = array.new_float(_ncolumns * _ncolumns, 0)
var _a = array.new_float(_nrows, 0)
var _q = array.new_float(_nrows, 0)
float _r = 0.0
float _aux = 0.0
//get first column of _A and its norm:
for i = 0 to _nrows - 1 by 1
array.set(_a, i, matrix_get(_A, i, 0, _nrows))
_r := vnorm(_a, _nrows)
//assign first diagonal element of R and first column of Q
matrix_set(_R, _r, 0, 0, _ncolumns)
for i = 0 to _nrows - 1 by 1
matrix_set(_Q, array.get(_a, i) / _r, i, 0, _nrows)
if _ncolumns != 1
//repeat for the rest of the columns
for k = 1 to _ncolumns - 1 by 1
for i = 0 to _nrows - 1 by 1
array.set(_a, i, matrix_get(_A, i, k, _nrows))
for j = 0 to k - 1 by 1
//get R_jk as scalar product of Q_j column and A_k column:
_r := 0
for i = 0 to _nrows - 1 by 1
_r += matrix_get(_Q, i, j, _nrows) * array.get(_a, i)
_r
matrix_set(_R, _r, j, k, _ncolumns)
//update vector _a
for i = 0 to _nrows - 1 by 1
_aux := array.get(_a, i) - _r * matrix_get(_Q, i, j, _nrows)
array.set(_a, i, _aux)
//get diagonal R_kk and Q_k column
_r := vnorm(_a, _nrows)
matrix_set(_R, _r, k, k, _ncolumns)
for i = 0 to _nrows - 1 by 1
matrix_set(_Q, array.get(_a, i) / _r, i, k, _nrows)
[_Q, _R]
pinv(_A, _nrows, _ncolumns) =>
//Pseudoinverse of matrix _A calculated using QR decomposition
// Input:
// _A:: array: implied as a (_nrows x _ncolumns) matrix _A = [[column_0],[column_1],...,[column_(_ncolumns-1)]]
// Output:
// _Ainv:: array implied as a (_ncolumns x _nrows) matrix _A = [[row_0],[row_1],...,[row_(_nrows-1)]]
// ----
// First find the QR factorization of A: A = QR,
// where R is upper triangular matrix.
// Then _Ainv = R^-1*Q^T.
// ----
[_Q, _R] = qr_diag(_A, _nrows, _ncolumns)
_QT = transpose(_Q, _nrows, _ncolumns)
// Calculate Rinv:
var _Rinv = array.new_float(_ncolumns * _ncolumns, 0)
float _r = 0.0
matrix_set(_Rinv, 1 / matrix_get(_R, 0, 0, _ncolumns), 0, 0, _ncolumns)
if _ncolumns != 1
for j = 1 to _ncolumns - 1 by 1
for i = 0 to j - 1 by 1
_r := 0.0
for k = i to j - 1 by 1
_r += matrix_get(_Rinv, i, k, _ncolumns) * matrix_get(_R, k, j, _ncolumns)
_r
matrix_set(_Rinv, _r, i, j, _ncolumns)
for k = 0 to j - 1 by 1
matrix_set(_Rinv, -matrix_get(_Rinv, k, j, _ncolumns) / matrix_get(_R, j, j, _ncolumns), k, j, _ncolumns)
matrix_set(_Rinv, 1 / matrix_get(_R, j, j, _ncolumns), j, j, _ncolumns)
//
_Ainv = multiply(_Rinv, _QT, _ncolumns, _ncolumns, _nrows)
_Ainv
norm_rmse(_x, _xhat) =>
// Root Mean Square Error normalized to the sample mean
// _x. :: array float, original data
// _xhat :: array float, model estimate
// output
// _nrmse:: float
float _nrmse = 0.0
if array.size(_x) != array.size(_xhat)
_nrmse := na
_nrmse
else
int _N = array.size(_x)
float _mse = 0.0
for i = 0 to _N - 1 by 1
_mse += math.pow(array.get(_x, i) - array.get(_xhat, i), 2) / _N
_mse
_xmean = array.sum(_x) / _N
_nrmse := math.sqrt(_mse) / _xmean
_nrmse
_nrmse
diff(_src, _window, _degree) =>
// Polynomial differentiator
// input:
// _src:: input series
// _window:: integer: wigth of the moving lookback window
// _degree:: integer: degree of fitting polynomial
// output:
// _diff :: series: time derivative
// _nrmse:: float: normalized root mean square error
//
// Vandermonde matrix with implied dimensions (window x degree+1)
// Linear form: J = [ [z]^0, [z]^1, ... [z]^degree], with z = [ (1-window)/2 to (window-1)/2 ]
var _J = array.new_float(_window * (_degree + 1), 0)
for i = 0 to _window - 1 by 1
for j = 0 to _degree by 1
matrix_set(_J, math.pow(i, j), i, j, _window)
// Vector of raw datapoints:
var _Y_raw = array.new_float(_window, na)
for j = 0 to _window - 1 by 1
array.set(_Y_raw, j, _src[_window - 1 - j])
// Calculate polynomial coefficients which minimize the loss function
_C = pinv(_J, _window, _degree + 1)
_a_coef = multiply(_C, _Y_raw, _degree + 1, _window, 1)
// For first derivative, approximate the last point (i.e. z=window-1) by
float _diff = 0.0
for i = 1 to _degree by 1
_diff += i * array.get(_a_coef, i) * math.pow(_window - 1, i - 1)
_diff
// Calculates data estimate (needed for rmse)
_Y_hat = multiply(_J, _a_coef, _window, _degree + 1, 1)
float _nrmse = norm_rmse(_Y_raw, _Y_hat)
[_diff, _nrmse]
/// --- main ---
degree = input.int(title='Polynomial Order', group='Model Parameters:', inline='linepar1', defval=2, minval=1)
rsi_l = input.int(title='RSI Length', group='Model Parameters:', inline='linepar1', defval=21, minval=1, tooltip='The period length of RSI that is used as input.')
window = input.int(title='Length ( > Order)', group='Model Parameters:', inline='linepar2', defval=21, minval=2)
signalLength = input.int(title='Signal Length', group='Model Parameters:', inline='linepar2', defval=9, tooltip='The signal line is a EMA of the D-RSI time series.')
islong = input.bool(title='Buy', group='Show Signals:', inline='lineent', defval=true)
isshort = input.bool(title='Sell', group='Show Signals:', inline='lineent', defval=true)
showendlabels = input.bool(title='Exit', group='Show Signals:', inline='lineent', defval=true)
buycond = input.string(title='Buy', group='Entry and Exit Conditions:', inline='linecond', defval='Zero-Crossing', options=['Zero-Crossing', 'Signal Line Crossing', 'Direction Change'])
sellcond = input.string(title='Sell', group='Entry and Exit Conditions:', inline='linecond', defval='Zero-Crossing', options=['Zero-Crossing', 'Signal Line Crossing', 'Direction Change'])
endcond = input.string(title='Exit', group='Entry and Exit Conditions:', inline='linecond', defval='Zero-Crossing', options=['Zero-Crossing', 'Signal Line Crossing', 'Direction Change'])
usenrmse = input.bool(title='', group='Filter by Means of Root-Mean-Square Error of RSI Fitting:', inline='linermse', defval=false)
rmse_thrs = input.float(title='RSI fitting Error Threshold, %', group='Filter by Means of Root-Mean-Square Error of RSI Fitting:', inline='linermse', defval=10, minval=0.0) / 100
src = ta.rsi(close, rsi_l)
[drsi, nrmse] = diff(src, window, degree)
signalline = ta.ema(drsi, signalLength)
// Conditions and filters
filter_rmse = usenrmse ? nrmse < rmse_thrs : true
dirchangeup = drsi > drsi[1] and drsi[1] < drsi[2] and drsi[1] < 0.0
dirchangedw = drsi < drsi[1] and drsi[1] > drsi[2] and drsi[1] > 0.0
crossup = ta.crossover(drsi, 0.0)
crossdw = ta.crossunder(drsi, 0.0)
crosssignalup = ta.crossover(drsi, signalline)
crosssignaldw = ta.crossunder(drsi, signalline)
//Signals
golong = (buycond == 'Direction Change' ? dirchangeup : buycond == 'Zero-Crossing' ? crossup : crosssignalup) and filter_rmse
goshort = (sellcond == 'Direction Change' ? dirchangedw : sellcond == 'Zero-Crossing' ? crossdw : crosssignaldw) and filter_rmse
endlong = (endcond == 'Direction Change' ? dirchangedw : endcond == 'Zero-Crossing' ? crossdw : crosssignaldw) and filter_rmse
endshort = (endcond == 'Direction Change' ? dirchangeup : endcond == 'Zero-Crossing' ? crossup : crosssignalup) and filter_rmse
plotshape(golong and islong ? low : na, location=location.belowbar, style=shape.labelup, color=color.new(#2E7C13, 0), size=size.small, title='Buy')
plotshape(goshort and isshort ? high : na, location=location.abovebar, style=shape.labeldown, color=color.new(#BF217C, 0), size=size.small, title='Sell')
plotshape(showendlabels and endlong and islong ? high : na, location=location.abovebar, style=shape.xcross, color=color.new(#2E7C13, 0), size=size.tiny, title='Exit Long')
plotshape(showendlabels and endshort and isshort ? low : na, location=location.belowbar, style=shape.xcross, color=color.new(#BF217C, 0), size=size.tiny, title='Exit Short')
alertcondition(golong, title='Long Signal', message='D-RSI: Long Signal')
alertcondition(goshort, title='Short Signal', message='D-RSI: Short Signal')
alertcondition(endlong, title='Exit Long Signal', message='D-RSI: Exit Long')
alertcondition(endshort, title='Exit Short Signal', message='D-RSI: Exit Short')
strategy.entry('long', strategy.long, when=golong and islong)
strategy.entry('short', strategy.short, when=goshort and isshort)
strategy.close('long', when=endlong and islong)
strategy.close('short', when=endshort and isshort)
관련
- 향상된 볼링거 밴드 RSI 거래 전략
- EMA 상승적 크로스오버 전략
- 낮은 탐지기
- 포지션 스케일링이 가능한 다중 시간 프레임 RSI-EMA 모멘텀 거래 전략
- EMA 크로스오버 피보나치 역전 전략
- EMA, RSI, 부피 가격 추세, 포용 패턴
- RSI와 듀얼 EMA 크로스오버 신호 양적 전략
- 전략에 따른 다중 지표 트렌드
- EMA 크로스 전략, RSI 디버전스, 30분 트렌드 식별 및 가격 고갈
- ma & rsi - ogcheckers와 함께 암호화 선물 시간 스칼핑
더 많은
- 다중 지표 트렌드 수익 최적화 전략
- 프랙탈 브레이크업 모멘텀 거래 전략
데 모멘텀 오시레이터 기반의 적응적 평균 역전 거래 전략 - 거래 전략에 따른 MACD-Supertrend 이중 확인 트렌드
- 다기간의 슈퍼트렌드 동적 거래 전략
- 피보나치 리트레이싱 및 피보트 포인트 거래 전략과 함께 멀티 타임프레임 EMA
- 다중 시간 프레임 동적 스톱 로스 EMA-스프레시 거래 전략
- MACD 및 선형 회귀 이중 신호 지능형 거래 전략
- 거래 전략에 따른 멀티 EMA 트렌드
- 양적 거래 시스템을 따르는 다중 시간 프레임 평형 하킨 아시 트렌드
- 일일 범위 파업 단방향 거래 전략
- SMA-RSI-MACD 다중 지표 동적 한도 주문 거래 전략
- EMA/SMA 트렌드 추종 스윙 거래 전략 결합 된 볼륨 필터 및 비율 취득/손실 정지 시스템
- VWAP 표준 오차 평균 역전 거래 전략
- 동적 가격대 브레이크업 거래 전략 지원 및 저항 양적 시스템
- 다중 지표 트렌드 모멘텀 크로스오버 양적 전략
- 리스크-보상 타겟팅 전략과 함께 고급 동적 후속 정지
- 선진 단장 동적 트렌드 라인 브레이크 전략
- 볼링거 밴드 및 ATR를 기반으로 한 다단계 지능형 동적 트레일링 스톱 전략
- 동적 이중 EMA 크로스오버 전략