Trend Mengikuti Strategi Pecah Momentum
ChaoZhang
Gambaran keseluruhan
Strategi terobosan momentum adalah strategi perdagangan kuantitatif yang mengikuti trend pasaran. Ia menangkap trend garis tengah pasaran dengan mengira indikator dinamik harga sejarah, menilai trend dan kekuatan pergerakan harga pasaran.
Prinsip Strategi
Strategi ini adalah berdasarkan pada indikator momentum. Indeks momentum adalah harga penutupan kitaran semasa yang dikurangkan dari harga penutupan sebelum kitaran N. Apabila harga penutupan satu baris K terkini lebih tinggi daripada kitaran N, momentum adalah positif, menunjukkan momentum naik; Apabila harga penutupan satu baris K terkini lebih rendah daripada kitaran N, momentum adalah negatif, menunjukkan momentum turun.
Strategi ini mulakan dengan mengira momentum 18 kitaran, iaitu harga penutupan semasa tolak harga penutupan sebelum 18 kitaran, untuk mendapatkan mom0 ⋅ dan kemudian mengira satu kitaran momentum mom0 untuk mendapatkan mom1 ⋅
Apabila mom0>0 dan mom1>0 menghasilkan isyarat melakukan banyak, ini menunjukkan bahawa harga naik dengan pesat; apabila mom0 dan mom1 menghasilkan isyarat melakukan jarak, ini menunjukkan bahawa harga turun dengan pesat.
Strategi akan merekodkan masa-masa terakhir untuk melakukan lebih banyak dan lebih sedikit isyarat, memegang kedudukan yang lebih banyak apabila masa lebih banyak isyarat lebih besar daripada masa isyarat, dan memegang kedudukan yang lebih sedikit apabila masa isyarat lebih besar daripada masa isyarat.
Analisis kelebihan
Strategi ini mempunyai kelebihan berikut:
Strategi ini jelas dan mudah difahami, sesuai untuk pemula dalam perdagangan kuantitatif.
Penunjuk momentum dapat menangkap trend dan kekuatan pasaran, dan trend garis panjang tengah mempunyai kadar kemenangan yang tinggi.
Penggunaan penapis dua kali ganda boleh menapis sebahagian daripada kerosakan yang disebabkan oleh penembusan palsu.
Setelah isyarat perdagangan dihasilkan, anda boleh menaikkan kedudukan untuk mewujudkan kedudukan trend, dan anda boleh mendapatkan keuntungan tambahan dari pergerakan trend.
Pengunduran kerugian yang tepat pada masanya dapat mengawal kerugian tunggal dan mengelakkan kerugian yang terlalu besar akibat pembalikan.
Analisis risiko
Strategi ini juga mempunyai risiko yang perlu diperhatikan:
Penyesuaian jangka pendek dalam perdagangan berbilang mata menyebabkan penarikan stop loss, tidak dapat menangkap perdagangan sepanjang kitaran.
Keadaan yang sering berlaku dalam keadaan yang bergolak, mudah meningkatkan yuran perdagangan dan kehilangan titik tergelincir. Keadaan penapisan boleh dilonggarkan dengan sewajarnya, mengurangkan kekerapan perdagangan.
Selepas pembalikan trend, kedudukan yang masih dipegang di arah asal menyebabkan kerugian meluas. Anda boleh menilai pembalikan trend dengan menggabungkan indikator trend.
Tetapan parameter yang tidak betul boleh menyebabkan isyarat perdagangan yang salah atau menghasilkan isyarat yang salah. Perlu menyesuaikan parameter untuk pasaran yang berbeza.
Arah pengoptimuman
Strategi ini boleh dioptimumkan dalam beberapa aspek:
Optimumkan parameter dinamik, kira panjang dinamik untuk kitaran yang berbeza dan penyesuaian pasaran, dan tingkatkan kualiti isyarat.
Tambah penapis untuk penunjuk lain seperti MACD, KD dan lain-lain untuk mengelakkan kehilangan akibat pembalikan trend.
Mengoptimumkan strategi hentian kerugian, meredakan hentian kerugian dengan sewajarnya dalam trend perdagangan; pasaran bukan trend mengetatkan hentian kerugian dengan sewajarnya.
Meningkatkan strategi pengurusan kedudukan, mengurangkan kedudukan dalam keadaan bukan trend; meningkatkan kedudukan dalam keadaan trend untuk mendapatkan lebih banyak keuntungan.
Mengoptimumkan parameter untuk pelbagai jenis, meningkatkan kesesuaian parameter.
Menambah algoritma pembelajaran mesin untuk mengoptimumkan parameter dinamik strategi.
ringkaskan
Strategi pemecahan momentum secara keseluruhan adalah strategi pemantauan trend yang mudah dan intuitif. Ia dapat menangkap trend garis panjang di pasaran dengan berkesan, dan memperoleh keuntungan yang lebih baik dalam keadaan trend. Ia juga memerlukan perhatian terhadap kawalan risiko, mengoptimumkan strategi menghentikan kerugian, dan membantu menilai trend dengan indikator lain. Dengan terus mengoptimumkan, strategi ini dapat dijadikan sistem perdagangan kuantitatif yang menguntungkan secara stabil.
/*backtest
start: 2023-10-15 00:00:00
end: 2023-11-14 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("Momentum BF 🚀", overlay=true, 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)
/////////////// Time Frame ///////////////
_0 = 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
///////////// Momentum /////////////
_1 = input(false, "═══════ Momentum ══════")
length = input(18)
price = close
momentum(seria, length) =>
mom = seria - seria[length]
mom
mom0 = momentum(price, length)
mom1 = momentum(mom0, 1)
/////////////// Strategy ///////////////
long = mom0 > 0 and mom1 > 0
short = mom0 < 0 and mom1 < 0
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])
/////////////// Stop Losses Long ///////////////
_5 = input(false, "═══════ Stop Loss L ══════")
SL_typel = input("Fixed", options=["Fixed", "ATR Derived"], title="Stop Loss Type")
sl_inpl = input(8.0, title='Fixed Stop Loss %') / 100
atrLkbl = input(20, minval=1, title='ATR Stop Period')
atrMultl = input(1.5, step=0.25, title='ATR Stop Multiplier')
atr1l = atr(atrLkbl)
longStop1l = 0.0
longStop1l := short_signal ? na : long_signal ? close - (atr1l * atrMultl) : longStop1l[1]
slLongl = in_long_signal ? strategy.position_avg_price * (1 - sl_inpl) : na
long_sll = in_long_signal ? slLongl : na
/////////////// Stop Losses Short ///////////////
_6 = input(false, "═══════ Stop Loss S ══════")
SL_types = input("Fixed", options=["Fixed", "ATR Derived"], title="Stop Loss Type")
sl_inps = input(7.0, title='Fixed Stop Loss %') / 100
atrLkbs = input(20, minval=1, title='ATR Stop Period')
atrMults = input(1.5, step=0.25, title='ATR Stop Multiplier')
atr1s = atr(atrLkbs)
shortStop1s = 0.0
shortStop1s := long_signal ? na : short_signal ? close + (atr1s * atrMults) : shortStop1s[1]
slShorts = strategy.position_avg_price * (1 + sl_inps)
short_sls = in_short_signal ? slShorts : na
_7 = 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_typel == "Fixed" ? long_sll : longStop1l, when=since_longEntry > 0)
if useShorts
strategy.exit("S SL", "S", stop = SL_types == "Fixed" ? short_sls : shortStop1s, when=since_shortEntry > 0)
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=40)
p0 = plot(close)
p1 = plot(strategy.position_size <= 0 ? na : SL_typel == "Fixed" ? long_sll : longStop1l, title="Long Stop Loss", color=color.yellow, style=plot.style_linebr, linewidth=2)
p2 = plot(strategy.position_size >= 0 ? na : SL_types == "Fixed" ? short_sls : shortStop1s, title="Short Stop Loss", color=color.orange, style=plot.style_linebr, linewidth=2)
p3 = plot(strategy.position_size <= 0 ? na : strategy.position_avg_price, style=plot.style_linebr, title="Long Entry", color=color.green, linewidth=2)
p4 = plot(strategy.position_size >= 0 ? na : strategy.position_avg_price, style=plot.style_linebr, title="Short Entry", color=color.red, linewidth=2)
fill(p0, p3, color = color.lime, transp=60)
fill(p0, p4, color = color.red, transp=60)