Strategi pelacakan tren berdasarkan rata-rata pergerakan kuantitatif
ChaoZhang
Ringkasan
Strategi ini dilakukan dengan menghitung dua rata-rata bergerak berdasarkan volume transaksi dan menilai arah tren saat ini berdasarkan arah perbedaan mereka, kemudian melakukan posisi panjang atau posisi pendek. Strategi ini sederhana dan mudah digunakan, dan dapat secara efektif melacak tren pasar.
Prinsip Strategi
Hitung garis cepat dan lambat. Garis cepat adalah rata-rata bergerak kuantitatif berdasarkan periode garis cepat yang ditentukan oleh pengguna, dan garis lambat adalah rata-rata bergerak kuantitatif berdasarkan periode garis lambat.
Hitung perbedaan dua garis. Garis cepat dikurangi garis lambat untuk mendapatkan kurva perbedaan.
Pertimbangkan arah tren. Bila garis cepat melewati garis lambat, lakukan lebih banyak untuk sinyal bullish; Bila garis cepat melewati garis lambat di bawahnya untuk sinyal bearish, lakukan kosong.
Sinyal trading. Sinyal multi saat bullish; Sinyal kosong saat bearish.
Pengaturan Stop Loss. Posisi Stop Loss diatur dengan persentase Stop Loss tetap yang didefinisikan pengguna atau Stop Loss dinamis berdasarkan ATR.
Kondisi Keluar: Jika ada sinyal stop loss atau reversal saat memegang posisi, maka posisi akan keluar.
Analisis Keunggulan
Menggunakan indikator kuantitatif untuk mengidentifikasi tren, tidak mudah tertipu oleh terobosan palsu.
Garis cepat dan lambat menggabungkan filter kebisingan pasar untuk menghindari perdagangan yang sering.
Pengaturan Stop Loss mengontrol risiko kerugian secara efektif.
Strategi logisnya sederhana, jelas, dan mudah dimengerti.
Parameter dapat disesuaikan untuk memenuhi kebutuhan berbagai varietas dan periode waktu.
Analisis risiko
Pengaturan parameter yang tidak tepat dapat menyebabkan frekuensi perdagangan yang terlalu tinggi atau kehilangan tren.
Stop loss tetap mungkin terlalu mekanis dan tidak dapat beradaptasi dengan perubahan pasar.
Perubahan hubungan kuantitas-harga dapat mempengaruhi efek indikator kuantitatif.
Risiko 1 dapat ditemukan melalui optimasi parameter untuk menemukan kombinasi optimal.
Risiko 2 dapat menggunakan stop loss ATR dinamis sebagai pengganti stop loss tetap.
Risiko 3 memerlukan perhatian terhadap dampak perubahan volume transaksi pada strategi.
Arah optimasi
Uji berbagai kombinasi parameter garis cepat dan lambat.
Cobalah indikator lain seperti OBV, William, dll.
Meningkatkan stop loss berdasarkan volatilitas.
Evaluasi efek dari kombinasi dengan indikator lainnya.
Evaluasi efektifitas dalam berbagai jenis transaksi.
Meringkaskan
Strategi ini melacak tren melalui kombinasi garis cepat dan lambat dengan rata-rata kuantitatif, logika perdagangan sederhana dan jelas, parameter dapat disesuaikan secara optimal. Pengaturan stop loss membantu mengendalikan risiko.
/*backtest
start: 2023-08-18 00:00:00
end: 2023-09-17 00:00:00
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("EVWMA 6HR", overlay=false, 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)
// Credit to QuantNomad for the main idea behind this code
/////////////// Time Frame ///////////////
_1 = 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
///////////// EVWMA /////////////
_2 = input(false, "════════ EVMA ═══════")
fast_sum_length = input(5, title = "Fast Sum Length", type = input.integer)
slow_sum_length = input(11, title = "Slow Sum Length", type = input.integer)
fast_vol_period = sum(volume, fast_sum_length)
slow_vol_period = sum(volume, slow_sum_length)
fast_evwma = 0.0
fast_evwma := ((fast_vol_period - volume) * nz(fast_evwma[1], close) + volume * close) / (fast_vol_period)
slow_evwma = 0.0
slow_evwma := ((slow_vol_period - volume) * nz(slow_evwma[1], close) + volume * close) / (slow_vol_period)
diff = fast_evwma - slow_evwma
/////////////// Strategy ///////////////
long = fast_evwma > slow_evwma
short = fast_evwma < slow_evwma
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])
/////////////// Dynamic ATR Stop Losses ///////////////
_4 = input(false, "════════ Stop Loss ═══════")
SL_type = input("Fixed", options=["Fixed", "ATR Derived"], title="Stop Loss Type")
sl_inp = input(9.0, title='Fixed Stop Loss %') / 100
atrLkb = input(20, minval=1, title='ATR Stop Period')
atrMult = input(1.5, step=0.25, title='ATR Stop Multiplier')
atr1 = atr(atrLkb)
longStop1 = 0.0
longStop1 := short_signal ? na : long_signal ? close - (atr1 * atrMult) : longStop1[1]
shortStop1 = 0.0
shortStop1 := long_signal ? na : short_signal ? close + (atr1 * atrMult) : shortStop1[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
_5 = input(false, "══════ Longs or Shorts ═════")
useLongs = input(true, title="Use Longs")
useShorts = input(true, title="Use Shorts")
/////////////// Execution ///////////////
if testPeriod()
if useLongs
strategy.entry("L", strategy.long, when=long)
strategy.exit("L SL", "L", stop = SL_type == "Fixed" ? long_sl : longStop1, when=since_longEntry > -1)
if useShorts
strategy.exit("S SL", "S", stop = SL_type == "Fixed" ? short_sl : shortStop1, when=since_shortEntry > -1)
strategy.entry("S", strategy.short, when=short)
if not useShorts
strategy.close("L", when=short)
if not useLongs
strategy.close("S", when=long)
/////////////// Plotting ///////////////
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)
p1 = plot(diff, title = "Delta", color = long ? color.lime : short ? color.red : na, transp=0)
p2 = plot(0, color = color.white)
fill(p1, p2, color = long ? color.lime : short ? color.red : na, transp=60)