Chiến lược đường trung bình động đột phá xoắn ốc hướng lên
ChaoZhang
Tổng quan
Chiến lược này kết hợp các chỉ số xoắn ốc và chỉ số tỷ lệ chênh lệch để tạo ra tín hiệu mua khi giá phá vỡ đường lên và đường trung bình. Đồng thời, khi giá phá vỡ đường xuống và đường trung bình, tạo ra tín hiệu bán. Chiến lược này sử dụng đường xoắn ốc để xác định xu hướng của giá và sử dụng chỉ số tỷ lệ chênh lệch để phát hiện năng lượng giá, tạo ra tín hiệu giao dịch dựa trên hai chỉ số được xác nhận đồng thời, do đó có tỷ lệ thắng tốt hơn.
Nguyên tắc chiến lược
Chiến lược này dựa trên hai chỉ số:
Kênh xoắn ốc (Spiral Channels): Tính toán đường đường xuống đường, dùng để xác định xu hướng của giá. Khi giá phá vỡ đường lên, giá sẽ tăng lên, khi phá vỡ đường xuống thì giảm xuống.
Chỉ số tỷ lệ chênh lệch ((ROC): Chẩn đoán liệu giá có đang tăng tốc hay không, được sử dụng để đánh giá động lực giá. ROC lớn hơn một giá trị tích cực cho thấy giá tăng tốc, nhỏ hơn một giá trị âm cho thấy giá giảm tốc.
Các tín hiệu mua được tạo ra khi các kênh xoắn ốc và các chỉ số chênh lệch phát ra nhiều tín hiệu cùng một lúc. Đó là, giá cả sẽ phá vỡ cùng một lúc và hiển thị các dấu hiệu tăng tốc lên.
Sự kết hợp như vậy có thể làm tăng độ tin cậy của tín hiệu và tránh giao dịch mù quáng khi không có xu hướng rõ ràng.
Lợi thế chiến lược
Kết hợp xu hướng giá cả và động lực, tín hiệu đáng tin cậy hơn, tỷ lệ thắng cao hơn.
Thông qua tối ưu hóa tham số, có thể điều chỉnh tần số giao dịch của chiến lược. Ví dụ: điều chỉnh tham số của chỉ số tỷ lệ chênh lệch, do đó kiểm soát độ nhạy cảm của việc mở vị trí.
Sử dụng dừng lỗ để kiểm soát tổn thất đơn. Các tham số có thể được tùy chỉnh.
Cơ chế tái nhập học có thể theo dõi xu hướng và nâng cao lợi nhuận hơn nữa.
Rủi ro chiến lược
Một số doanh nghiệp có thể sẽ bỏ lỡ một số cơ hội giao dịch, và lợi nhuận của họ sẽ bị hạn chế.
Chiến lược phá vỡ dễ bị mắc kẹt. Khi giá đảo ngược, có thể dẫn đến tổn thất lớn.
Thiết lập tham số không đúng có thể dẫn đến tín hiệu giao dịch quá thường xuyên hoặc thưa thớt.
Lãi suất dừng cố định không thể hoàn toàn tránh được sự ra đời của một khoản lỗ lớn.
Hướng tối ưu hóa chiến lược
Kiểm tra các tham số của chỉ số tỷ lệ chênh lệch để tìm ra sự kết hợp tham số tốt nhất.
Kiểm tra các mức độ dừng khác nhau, cân bằng tỷ lệ thua lỗ và tỷ lệ thắng.
Thêm các bộ lọc cho các chỉ số khác, chẳng hạn như chỉ số năng lượng, chỉ số rung động, để cải thiện chất lượng tín hiệu.
Thử nghiệm các thị trường khác nhau để tìm ra giống phù hợp nhất với chiến lược này.
Quản lý vị trí tối ưu hóa chiến lược, sử dụng vị trí khác nhau trong các tình huống thị trường khác nhau.
Tóm tắt
Chiến lược này kết hợp các kênh xoắn ốc và các chỉ số tỷ lệ chênh lệch để đánh giá xu hướng và động lực của giá cả, khả năng duy trì lợi nhuận thông qua nhập lại và tối ưu hóa tham số, đồng thời đảm bảo chất lượng tín hiệu giao dịch. Kiểm soát rủi ro dựa trên tỷ lệ dừng cố định có thể được tối ưu hóa hơn nữa. Nói chung, chiến lược này là một khung cơ bản cho giao dịch định lượng.
/*backtest
start: 2024-01-07 00:00:00
end: 2024-01-14 00:00:00
period: 45m
basePeriod: 5m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("SSL Chaikin BF 🚀", overlay=true, precision=2, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)
/////////////// Time Frame ///////////////
_0 = input(false, "════════ Test Period ═══════")
testStartYear = input(2017, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)
testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)
testPeriod() => true
/////////////// Chaikin MF ///////////////
_1 = input(false, "═══════ Chaikin MF ═══════")
length = input(20, minval=1, title = "Chaikin SMA Length")
upperThreshold = input(0.04, step=0.01, title="Upper Threshold")
lowerThreshold = input(0.02, step=0.01, title="Lower Threshold")
ad = close==high and close==low or high==low ? 0 : ((2*close-low-high)/(high-low))*volume
mf = sum(ad, length) / sum(volume, length)
/////////////// SSL Channels ///////////////
_2 = input(false, "═════════ SSL ══════════")
len1=input(title="SMA Length 1", defval=12)
len2=input(title="SMA Length 2", defval=13)
smaHigh = sma(high, len1)
smaLow = sma(low, len2)
Hlv = 0
Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? smaHigh : smaLow
sslUp = Hlv < 0 ? smaLow : smaHigh
///////////// Rate Of Change /////////////
_3 = input(false, "══════ Rate of Change ══════")
source = close
roclength = input(13, "ROC Length", minval=1)
pcntChange = input(4, "ROC % Change", minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Strategy ///////////////
long = sslUp > sslDown and isMoving() or crossover(mf, upperThreshold)
short = sslUp < sslDown and isMoving() or crossunder(mf, lowerThreshold)
last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
//////////////// Stop loss ///////////////
_4 = input(false, "════════ Stop Loss ═══════")
sl_inp = input(2.0, title='Stop Loss %') / 100
slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("L", strategy.long, when=long)
strategy.entry("S", strategy.short, when=short)
strategy.exit("L SL", "L", stop=long_sl, when=since_longEntry > 0)
strategy.exit("S SL", "S", stop=short_sl, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
p1 = plot(sslDown, linewidth = 1, color=color.red)
p2 = plot(sslUp, linewidth = 1, color=color.lime)
fill(p1, p2, color = sslDown < sslUp ? color.lime : color.red, transp=80)
bgcolor(isMoving() ? long ? color.green : short ? color.red : na : color.white, transp=80)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)
bgcolor(crossover(mf, upperThreshold) ? color.blue : crossunder(mf, lowerThreshold) ? color.orange : na, transp=30)