Strategi berbalik dua garis lurus
ChaoZhang
Ringkasan
Strategi Reversi Rata-rata Bergerak Ganda (bahasa Inggris: Dual Moving Average Reversion Strategy) adalah strategi perdagangan reversi jangka pendek yang khas. Strategi ini menggunakan dua set parameter yang berbeda untuk melakukan sinyal perdagangan dan mengambil keuntungan ketika tren terjadi.
Prinsip Strategi
Strategi ini menggunakan dua garis rata untuk menghasilkan sinyal perdagangan. Maopening garis rata pertama digunakan untuk menentukan arah tren, dan maclosing garis rata kedua digunakan untuk mengirimkan sinyal perdagangan.
Ketika maopening naik, berarti saat ini berada dalam fase tren naik; ketika maopening turun, berarti saat ini berada dalam fase tren turun. Maclosing dikalikan dengan faktor lebih besar dari 1, membuatnya lebih sensitif, dapat mengirimkan sinyal reversal lebih awal.
Secara khusus, ketika maopening naik dan maclosing turun melalui maopening, menunjukkan pembalikan tren, saat ini strategi akan membuka posisi short; ketika maopening turun dan maclosing melewati maopening, menunjukkan pembalikan tren, saat ini strategi akan membuka posisi lebih banyak.
Parameter dari strategi ini meliputi jenis garis rata-rata, panjang, sumber data, dan lain-lain, yang dapat disesuaikan dengan parameter ini untuk mendapatkan efek perdagangan yang lebih baik. Selain itu, strategi ini juga memiliki beberapa opsi yang dapat disesuaikan sesuai kebutuhan, seperti cara membuka posisi, cara menghentikan kerugian, dan lain-lain.
Analisis Keunggulan
Keuntungan dari strategi reversal dua garis rata antara lain:
Retracement kecil, cocok untuk trading short line. Penggunaan dua garis rata-rata cepat, dapat dengan cepat menangkap pembalikan tren jangka pendek, retracement kecil.
Implementasinya sederhana dan mudah dipelajari. Bentuk dua garis sejajar yang bersilang adalah sinyal perdagangan, sangat sederhana dan jelas.
Banyak parameter yang dapat disesuaikan, dapat dioptimalkan. Berisi parameter dan faktor dari dua garis rata-rata, dapat dioptimalkan untuk menemukan kombinasi parameter terbaik.
Terjadwal, cocok untuk perdagangan otomatis. Strategi logika sederhana dan jelas, frekuensi eksekusi tinggi, sangat cocok untuk pemrograman untuk mencapai perdagangan otomatis.
Risiko yang dapat dikontrol, dengan mekanisme stop loss. Stop loss bergerak atau stop loss numerik dapat diatur, dapat mengontrol kerugian tunggal.
Analisis risiko
Ada beberapa risiko dalam strategi perputaran dua garis lurus:
Sebuah persimpangan dua garis rata berada di belakang. Garis rata itu sendiri berada di belakang harga, dan tren mungkin telah berbalik untuk beberapa waktu ketika persimpangan terjadi.
Kecenderungan ini tidak selalu dapat bertahan lama, dan mungkin akan kembali lagi dalam waktu dekat, dan menyebabkan kecenderungan.
Penarikan masih ada. Penarikan yang tepat waktu dapat mengurangi kerugian tunggal, tetapi penarikan berturut-turut juga dapat menyebabkan penarikan yang lebih besar.
Risiko pengoptimalan data. Parameter pengoptimalan yang berlebihan, kinerja yang baik dalam data historis tetapi tidak efektif dalam real-time.
Solusi untuk mengatasi risiko meliputi:
Optimalkan parameter untuk menemukan setelan rata-rata yang responsif.
Hindari pengikat dalam kombinasi dengan indikator lain, seperti indikator harga kuantitatif, indikator volatilitas, dll.
Mengatur posisi stop loss untuk mengurangi probabilitas stop loss berkelanjutan.
Tes optimasi parameter multiset untuk menilai kekuatan parameter.
Arah optimasi
Strategi berbalik dua garis lurus dapat dioptimalkan dalam beberapa hal:
Uji berbagai jenis rata-rata untuk mencari rata-rata yang lebih responsif. Seperti Kama, ZLEMA, dll.
Optimalkan parameter garis rata untuk menemukan kombinasi panjang yang optimal. Biasanya, garis rata dengan periode yang lebih pendek lebih baik.
Uji berbagai sumber data, seperti harga close out, harga rata-rata, dan harga tipikal.
Menambahkan filter tren untuk menghindari sinyal reversal yang tidak sesuai.
Dihubungkan dengan indikator lain, seperti indikator harga kuantitatif MACD, OBV, dll.
Meningkatkan mekanisme manajemen risiko, seperti stop loss mobile, maksimum kerugian akun, dan sebagainya.
Optimalkan portofolio untuk mencari rasio alokasi aset yang optimal.
Menambahkan pengujian kekuatan parameter untuk menilai risiko parameter yang terlalu dioptimalkan.
Meringkaskan
Strategi berbalik dua baris adalah strategi garis pendek yang sederhana dan praktis yang cocok untuk menangkap pasar yang berbalik dalam waktu singkat. Strategi berbalik ini kecil, mudah dilakukan, sangat cocok untuk perdagangan kuantitatif. Namun, ada juga beberapa masalah, seperti risiko keterlambatan, kurung, dan lain-lain.
/*backtest
start: 2023-10-17 00:00:00
end: 2023-11-16 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=5
strategy(title = "hamster-bot MRS 2", overlay = true, default_qty_type = strategy.percent_of_equity, initial_capital = 100, default_qty_value = 100, pyramiding = 9, commission_value = 0.045, backtest_fill_limits_assumption = 1)
info_options = "Options"
on_close = input(false, title = "Entry on close", inline=info_options, group=info_options)
OFFS = input.int(0, minval = 0, maxval = 1, title = "| Offset View", inline=info_options, group=info_options)
trade_offset = input.int(0, minval = 0, maxval = 1, title = "Trade", inline=info_options, group=info_options)
use_kalman_filter = input.bool(false, title="Use Kalman filter", group=info_options)
//MA Opening
info_opening = "MA Opening"
maopeningtyp = input.string("SMA", title="Type", options=["SMA", "EMA", "TEMA", "DEMA", "ZLEMA", "WMA", "Hma", "Thma", "Ehma", "H", "L", "DMA"], title = "", inline=info_opening, group=info_opening)
maopeningsrc = input.source(ohlc4, title = "", inline=info_opening, group=info_opening)
maopeninglen = input.int(3, minval = 1, maxval = 200, title = "", inline=info_opening, group=info_opening)
//MA Closing
info_closing = "MA Closing"
maclosingtyp = input.string("SMA", title="Type", options=["SMA", "EMA", "TEMA", "DEMA", "ZLEMA", "WMA", "Hma", "Thma", "Ehma", "H", "L", "DMA"], title = "", inline=info_closing, group=info_closing)
maclosingsrc = input.source(ohlc4, title = "", inline=info_closing, group=info_closing)
maclosinglen = input.int(3, minval = 1, maxval = 200, title = "", inline=info_closing, group=info_closing)
maclosingmul = input.float(1, step = 0.005, title = "mul", inline=info_closing, group=info_closing)
long1on = input(true, title = "", inline = "long1")
long1shift = input.float(0.96, step = 0.005, title = "Long", inline = "long1")
long1lot = input.int(10, minval = 0, maxval = 10000, step = 10, title = "Lot 1", inline = "long1")
short1on = input(true, title = "", inline = "short1")
short1shift = input.float(1.04, step = 0.005, title = "short", inline = "short1")
short1lot = input.int(10, minval = 0, maxval = 10000, step = 10, title = "Lot 1", inline = "short1")
startTime = input(timestamp("01 Jan 2010 00:00 +0000"), "Start date", inline = "period")
finalTime = input(timestamp("31 Dec 2030 23:59 +0000"), "Final date", inline = "period")
HMA(_src, _length) => ta.wma(2 * ta.wma(_src, _length / 2) - ta.wma(_src, _length), math.round(math.sqrt(_length)))
EHMA(_src, _length) => ta.ema(2 * ta.ema(_src, _length / 2) - ta.ema(_src, _length), math.round(math.sqrt(_length)))
THMA(_src, _length) => ta.wma(ta.wma(_src,_length / 3) * 3 - ta.wma(_src, _length / 2) - ta.wma(_src, _length), _length)
tema(sec, length)=>
tema1= ta.ema(sec, length)
tema2= ta.ema(tema1, length)
tema3= ta.ema(tema2, length)
tema_r = 3*tema1-3*tema2+tema3
donchian(len) => math.avg(ta.lowest(len), ta.highest(len))
ATR_func(_src, _len)=>
atrLow = low - ta.atr(_len)
trailAtrLow = atrLow
trailAtrLow := na(trailAtrLow[1]) ? trailAtrLow : atrLow >= trailAtrLow[1] ? atrLow : trailAtrLow[1]
supportHit = _src <= trailAtrLow
trailAtrLow := supportHit ? atrLow : trailAtrLow
trailAtrLow
f_dema(src, len)=>
EMA1 = ta.ema(src, len)
EMA2 = ta.ema(EMA1, len)
DEMA = (2*EMA1)-EMA2
f_zlema(src, period) =>
lag = math.round((period - 1) / 2)
ema_data = src + (src - src[lag])
zl= ta.ema(ema_data, period)
f_kalman_filter(src) =>
float value1= na
float value2 = na
value1 := 0.2 * (src - src[1]) + 0.8 * nz(value1[1])
value2 := 0.1 * (ta.tr) + 0.8 * nz(value2[1])
lambda = math.abs(value1 / value2)
alpha = (-math.pow(lambda, 2) + math.sqrt(math.pow(lambda, 4) + 16 * math.pow(lambda, 2)))/8
value3 = float(na)
value3 := alpha * src + (1 - alpha) * nz(value3[1])
//SWITCH
ma_func(modeSwitch, src, len, use_k_f=true) =>
modeSwitch == "SMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.sma(src, len)) : ta.sma(src, len) :
modeSwitch == "RMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.rma(src, len)) : ta.rma(src, len) :
modeSwitch == "EMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.ema(src, len)) : ta.ema(src, len) :
modeSwitch == "TEMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(tema(src, len)) : tema(src, len):
modeSwitch == "DEMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(f_dema(src, len)) : f_dema(src, len):
modeSwitch == "ZLEMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(f_zlema(src, len)) : f_zlema(src, len):
modeSwitch == "WMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.wma(src, len)) : ta.wma(src, len):
modeSwitch == "VWMA" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.vwma(src, len)) : ta.vwma(src, len):
modeSwitch == "Hma" ? use_kalman_filter and use_k_f ? f_kalman_filter(HMA(src, len)) : HMA(src, len):
modeSwitch == "Ehma" ? use_kalman_filter and use_k_f ? f_kalman_filter(EHMA(src, len)) : EHMA(src, len):
modeSwitch == "Thma" ? use_kalman_filter and use_k_f ? f_kalman_filter(THMA(src, len/2)) : THMA(src, len/2):
modeSwitch == "ATR" ? use_kalman_filter and use_k_f ? f_kalman_filter(ATR_func(src, len)): ATR_func(src, len) :
modeSwitch == "L" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.lowest(len)): ta.lowest(len) :
modeSwitch == "H" ? use_kalman_filter and use_k_f ? f_kalman_filter(ta.highest(len)): ta.highest(len) :
modeSwitch == "DMA" ? donchian(len) : na
//Var
sum = 0.0
maopening = 0.0
maclosing = 0.0
os = maopeningsrc
cs = maclosingsrc
pos = strategy.position_size
p = 0.0
p := pos == 0 ? (strategy.equity / 100) / close : p[1]
truetime = true
loss = 0.0
maxloss = 0.0
equity = 0.0
//MA Opening
maopening := ma_func(maopeningtyp, maopeningsrc, maopeninglen)
//MA Closing
maclosing := ma_func(maclosingtyp, maclosingsrc, maclosinglen) * maclosingmul
long1 = long1on == false ? 0 : long1shift == 0 ? 0 : long1lot == 0 ? 0 : maopening == 0 ? 0 : maopening * long1shift
short1 = short1on == false ? 0 : short1shift == 0 ? 0 : short1lot == 0 ? 0 : maopening == 0 ? 0 : maopening * short1shift
//Colors
maopeningcol = maopening == 0 ? na : color.blue
maclosingcol = maclosing == 0 ? na : color.fuchsia
long1col = long1 == 0 ? na : color.green
short1col = short1 == 0 ? na : color.red
//Lines
plot(maopening, offset = OFFS, color = maopeningcol)
plot(maclosing, offset = OFFS, color = maclosingcol)
long1line = long1 == 0 ? close : long1
short1line = short1 == 0 ? close : short1
plot(long1line, offset = OFFS, color = long1col)
plot(short1line, offset = OFFS, color = short1col)
//Lots
lotlong1 = p * long1lot
lotshort1 = p * short1lot
//Entry
if maopening > 0 and maclosing > 0 and truetime
//Long
sum := 0
strategy.entry("L", strategy.long, lotlong1, limit = on_close ? na : long1, when = long1 > 0 and pos <= sum and (on_close ? close <= long1[trade_offset] : true))
sum := lotlong1
//Short
sum := 0
pos := -1 * pos
strategy.entry("S", strategy.short, lotshort1, limit = on_close ? na : short1, when = short1 > 0 and pos <= sum and (on_close ? close >= short1[trade_offset] : true))
sum := lotshort1
strategy.exit("Exit", na, limit = maclosing)
if time > finalTime
strategy.close_all()