Strategi Mengikuti Tren Matriks Deviasi
ChaoZhang
Ringkasan
Strategi mengikuti tren matriks yang diisolasi adalah strategi perdagangan kuantitatif yang menggabungkan tren, diisolasi dan rata-rata. Strategi ini menggunakan indikator RSI ganda untuk menentukan arah tren pasar, dan dalam kombinasi dengan matriks rata-rata untuk mengatur sinyal masuk. Matriks rata-rata akan menyesuaikan skala posisi sesuai dengan tingkat pengisolasian harga. Secara keseluruhan, keuntungan dari strategi ini adalah bahwa menggunakan beberapa indikator untuk mengkonfirmasi sinyal perdagangan, dapat secara efektif mencegah terobosan palsu, sementara mekanisme matriks rata-rata dapat mengunci keuntungan yang lebih tinggi.
Prinsip Strategi
Strategi mengikuti tren matriks yang terpisah terdiri dari beberapa bagian utama:
- Tren penilaian RSI ganda
Menggunakan RSI cepat dan RSI lambat untuk menentukan arah tren pasar. Ketika RSI cepat terjadi overbought atau oversold, menggabungkan RSI lambat untuk menentukan arah tren.
- Matrix linear menghasilkan sinyal transaksi
Dengan mengatur satu set matriks rata-rata berdasarkan harga masuk, ketika harga menyentuh garis rata-rata tertentu, menyesuaikan posisi sesuai. Dengan demikian, Anda bisa mendapatkan lebih banyak keuntungan dalam tren.
- Transaksi dua arah
Default adalah transaksi dua arah. Anda dapat memilih hanya melakukan lebih banyak dan tidak melakukan lebih sedikit.
Logika transaksi adalah sebagai berikut:
Menggunakan RSI cepat untuk menilai pasar yang sedang overbought dan oversold.
Menggunakan RSI yang lambat untuk menentukan arah tren jangka panjang pasar.
Ketika RSI cepat terjadi overbought dan oversold, sementara RSI lambat menunjukkan trend reversal, berdasarkan penilaian RSI lambat lebih banyak ruang untuk melakukan posisi yang sesuai arah.
Setelah membangun gudang, mengatur satu set matriks rata-rata. Matriks rata-rata ini mengelilingi pengaturan harga masuk, dengan ukuran interval yang ditetapkan oleh persentase parameter ketebalan antara area matriks ketebalan.
Ketika harga menyentuh garis rata-rata matriks, perbaiki jumlah kepemilikan sesuai. Jika naik melewati garis rata-rata, Anda akan mendapatkan lebih banyak opsi; Jika turun, Anda akan kehilangan opsi kosong.
Bila ada perubahan besar dalam harga, posisi akan dikembalikan ke level awal.
Ini adalah logika perdagangan utama dari strategi ini. Dengan menggunakan rata-rata matriks, Anda dapat mengunci lebih banyak keuntungan dalam tren.
Keunggulan Strategis
Strategi mengikuti tren dari matriks yang terpisah memiliki beberapa keuntungan:
Sinyal penilaian RSI ganda lebih dapat diandalkan. RSI cepat menghindari false breakout, RSI lambat memastikan tren besar benar.
Matriks rata-rata mengikuti tren untuk mendapatkan keuntungan. Mengatur posisi sesuai dengan tingkat perbedaan harga, dapat terus menghasilkan keuntungan.
Mendukung perdagangan dua arah. Perdagangan dua arah default, atau hanya lebih banyak. Dapat beradaptasi dengan lebih banyak lingkungan pasar.
Reset posisi mekanisme pengendalian risiko. Reset posisi ketika harga terjadi penyesuaian yang jelas, dapat menghentikan kerugian.
Pengaturan parameter yang fleksibel. Pengguna dapat memilih kombinasi parameter yang optimal berdasarkan data sejarah, jenis transaksi, dll.
Struktur kode yang jelas. Tugas-tugas yang jelas dan mudah dipahami, dioptimalkan dan diperluas.
Secara keseluruhan, keuntungan terbesar dari strategi ini adalah memanfaatkan berbagai mekanisme untuk meningkatkan kualitas sinyal, mengejar keuntungan yang lebih tinggi sambil mengendalikan risiko. Ini adalah strategi perdagangan yang berimbang antara risiko dan keuntungan.
Risiko Strategis
Ada beberapa risiko yang terkait dengan strategi mengikuti tren matriks deviasi, yang terkonsentrasi pada beberapa poin berikut:
Bila RSI menilai risiko kegagalan. RSI sering mengeluarkan sinyal palsu ketika pasar berada dalam penyesuaian getaran. Ini membutuhkan momentum uji coba, penyesuaian parameter yang sesuai, atau penghentian perdagangan.
Matriks rata-rata metode tidak tepat risiko. Jika matriks parameter yang tidak tepat, posisi penyesuaian mungkin terlalu radikal, sehingga meningkatkan kerugian. Perlu hati-hati menguji parameter.
Terlalu banyak posisi memperbesar risiko. Penyesuaian posisi terlalu besar juga dapat menyebabkan kerugian meluas. Parameter posisi maksimum perlu diatur dengan hati-hati.
Risiko terbaliknya tren. Ketika tren terbalik, jika tidak segera menutup posisi, Anda akan menghadapi kerugian yang lebih besar. Ini perlu memperhatikan indikator tren dengan periode yang lebih panjang.
Kode optimisasi ruang terbatas risiko. Strategi ini sudah cukup matang dan ruang untuk terus optimasi terbatas. Jika ada perubahan besar dalam lingkungan pasar, logika perdagangan keseluruhan perlu dievaluasi ulang.
Evaluasi dan pengoptimalan strategi adalah kunci untuk mengurangi risiko ini. Pengaturan kombinasi parameter, pemantauan indikator siklus yang lebih panjang, dan lain-lain dapat menghindari risiko ini sampai batas tertentu.
Arah optimasi strategi
Ada ruang untuk optimasi lebih lanjut dari strategi yang mengikuti tren matriks perpindahan:
Optimalkan parameter RSI ganda. Anda dapat menguji lebih banyak kombinasi parameter dan memilih untuk menentukan nilai siklus RSI yang paling akurat.
Pengaturan rata-rata matriks yang dapat disesuaikan. Mengizinkan pengguna untuk mengatur parameter rata-rata matriks sesuai dengan varietas yang berbeda, sehingga lebih sesuai dengan karakteristik varietas tersebut.
Meningkatkan mekanisme stop loss. Misalnya, menetapkan garis rata-rata keluar dari pertandingan, dan berhenti ketika harga jatuh dari garis rata-rata tersebut.
Peningkatan aturan proporsi posisi. Lebih ilmiah dan masuk akal untuk menyesuaikan ukuran dan kecepatan posisi, untuk mencegah peningkatan posisi yang berlebihan.
Dalam kombinasi dengan indikator lain, indikator lain seperti MACD, KD dapat diperkenalkan untuk penilaian tambahan, meningkatkan akurasi sinyal.
Mengoptimalkan struktur kode. Terus meningkatkan skalabilitas, pemeliharaan, dan efektivitas kode.
Meringkaskan
Strategi mengikuti tren matriks yang terpisah adalah strategi perdagangan kuantitatif yang komprehensif dengan beberapa mekanisme. Ini terutama menggunakan arah RSI ganda untuk menentukan arah tren, dan matriks untuk melacak tren yang menguntungkan. Strategi ini dapat memberikan sinyal perdagangan yang lebih stabil dan efisien dibandingkan dengan strategi indikator tunggal.
/*backtest
start: 2023-01-01 00:00:00
end: 2023-10-14 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
strategy("The Matrix 7.0 Strategy", overlay=false)
//Matrix Settings
entry_size = input(title="Entry Size", defval = 1)
max_size = input(title="Max Size", defval = 10000)
matrix = input(title="Matrix Interval %", defval = 2)
matrix_price_overwrite = input(title="Matrix Overwrite $", defval = 0.0)
adjustment = input(title="Adjustment Size", defval = 1000)
trade_short = input(title="Trade Short", type=bool, defval = true)
//RSI Settings
periods = input(title="RSI Periods", defval = 14)
overbought_short = input(title="RSI Overbought", defval = 65)
oversold_short = input(title="RSI Oversold", defval = 30)
//RSI Trend Settings
resolution_long = input(title="Resolution Trend", defval = "D")
periods_long = input(title="RSI Trend Periods", defval = 14)
overbought_long = input(title="RSI Trend Overbought", defval = 64)
oversold_long = input(title="RSI Trend Oversold", defval = 30)
//Round Off to 2 decimals
round2(x) =>
a = x * 10 * 10
a := floor(a + 0.5)
a := a / 10 / 10
a
//RSI Function
RSI = rsi(close, periods)
//RSI Market Function
rsi_oversold = RSI < oversold_short
rsi_overbought = RSI > overbought_short
market_rsi = 0.0
market_rsi := if (rsi_oversold)
RSI - oversold_short
else
if (rsi_overbought)
RSI - overbought_short
else
0
//RSI Trend Function
rsi_long = request.security(syminfo.tickerid,resolution_long,rsi(close,periods_long))
trend_rsi_long = rsi_long < oversold_long
trend_rsi_short = rsi_long > overbought_long
trend_rsi = 0
trend_rsi := if (trend_rsi_short)
-1
else
if (trend_rsi_long)
1
else
trend_rsi[1]
// // Shorter time resolution to make "close" crosses give faster positives.
// short_resolution = security(tickerid, "1", close)
// quick = round2(short_resolution) //ROUND OFF TO 2 DECIMAL PLACES.
//Declare Other Variables
entry_price = 0.0
entry_price := nz(entry_price[1])
position_size = 0.0
position_size := nz(position_size[1])
last_traded_price = 0.0
last_traded_price := nz(last_traded_price[1])
matrix_price = 0.0
if matrix_price_overwrite > 0.0
matrix_price := matrix_price_overwrite
else
matrix_price := round2((matrix/100) * entry_price)
level = 0
level := nz(level[1])
level_price = entry_price
if not na(level_price[1])
level_price := level_price[1]
// Calculate Level
if close > level_price
level_change = floor((high - level_price)/matrix_price)
level := level + level_change
else
if close < level_price
level_change = ceil((low - level_price)/matrix_price)
level := level + level_change
// Calculate Level Price
level_price := (level * matrix_price) + entry_price
// Calculate Matrix Position
matrix_position = 0.0
if position_size > 0
matrix_position := ((-1 * level) * adjustment) + entry_size
else
if position_size < 0
matrix_position := ((-1 * level) * adjustment) - entry_size
//Trend Entry or Reversal Conditions
trend_reversal_up = trend_rsi == 1 and (trend_rsi[1] == -1 or trend_rsi == 0) and position_size <= 0
trend_reversal_down = trend_rsi == -1 and (trend_rsi[1] == 1 or trend_rsi == 0) and position_size >= 0 and trade_short == true
flatten_position = trend_rsi == -1 and (trend_rsi[1] == 1 or trend_rsi == 0) and position_size >= 0 and trade_short == false
//Reset Conditions
reset_long = (position_size > 0) and (close - entry_price > matrix_price) and (market_rsi < 0) and (position_size != entry_size)
reset_short = (position_size < 0) and (entry_price - close > matrix_price) and (market_rsi > 0) and (position_size != (-1 * entry_size))
//Adjustment Conditions
increase_long = (position_size > 0) and (matrix_position > position_size) and (market_rsi < 0) and (matrix_position <= max_size)
decrease_long = (position_size > 0) and (matrix_position < position_size) and (market_rsi > 0)
increase_short = (position_size < 0) and (matrix_position < position_size) and (market_rsi > 0) and (matrix_position >= (-1 * max_size))
decrease_short = (position_size < 0) and (matrix_position > position_size) and (market_rsi < 0)
//Transactions
//Trend Reversals
if trend_reversal_up
strategy.entry("OL", strategy.long, qty=entry_size)
position_size := entry_size
matrix_position := entry_size
level := 0
else
if trend_reversal_down
strategy.entry("OS", strategy.short, qty=entry_size)
position_size := -1 * entry_size
matrix_position := -1 * entry_size
level := 0
//Reset Positions
else
if reset_long
order = entry_size - position_size[1]
strategy.order("RL", strategy.long, qty=order)
position_size := entry_size
matrix_position := entry_size
level := 0
else
if reset_short
order = position_size[1] - (-1* entry_size)
strategy.order("RS", strategy.short, qty=order)
position_size := -1 * entry_size
matrix_position := -1 * entry_size
level := 0
//Position Adjustments
else
if increase_long
order = matrix_position - position_size[1]
strategy.order("IL", strategy.long, qty=order)
position_size := position_size[1] + order
else
if decrease_long
order = position_size[1] - matrix_position
strategy.order("DL", strategy.short, qty=order)
position_size := position_size[1] - order
else
if increase_short
order = position_size[1] - matrix_position
strategy.order("IS", strategy.short, qty=order)
position_size := position_size[1] - order
else
if decrease_short
order = matrix_position - position_size[1]
strategy.order("DS", strategy.long, qty=order)
position_size := position_size[1] + order
else
if flatten_position
strategy.close_all()
position_size := 0.0
matrix_position := 0.0
level := 0
//Grouped Actions
if trend_reversal_up or trend_reversal_down or reset_short or reset_long
entry_price := round2(close)
last_traded_price := round2(close)
if increase_long or decrease_long or increase_short or decrease_short
last_traded_price := round2(close)
// //RSI Trend & Adjustment Moments. (strategy)
p1 = plot(market_rsi, color = trend_rsi > 0 ? green : red, linewidth = 4, title='Market', transp =0)
p2 = plot(trend_rsi, color = trend_rsi > 0 ? green : red, linewidth = 4, title='Trend', transp = 0)
fill(p1,p2, color=trend_rsi > 0 ? green : red, transp=0)
p3 = plot((rsi_long - 50) *2, color = white, title="Trend Index")
fill(p2,p3, color=white)
hline((overbought_long -50) * 2)
hline((oversold_long -50) * 2)
//Position Plots (strategy)
plot(matrix_position / 100, title='Matrix', color=white, linewidth = 4)
plot(position_size / 100, title='Position', color=blue, linewidth = 4)
plot(strategy.position_size / 100, title='Strategy', color=orange, linewidth = 4)
// //Price Plots (study)
// plot(level_price, title="Matrix Level Price", linewidth=4)
// plot(last_traded_price, title="Last Traded Price", linewidth=2, color=orange)
// plot(entry_price + (4 * matrix_price), title='Adjustment 4', color=white, linewidth = 1)
// plot(entry_price + (3 * matrix_price), title='Adjustment 3', color=white, linewidth = 1)
// plot(entry_price + (2 * matrix_price), title='Adjustment 2', color=white, linewidth = 1)
// plot(entry_price + matrix_price, title='Adjustment 1', color=white, linewidth = 1)
// plot(entry_price, title='Entry Price', color=white, linewidth = 3)
// plot(entry_price - matrix_price, title='Adjustment -1', color=white, linewidth = 1)
// plot(entry_price - (2 * matrix_price), title='Adjustment -2', color=white, linewidth = 1)
// plot(entry_price - (3 * matrix_price), title='Adjustment -3', color=white, linewidth = 1)
// plot(entry_price - (4 * matrix_price), title='Adjustment -4', color=white, linewidth = 1)
// //Alerts (study only)
// alertcondition(trend_reversal_up, title='Trend Reversal Up', message='Market Oversold, Lets Buy')
// alertcondition(trend_reversal_down, title='Trend Reversal Down', message='Market Overbought, Lets Sell')
// alertcondition(reset_long, title='Reset Long', message='Higher Bottom, Lets Buy')
// alertcondition(reset_short, title='Reset Short', message='Lower Top, Lets Sell')
// alertcondition(increase_long, title='Increase Long', message='Price Dropped, Lets Buy')
// alertcondition(decrease_long, title='Decrease Long', message='Price Spiked, Lets Sell')
// alertcondition(increase_short, title='Increase Short', message='Price Spiked, Lets Sell')
// alertcondition(decrease_short, title='Decrease Short', message='Price Dropped, Lets Buy')
// //Grouped Conditions
// condition_buy = trend_reversal_up or increase_long or decrease_short or reset_long
// condition_sell = trend_reversal_down or decrease_long or increase_short or reset_short
// adjustment_matrix = trend_reversal_up or increase_long or decrease_short or trend_reversal_down or decrease_long or increase_short or reset_long or reset_short
// //Grouped Alerts
// alertcondition(condition_buy, title='Condition Buy', message='You Need to Buy')
// alertcondition(condition_sell, title='Condition Sell', message='You Need to Sell!')
// alertcondition(adjustment_matrix, title='Adjustment Matrix', message='You Need to Adjust')