Sumber daya yang dimuat... Pemuatan...

Indikator Momentum Strategi Perdagangan Keputusan

Penulis:ChaoZhang, Tanggal: 2023-12-15 15:31:52
Tag:

Gambaran umum

Momentum Indicator Decision Trading Strategy adalah strategi mengikuti tren. Ini membangun indikator momentum menggunakan rata-rata bergerak eksponensial ganda dan menggabungkannya dengan indikator perubahan harga untuk menghasilkan sinyal perdagangan. Ketika indikator momentum naik, itu menghasilkan sinyal panjang. Ketika indikator momentum turun, itu menghasilkan sinyal pendek. Strategi ini cocok bagi pedagang yang ingin melacak tren jangka menengah di pasar.

Prinsip Strategi

Strategi ini menggunakan osilator titik keputusan berdasarkan rata-rata bergerak eksponensial ganda untuk mengukur momentum. Pertama-tama menghitung tingkat perubahan harga harian, kemudian menggunakan rata-rata bergerak eksponensial ganda 31 hari dan 20 hari untuk meratakan tingkat perubahan harga secara terpisah. Akhirnya, menggunakan rata-rata bergerak terhaluskan 9 hari untuk mengeluarkan sinyal perdagangan. Ketika garis cepat di atas garis lambat, itu menunjukkan pasar banteng. Ketika garis cepat di bawah garis lambat, itu menunjukkan pasar beruang.

Strategi ini juga memperkenalkan indikator tingkat perubahan harga untuk menghindari sinyal yang salah di pasar sampingan. Secara khusus, strategi ini menghitung persentase perubahan harga selama 30 hari terakhir, dan menilai apakah pasar aktif melalui rata-rata bergerak.

Analisis Keuntungan

Strategi ini menggabungkan indikator momentum dan indikator tingkat perubahan harga, yang dapat secara efektif mengidentifikasi tren jangka menengah dan menghindari perdagangan yang sering di pasar yang tidak stabil. Dibandingkan dengan tren sederhana mengikuti strategi seperti moving average, itu dapat sangat mengurangi kemungkinan perdagangan yang salah. Selain itu, risiko dikendalikan dengan menetapkan titik stop loss untuk memotong kerugian tepat waktu dan secara efektif mengendalikan kerugian per perdagangan.

Analisis Risiko

Strategi ini terutama bergantung pada perdagangan tren jangka menengah-panjang, tidak dapat menangkap fluktuasi harga jangka pendek. Ketika ada pergerakan pasar yang tajam, titik stop loss dapat rusak, yang menyebabkan kerugian yang lebih besar. Selain itu, pengaturan parameter yang tidak tepat juga dapat mempengaruhi strategi.

Untuk mencegah risiko, titik stop loss dapat disesuaikan dengan tepat untuk memperluas rentang stop loss. Ketika terjadi pergerakan pasar yang tajam, strategi dapat dimatikan sementara untuk menghindari kemungkinan stop loss yang rusak. Untuk penyesuaian parameter, backtesting rinci harus dilakukan untuk memilih parameter optimal.

Arahan Optimasi

Strategi dapat dioptimalkan dalam aspek berikut:

Tambahkan indikator penyaringan lainnya seperti indikator volatilitas untuk menghindari perdagangan selama periode fluktuasi pasar yang tajam.
Tambahkan model pembelajaran mesin untuk membantu penilaian arah tren dan kekuatan, yang dapat meningkatkan akurasi sinyal.
Cobalah indikator momentum yang berbeda seperti Relative Strength Index, Stochastic Oscillator untuk mengoptimalkan waktu masuk dan keluar.
Dalam perdagangan langsung, menyesuaikan parameter secara dinamis dikombinasikan dengan kondisi pasar terbaru untuk mengejar kombinasi parameter yang optimal.

Kesimpulan

Momentum Indicator Decision Trading Strategy umumnya merupakan strategi trend yang konsisten jangka menengah dan panjang. Secara efektif mengidentifikasi tren dan menghindari perdagangan yang salah dengan menggabungkan indikator momentum rata-rata bergerak eksponensial ganda dan indikator tingkat perubahan harga. Sementara itu, itu mengendalikan risiko dengan menetapkan titik stop loss. Jika parameter disetel dengan benar dan hasil backtest baik, itu cocok bagi investor jangka menengah dan panjang yang mengejar laba yang berlebihan. Tentu saja, pedagang masih perlu menyadari risiko yang dibawa oleh fluktuasi pasar yang tajam ke strategi.

/*backtest
start: 2022-12-08 00:00:00
end: 2023-11-10 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("Decision 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.075)

/////////////// Time Frame ///////////////
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

/////////////// Decision ///////////////
src = input(ohlc4, title="Source")
length1 = input(31, title="First Smoothing")
length2 = input(20, title="Second Smoothing")
siglength = input(9, title="Signal Smoothing")
fr = input(true, title="Fill Region")

calc_csf(src, length) => 
	sm = 2.0 / length
	csf = 0.0
	csf := (src - nz(csf[1])) * sm + nz(csf[1])
	csf
i = (src / nz(src[1], src)) * 100
pmol2 = calc_csf(i - 100, length1)
pmol = calc_csf(10 * pmol2, length2)
pmols = ema(pmol, siglength)
d = pmol - pmols
duml = plot(fr ? (d > 0 ? pmol : pmols) : na, style=plot.style_circles, color=color.yellow, linewidth=0, title="DummyL")

hc = d > 0 ? d > d[1] ? color.lime : color.green : d < d[1] ? color.red : color.orange

///////////// Rate Of Change ///////////// 
source = close
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 = d > 0 and isMoving() 
short = d < 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(2.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("L Ex", "Long", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
    strategy.exit("S Ex", "Short", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)

/////////////// Plotting ///////////////
sigl = plot(false ? na : pmols, title="PMO Signal", color=color.gray, linewidth=2, title="Signal")
mdl = plot(false ? na : pmol, title="PMO", color=color.black, linewidth=2, title="PMO")
fill(duml, sigl, color.green, transp=20, title="PosFill")
fill(duml, mdl, color.red, transp=20, title="NegFill")
bgcolor(isMoving() ? long ? color.lime : short ? color.red : na : color.white, transp=70)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=50)

Lebih banyak

2019 FMZ - Semua hak dilindungi