Sembilan Strategi Crossover Moving Average
ChaoZhang
Ringkasan
Strategi ini menggunakan dua set parameter yang berbeda untuk melakukan operasi silang dengan moving averages, berdasarkan arah tren yang ditentukan oleh sinyal silang, untuk membuka dan menutup posisi. Strategi ini memungkinkan pilihan dari 9 jenis moving average yang berbeda, termasuk moving average sederhana (SMA), moving average indeks (EMA), moving average berbobot (WMA), moving average ALMA, moving average nilai kuantitatif (VWMA), dan lain-lain.
Prinsip Strategi
Logika inti dari strategi ini adalah membandingkan nilai dari dua rata-rata bergerak dan menilai arah tren pasar berdasarkan persilangan dua rata-rata bergerak. Secara khusus, kami menetapkan dua rata-rata bergerak untuk garis cepat dan garis lambat. Ketika garis cepat melewati garis lambat, pasar dianggap masuk ke tren naik, melakukan over; Ketika garis cepat melewati garis lambat, pasar dianggap masuk ke tren turun, melakukan over.
Setelah memasuki posisi, keluar dari posisi jika harga menyentuh garis stop loss maka kerugian; keluar dari posisi jika harga menyentuh garis stop loss maka keuntungan mencapai ekspektasi. Dengan demikian, keuntungan dapat dikunci dan kerugian dapat dicegah.
Dari sudut pandang logika kode, strategi ini terdiri dari empat bagian utama:
Menghitung Moving Average. Menghitung Moving Average untuk Fastline dan Slowline berdasarkan jenis Moving Average yang dipilih pengguna.
Membuat sinyal perdagangan. Berdasarkan persilangan garis cepat dan lambat, menghasilkan sinyal over dan under.
Set Stop Loss Stop Stop. Berdasarkan harga masuk dan persentase Stop Loss Stop yang ditetapkan, harga Stop Loss Line dan Stop Loss Line dihitung secara real time.
Masuk dan keluar dari lapangan. Masuk berdasarkan sinyal over/under, keluar berdasarkan sinyal stop/stop loss.
Analisis Keunggulan
Keuntungan terbesar dari strategi ini adalah kebebasan untuk memilih berbagai jenis moving average. Berbagai jenis moving average memiliki sensitivitas yang berbeda terhadap harga, dan pengguna dapat memilih moving average yang sesuai sesuai dengan kebutuhan mereka sendiri. Selain itu, Anda dapat menyesuaikan durasi panjang moving average untuk mengoptimalkan dimensi waktu.
Kelebihan lainnya adalah adanya mekanisme stop loss. Ini dapat secara efektif mencegah kerugian untuk berkembang lebih jauh, sementara juga mengunci keuntungan. Secara keseluruhan, strategi ini lebih fleksibel dan dapat disesuaikan dengan kebutuhan pengguna yang berbeda.
Analisis risiko
Risiko utama dari strategi ini adalah bahwa moving average memiliki keterlambatan. Ketika harga tiba-tiba mengalami fluktuasi besar, moving average tidak dapat merespons secara tepat waktu, yang dapat menyebabkan kehilangan waktu masuk atau keluar yang optimal.
Risiko lain adalah pengaturan posisi stop loss. Jika setelan terlalu kecil, mungkin akan di-arbitrage; Jika terlalu besar, mudah menyebabkan keuntungan tidak terkunci pada waktu yang tepat. Jadi dalam real-time harus mengoptimalkan parameter stop loss sesuai dengan kondisi pasar.
Secara umum, strategi ini bergantung pada arah tren dari rata-rata bergerak, sehingga efeknya akan dikurangkan jika ada peristiwa mendadak yang menyebabkan fluktuasi harga yang besar. Selain itu, pengaturan parameter juga akan berdampak besar pada keuntungan strategi.
Arah optimasi
Strategi ini dapat dioptimalkan dalam beberapa hal:
Jenis rata-rata bergerak yang dioptimalkan. Pilih rata-rata bergerak yang lebih sesuai sesuai dengan situasi pasar yang berbeda dan jenis transaksi.
Parameter untuk mengoptimalkan moving averages. Mengatur durasi moving averages agar lebih sesuai dengan karakteristik pasar.
Tambahkan filter indikator lain. Anda dapat menambahkan indikator lain seperti MACD, RSI, dan lain-lain untuk menghindari perdagangan yang sering terjadi di pasar yang tidak tren.
Mengoptimalkan Stop Loss Stop Ratio. Menghitung parameter Stop Loss yang optimal berdasarkan data historis.
Menambahkan model pembelajaran mesin. Menggunakan algoritma seperti LSTM, hutan acak untuk memprediksi pergerakan harga, membantu menghasilkan sinyal perdagangan.
Menggunakan algoritma pelacakan stop. Membuat garis stop dapat bergerak seiring dengan pergerakan harga, mengurangi kemungkinan stop akan dipicu.
Meringkaskan
Strategi ini secara keseluruhan relatif sederhana, langsung, melalui penilaian silang arah tren, dan merupakan strategi mengikuti tren yang khas. Kelebihannya adalah sederhana dan mudah dipahami, fleksibilitas yang tinggi, dapat memilih sendiri jenis rata-rata bergerak dan parameter. Kelemahannya adalah reaksi yang lambat terhadap kejadian yang tidak terduga, ada beberapa keterlambatan. Secara keseluruhan, strategi ini cocok untuk investor yang mengejar keuntungan stabil jangka panjang.
/*backtest
start: 2022-12-26 00:00:00
end: 2024-01-01 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
strategy("Kozlod - Yet Another Moving Average Cross Strategy", shorttitle="kozlod_yamacs", overlay = true)
//
// author: Kozlod
// date: 2018-03-06
//
////////////
// INPUTS //
////////////
ma_type = input(title = "MA Type", defval = "SMA", options = ['SMA', 'EMA', 'WMA', 'ALMA', 'VWMA', 'HMA', 'LSMA', 'SMMA', 'DEMA'])
short_ma_len = input(title = "Short MA Length", defval = 5, minval = 1)
short_ma_src = input(title = "Short MA Source", defval = close)
long_ma_len = input(title = "Long MA Length", defval = 15, minval = 2)
long_ma_src = input(title = "Long MA Source", defval = close)
alma_offset = input(title = "ALMA Offset", type = float, defval = 0.85, step = 0.01, minval = 0, maxval = 1)
alma_sigma = input(title = "ALMA Sigma", type = float, defval = 6, step = 0.01)
lsma_offset = input(title = "LSMA Offset", defval = 0, step = 1)
sl_lev_perc = input(title = "SL Level % (0 - Off)", type = float, defval = 0, minval = 0, step = 0.01)
pt_lev_perc = input(title = "PT Level % (0 - Off)", type = float, defval = 0, minval = 0, step = 0.01)
// Set initial values to 0
short_ma = 0.0
long_ma = 0.0
// Simple Moving Average (SMA)
if ma_type == 'SMA'
short_ma := sma(short_ma_src, short_ma_len)
long_ma := sma(long_ma_src, long_ma_len)
// Exponential Moving Average (EMA)
if ma_type == 'EMA'
short_ma := ema(short_ma_src, short_ma_len)
long_ma := ema(long_ma_src, long_ma_len)
// Weighted Moving Average (WMA)
if ma_type == 'WMA'
short_ma := wma(short_ma_src, short_ma_len)
long_ma := wma(long_ma_src, long_ma_len)
// Arnaud Legoux Moving Average (ALMA)
if ma_type == 'ALMA'
short_ma := alma(short_ma_src, short_ma_len, alma_offset, alma_sigma)
long_ma := alma(long_ma_src, long_ma_len, alma_offset, alma_sigma)
// Hull Moving Average (HMA)
if ma_type == 'HMA'
short_ma := wma(2*wma(short_ma_src, short_ma_len/2)-wma(short_ma_src, short_ma_len), round(sqrt(short_ma_len)))
long_ma := wma(2*wma(long_ma_src, long_ma_len /2)-wma(long_ma_src, long_ma_len), round(sqrt(long_ma_len)))
// Volume-weighted Moving Average (VWMA)
if ma_type == 'VWMA'
short_ma := vwma(short_ma_src, short_ma_len)
long_ma := vwma(long_ma_src, long_ma_len)
// Least Square Moving Average (LSMA)
if ma_type == 'LSMA'
short_ma := linreg(short_ma_src, short_ma_len, lsma_offset)
long_ma := linreg(long_ma_src, long_ma_len, lsma_offset)
// Smoothed Moving Average (SMMA)
if ma_type == 'SMMA'
short_ma := na(short_ma[1]) ? sma(short_ma_src, short_ma_len) : (short_ma[1] * (short_ma_len - 1) + short_ma_src) / short_ma_len
long_ma := na(long_ma[1]) ? sma(long_ma_src, long_ma_len) : (long_ma[1] * (long_ma_len - 1) + long_ma_src) / long_ma_len
// Double Exponential Moving Average (DEMA)
if ma_type == 'DEMA'
e1_short = ema(short_ma_src, short_ma_len)
e1_long = ema(long_ma_src, long_ma_len)
short_ma := 2 * e1_short - ema(e1_short, short_ma_len)
long_ma := 2 * e1_long - ema(e1_long, long_ma_len)
/////////////
// SIGNALS //
/////////////
long_signal = crossover( short_ma, long_ma)
short_signal = crossunder(short_ma, long_ma)
// Calculate PT/SL levels
// Initial values
last_signal = 0
prev_tr_price = 0.0
pt_level = 0.0
sl_level = 0.0
// Calculate previous trade price
prev_tr_price := long_signal[1] or short_signal[1] ? open : nz(last_signal[1]) != 0 ? prev_tr_price[1] : na
// Calculate SL/PT levels
pt_level := nz(last_signal[1]) == 1 ? prev_tr_price * (1 + pt_lev_perc / 100) : nz(last_signal[1]) == -1 ? prev_tr_price * (1 - pt_lev_perc / 100) : na
sl_level := nz(last_signal[1]) == 1 ? prev_tr_price * (1 - sl_lev_perc / 100) : nz(last_signal[1]) == -1 ? prev_tr_price * (1 + sl_lev_perc / 100) : na
// Calculate if price hit sl/pt
long_hit_pt = pt_lev_perc > 0 and nz(last_signal[1]) == 1 and close >= pt_level
long_hit_sl = sl_lev_perc > 0 and nz(last_signal[1]) == 1 and close <= sl_level
short_hit_pt = pt_lev_perc > 0 and nz(last_signal[1]) == -1 and close <= pt_level
short_hit_sl = sl_lev_perc > 0 and nz(last_signal[1]) == -1 and close >= sl_level
// What is last active trade?
last_signal := long_signal ? 1 : short_signal ? -1 : long_hit_pt or long_hit_sl or short_hit_pt or short_hit_sl ? 0 : nz(last_signal[1])
//////////////
// PLOTTING //
//////////////
// Plot MAs
plot(short_ma, color = red, linewidth = 2)
plot(long_ma, color = green, linewidth = 2)
// Plot Levels
plotshape(prev_tr_price, style = shape.cross, color = gray, location = location.absolute, size = size.small)
plotshape(sl_lev_perc > 0 ? sl_level : na, style = shape.cross, color = red, location = location.absolute, size = size.small)
plotshape(pt_lev_perc > 0 ? pt_level : na, style = shape.cross, color = green, location = location.absolute, size = size.small)
//////////////
// STRATEGY //
//////////////
strategy.entry("long", true, when = long_signal)
strategy.entry("short", false, when = short_signal)
strategy.close("long", when = long_hit_pt or long_hit_sl)
strategy.close("short", when = short_hit_pt or short_hit_sl)