Chiến lược đảo ngược Dual Track
ChaoZhang
Tổng quan
Chiến lược đảo ngược theo dõi hai đường là chiến lược giao dịch đảo ngược kết hợp các chỉ số động lực của vùng Brin, Keltner và kênh Keltner. Chiến lược này sử dụng phán đoán tổng hợp của vùng Brin và kênh Keltner để xác định thời điểm giá đi vào khu vực nén; đồng thời kết hợp các chỉ số động lực để đánh giá tín hiệu đảo ngược giá, tạo thành tín hiệu giao dịch vào và ra.
Nguyên tắc chiến lược
Tính toán đường ray trung tâm, đường ray trên và đường ray dưới trong băng tần Brin
- Đường sắt trung tâm sử dụng SMA gần
- Đường cuộn lên xuống là đường cuộn giữa cộng trừ một số nhân có thể điều chỉnh khác biệt chuẩn
Tính trung tâm, trên và dưới đường ray trong Keltner Channel
- Đường sắt trung tâm sử dụng SMA gần
- Các đường ray trên và dưới là đường ray trung tâm cộng trừ ATR của một nhân điều chỉnh
Xác định xem vùng Brin nằm bên trong Keltner
- Brin được coi là đang bị nén khi đường lên của nó thấp hơn đường lên của Keltner và đường xuống của Brin cao hơn đường xuống của Keltner
- Thay vào đó, không nén.
Tính độ lệch regression tuyến tính của close với điểm trung tâm của vùng Brin và Keltner
- val > 0 cho biết close đang tăng, val < 0 cho biết close đang giảm
Tính biến đổi của ROC và EMA của close
- Xác định mức độ thay đổi đạt ngưỡng có thể điều chỉnh
- Nếu vượt ngưỡng, coi như đang trong xu hướng
Khi nén, làm thêm khi val > 0 và tỷ lệ thay đổi đạt ngưỡng
- Thay vào đó là làm trống.
Thiết lập điều kiện dừng, dừng
Lợi thế chiến lược
Kết hợp với hệ thống hai đường ray để xác định thời điểm đảo ngược, tăng độ chính xác
Tăng suy thoái tuyến tính và phán đoán tỷ lệ thay đổi, tránh tín hiệu đảo ngược giả
Cài đặt tham số có thể điều chỉnh linh hoạt, có thể được tối ưu hóa cho các giống khác nhau
Sử dụng chiến lược dừng lỗ để kiểm soát rủi ro giao dịch một lần
Dữ liệu phản hồi đầy đủ để chứng minh hiệu quả của chiến lược
Rủi ro chiến lược và giải pháp
Compressor đường hai không nhất thiết phải có hiệu quả đảo ngược
- Các tham số tối ưu hóa, điều kiện nén hai đường ray nghiêm ngặt
Một vụ tấn công giả tạo ra tín hiệu sai.
- Thêm định giá hồi quy tuyến tính, xác định hướng xu hướng
Cài đặt dừng lỗ quá thoải mái, thua lỗ quá lớn
- Tối ưu hóa điểm dừng lỗ, kiểm soát chặt chẽ lỗ đơn
Chu kỳ thử nghiệm Datenichinhalt
- Thêm nhiều chu kỳ thử nghiệm để xác minh hiệu quả lâu dài
Hướng tối ưu hóa chiến lược
Cài đặt tham số tối ưu hóa để phù hợp với nhiều giống hơn
Tăng điểm kháng cự cho phán đoán bằng máy học
Tăng tính xác thực đột phá kết hợp với sự thay đổi khối lượng giao dịch
Thêm phân tích theo giai đoạn thời gian để đánh giá xu hướng
Tối ưu hóa chiến lược dừng lỗ, theo dõi động
Tóm tắt
Chiến lược đảo ngược theo dõi hai làn đường nói chung là một chiến lược đảo ngược sử dụng các chỉ số như Keltner Channel và Brin. Chiến lược này có thể được tối ưu hóa theo các tham số, có thể thích ứng với các giống khác nhau và xác định tính xác thực của đột phá ở một mức độ nhất định. Tuy nhiên, giao dịch đảo ngược vẫn có một số rủi ro và cần kết hợp thêm các công nghệ như học máy để nâng cao độ chính xác phán đoán, do đó có thể có được lợi nhuận vượt trội ổn định hơn.
/*backtest
start: 2023-10-02 00:00:00
end: 2023-11-01 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
// Credit for the initial Squeeze Momentum code to LazyBear, rate of change code is from Kiasaki
strategy("Squeeze X BF 🚀", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.0)
/////////////// Time Frame ///////////////
testStartYear = input(2012, "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
/////////////// Squeeeeze ///////////////
length = input(20, title="BB Length")
mult = input(2.0,title="BB MultFactor")
lengthKC=input(22, title="KC Length")
multKC = input(1.5, title="KC MultFactor")
useTrueRange = input(true, title="Use TrueRange (KC)")
// Calculate BB
source = close
basis = sma(source, length)
dev = mult * stdev(source, length)
upperBB = basis + dev
lowerBB = basis - dev
// Calculate KC
ma = sma(source, lengthKC)
range = useTrueRange ? tr : (high - low)
rangema = sma(range, lengthKC)
upperKC = ma + rangema * multKC
lowerKC = ma - rangema * multKC
sqzOn = (lowerBB > lowerKC) and (upperBB < upperKC)
sqzOff = (lowerBB < lowerKC) and (upperBB > upperKC)
noSqz = (sqzOn == false) and (sqzOff == false)
val = linreg(source - avg(avg(highest(high, lengthKC), lowest(low, lengthKC)),sma(close,lengthKC)), lengthKC,0)
///////////// Rate Of Change /////////////
roclength = input(30, minval=1), pcntChange = input(7, 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 = val > 0 and isMoving()
short = val < 0 and isMoving()
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])
sl_inp = input(100.0, title='Stop Loss %') / 100
tp_inp = input(5000.0, title='Take Profit %') / 100
take_level_l = strategy.position_avg_price * (1 + tp_inp)
take_level_s = strategy.position_avg_price * (1 - tp_inp)
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
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("Long", strategy.long, when=long)
strategy.entry("Short", strategy.short, when=short)
strategy.exit("Long Ex", "Long", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
strategy.exit("Short Ex", "Short", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
bcolor = iff(val > 0, iff(val > nz(val[1]), color.lime, color.green), iff(val < nz(val[1]), color.red, color.maroon))
plot(val, color=bcolor, linewidth=4)
bgcolor(not isMoving() ? color.white : long ? color.lime : short ? color.red : na, transp=70)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=50)
hline(0, color = color.white)