Sumber dimuat naik... memuat...

Indikator Momentum Strategi Perdagangan Keputusan

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

Ringkasan

Strategi Perdagangan Keputusan Indikator Momentum adalah strategi mengikuti trend. Ia membina penunjuk momentum menggunakan purata bergerak eksponensial berganda dan menggabungkannya dengan penunjuk kadar perubahan harga untuk menjana isyarat perdagangan. Apabila penunjuk momentum naik, ia menjana isyarat panjang. Apabila penunjuk momentum turun, ia menjana isyarat pendek. Strategi ini sesuai untuk peniaga yang ingin mengesan trend jangka pertengahan di pasaran.

Prinsip Strategi

Strategi ini menggunakan pengayun Titik Keputusan berdasarkan purata bergerak eksponensial berganda untuk mengukur momentum. Pertama ia mengira kadar perubahan harga harian, kemudian menggunakan purata bergerak eksponensial berganda 31 hari dan 20 hari untuk meluruskan kadar perubahan harga secara berasingan. Akhirnya ia menggunakan purata bergerak meluruskan 9 hari untuk mengeluarkan isyarat perdagangan. Apabila garis pantas di atas garis perlahan, ia menunjukkan pasaran lembu. Apabila garis pantas di bawah garis perlahan, ia menunjukkan pasaran beruang.

Strategi ini juga memperkenalkan penunjuk kadar perubahan harga untuk mengelakkan isyarat yang salah di pasaran sampingan. Khususnya, ia mengira perubahan harga peratusan selama 30 hari yang lalu, dan menilai sama ada pasaran aktif melalui purata bergerak. Isyarat perdagangan hanya dikeluarkan apabila pasaran aktif.

Analisis Kelebihan

Strategi ini menggabungkan penunjuk momentum dan penunjuk kadar perubahan harga, yang dapat dengan berkesan mengenal pasti trend jangka menengah dan mengelakkan perdagangan yang kerap di pasaran yang tidak menentu. Berbanding dengan strategi trend mudah seperti purata bergerak, ia dapat mengurangkan kemungkinan perdagangan yang salah. Di samping itu, risiko dikawal dengan menetapkan titik stop loss untuk memotong kerugian dalam masa dan mengawal kerugian setiap perdagangan dengan berkesan.

Analisis Risiko

Strategi ini terutamanya bergantung pada perdagangan trend jangka menengah dan panjang, tidak dapat menangkap turun naik harga jangka pendek. Apabila terdapat pergerakan pasaran yang tajam, titik stop loss boleh dipecahkan, yang membawa kepada kerugian yang lebih besar. Di samping itu, tetapan parameter yang tidak sesuai juga boleh mempengaruhi strategi. Sebagai contoh, jika parameter purata bergerak eksponensial berganda ditetapkan terlalu pendek, kebarangkalian perdagangan yang salah akan meningkat.

Untuk mengelakkan risiko, titik stop loss boleh diselaraskan dengan sewajarnya untuk memperluaskan julat stop loss. Apabila pergerakan pasaran yang tajam berlaku, strategi boleh dimatikan sementara untuk mengelakkan kemungkinan stop loss terputus. Untuk penyesuaian parameter, pengujian belakang terperinci harus dilakukan untuk memilih parameter yang optimum.

Arahan pengoptimuman

Strategi ini boleh dioptimumkan dalam aspek berikut:

Tambah penapis lain seperti penunjuk turun naik untuk mengelakkan perdagangan semasa tempoh turun naik pasaran yang tajam.
Tambah model pembelajaran mesin untuk membantu penilaian arah trend dan kekuatan, yang boleh meningkatkan ketepatan isyarat.
Cuba indikator momentum yang berbeza seperti Indeks Kekuatan Relatif, Osilator Stochastic untuk mengoptimumkan masa masuk dan keluar.
Dalam perdagangan langsung, menyesuaikan parameter secara dinamik digabungkan dengan keadaan pasaran terkini untuk mengejar kombinasi parameter yang optimum.

Kesimpulan

Strategi Perdagangan Keputusan Indikator Momentum umumnya merupakan strategi trend jangka menengah dan panjang yang stabil. Ia secara berkesan mengenal pasti trend dan mengelakkan perdagangan yang salah dengan menggabungkan indikator momentum purata bergerak eksponensial ganda dan indikator kadar perubahan harga. Sementara itu, ia mengawal risiko dengan menetapkan titik stop loss. Jika parameter disesuaikan dengan betul dan hasil backtest baik, ia sesuai untuk pelabur jangka menengah dan panjang yang mengejar pulangan yang berlebihan.

/*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 lanjut

2019 FMZ - Semua hak dilindungi