Divergence Matrix Trend Mengikuti Strategi

Penulis:ChaoZhang, Tanggal: 2023-12-12 17:05:27
Tag:

Gambaran umum

Divergence Matrix Trend Following Strategy adalah strategi perdagangan kuantitatif yang menggabungkan analisis tren, divergensi, dan moving average. Strategi ini menggunakan indikator RSI ganda untuk menilai arah tren pasar dan rata-rata bergerak matriks untuk menghasilkan sinyal masuk.

Logika Strategi

Strategi Divergence Matrix Trend Following terdiri dari bagian utama berikut:

RSI ganda untuk menilai tren

Gunakan RSI cepat dan RSI lambat untuk menentukan arah tren pasar.
Rata-rata bergerak matriks untuk sinyal perdagangan

Setel kelompok matriks moving average berdasarkan harga masuk. Ketika harga menyentuh garis moving average, sesuaikan posisinya. Hal ini memungkinkan lebih banyak keuntungan untuk ditangkap dalam tren.
Perdagangan dua arah

Default adalah perdagangan bidirectional.

Logika perdagangan khusus adalah:

Gunakan RSI cepat untuk melihat tingkat overbought / oversold sementara di pasar.
Gunakan RSI yang lambat untuk menentukan arah tren pasar jangka menengah hingga panjang.
Ketika RSI cepat menunjukkan ekstrem dan RSI lambat sinyal pembalikan tren, mengambil posisi berdasarkan tren panjang/pendek dengan RSI lambat.
Setelah memasukkan posisi, atur sekelompok rata-rata bergerak matriks. Garis matriks ini didasarkan pada harga masuk, dengan ukuran interval didefinisikan dalam parameter Matrix Interval %.
Ketika harga menyentuh garis matriks, sesuaikan ukuran posisi. misalnya, tingkatkan long pada break-out ke atas, kurangi short pada breakdown ke bawah.
Ketika harga melihat penyesuaian besar, posisi akan diatur kembali ke tingkat awal.

Di atas menggambarkan logika perdagangan utama dari strategi ini. mekanisme matriks memungkinkan lebih banyak keuntungan tren untuk dikunci.

Keuntungan

Strategi Divergence Matrix Trend Following memiliki keuntungan berikut:

Sinyal RSI ganda lebih dapat diandalkan. RSI cepat menghindari pecah palsu dan RSI lambat memastikan tren utama benar.
Rata-rata bergerak matriks keuntungan dari tren. penyesuaian ukuran posisi berdasarkan perbedaan harga memungkinkan keuntungan berkelanjutan untuk ditangkap.
Mendukung perdagangan bidirectional. Default adalah perdagangan bidirectional, tetapi juga dapat berjalan lama saja. Ini beradaptasi dengan lebih banyak lingkungan pasar.
Mekanisme reset posisi mengendalikan risiko. Reset posisi ketika harga melihat penyesuaian besar memungkinkan stop loss yang tepat waktu.
Pengaturan parameter yang fleksibel. Pengguna dapat memilih kombinasi parameter yang optimal berdasarkan data historis, instrumen perdagangan dll.
Struktur kode yang bersih. pemisahan tanggung jawab yang jelas membuat kode mudah dipahami, dioptimalkan dan diperluas.

Singkatnya, keunggulan terbesar dari strategi ini adalah meningkatkan kualitas sinyal melalui beberapa mekanisme sambil mengejar pengembalian yang lebih tinggi dengan risiko terkontrol.

Risiko

Strategi Divergence Matrix Trend Following juga memiliki beberapa risiko, terutama di bidang berikut:

Risiko kegagalan sinyal RSI ganda. Ketika pasar terikat kisaran, RSI sering memberikan sinyal palsu. Intervensi manual diperlukan untuk menyesuaikan parameter atau menangguhkan perdagangan.
Jika parameter matriks tidak diatur dengan benar, penyesuaian posisi bisa terlalu agresif, sehingga memperbesar kerugian. pengujian parameter konservatif adalah suatu keharusan.
Risiko posisi yang terlalu leveraged. penyesuaian ukuran posisi yang berlebihan juga akan memperluas kerugian. parameter ukuran posisi maksimum perlu ditetapkan dengan hati-hati.
Risiko pembalikan tren. Jika gagal untuk menutup posisi segera ketika tren berbalik, kerugian besar dapat terjadi. Ini mengharuskan pemantauan indikator tren jangka panjang.
Risiko ruang optimasi terbatas. Strategi ini sudah cukup matang. Potensi optimasi berkelanjutan terbatas. Upgrade besar mungkin diperlukan jika rezim pasar berubah secara drastis.

Penilaian dan optimalisasi strategi adalah kunci untuk mengurangi risiko ini - menyesuaikan parameter, memantau indikator jangka panjang dll, dapat mengurangi risiko sampai batas tertentu.

Peluang Peningkatan

Ada ruang untuk peningkatan lebih lanjut dari Trend Divergence Matrix Strategi berikut:

Mengoptimalkan parameter RSI ganda. Uji lebih banyak kombinasi parameter dan pilih periode RSI dengan akurasi tertinggi.
Lini matriks yang dapat disesuaikan. Memungkinkan pengguna untuk memparameterkan pengaturan matriks berdasarkan instrumen yang berbeda untuk lebih sesuai dengan karakteristik mereka.
Tambahkan mekanisme stop loss. misalnya, atur garis keluar untuk menghentikan posisi jika harga melanggar garis tersebut.
Tambahkan aturan ukuran posisi yang lebih ilmiah. Mengelola penyesuaian ukuran posisi secara lebih bertahap untuk mencegah leverage yang berlebihan.
Masukkan indikator lain. Masukkan indikator tambahan seperti MACD, KD dll untuk meningkatkan akurasi sinyal.
Mengoptimalkan struktur kode. Lebih lanjut meningkatkan ekstensibilitas, pemeliharaan dan efisiensi eksekusi kode.

Kesimpulan

Divergence Matrix Trend Following Strategy adalah strategi perdagangan kuantitatif yang canggih yang menggabungkan beberapa mekanisme - menggunakan RSI ganda untuk arah tren dan garis matriks untuk mendapatkan keuntungan dari tren. Dibandingkan dengan strategi indikator tunggal, strategi ini memberikan sinyal perdagangan yang lebih stabil dan efisien. Dengan penyesuaian parameter dan ekstensi pengoptimalan, strategi ini dapat beradaptasi dengan lebih banyak kondisi dan rezim pasar, menjadikannya sangat serbaguna. Secara keseluruhan, strategi ini mencapai keseimbangan yang baik antara risiko dan pengembalian, dan layak diterapkan secara aktif dan terus ditingkatkan oleh investor.

/*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')

Lebih banyak

2019 FMZ - Semua hak dilindungi