Trend Matriks Divergensi Mengikut Strategi

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

Ringkasan

Divergence Matrix Trend Following Strategy adalah strategi perdagangan kuantitatif yang menggabungkan analisis trend, divergensi, dan purata bergerak. Strategi ini menggunakan penunjuk RSI berganda untuk menilai arah trend pasaran dan purata bergerak matriks untuk menjana isyarat kemasukan. Purata bergerak matriks menyesuaikan saiz kedudukan berdasarkan tahap perbezaan harga. Secara keseluruhan, kelebihan strategi ini adalah untuk mengesahkan isyarat perdagangan dengan beberapa penunjuk, yang dapat mengelakkan kegagalan palsu. Sementara itu, mekanisme matriks dapat mengunci pulangan yang lebih tinggi.

Logika Strategi

Divergence Matrix Trend Following Strategy terdiri daripada bahagian utama berikut:

RSI berganda untuk menilai trend

Gunakan RSI cepat dan RSI perlahan untuk menentukan arah trend pasaran. Apabila RSI cepat menunjukkan tahap overbought atau oversold, periksa RSI perlahan untuk arah trend.
Purata bergerak matriks untuk isyarat dagangan

Tetapkan kumpulan purata bergerak matriks berdasarkan harga kemasukan. Apabila harga menyentuh garis purata bergerak, sesuaikan kedudukan dengan itu. Ini membolehkan lebih banyak keuntungan ditangkap dalam trend.
Perdagangan dua arah

Default adalah perdagangan dua arah. boleh memilih untuk hanya pergi lama.

Logik perdagangan khusus adalah:

Gunakan RSI pantas untuk melihat tahap overbought / oversold sementara di pasaran.
Gunakan RSI yang perlahan untuk menentukan arah trend jangka menengah hingga panjang pasaran.
Apabila RSI yang cepat menunjukkan ekstrem dan RSI yang perlahan menandakan pembalikan trend, ambil kedudukan berdasarkan trend panjang/pendek oleh RSI yang perlahan.
Selepas memasukkan kedudukan, tetapkan sekumpulan purata bergerak matriks. Garis matriks ini berdasarkan harga kemasukan, dengan saiz selang yang ditakrifkan dalam parameter Matrix Interval %.
Apabila harga menyentuh garisan matriks, sesuaikan saiz kedudukan dengan sewajarnya.
Apabila harga melihat penyesuaian besar, kedudukan akan diset semula ke tahap awal.

Di atas menerangkan logik perdagangan utama strategi ini. Mekanisme matriks membolehkan lebih banyak keuntungan trend dikunci.

Kelebihan

Divergence Matrix Trend Following Strategy mempunyai kelebihan berikut:

Isyarat RSI berganda lebih boleh dipercayai. RSI cepat mengelakkan pecah palsu dan RSI perlahan memastikan trend utama betul.
Rata-rata bergerak matriks mendapat keuntungan daripada trend. Penyesuaian saiz kedudukan berdasarkan perbezaan harga membolehkan keuntungan berterusan ditangkap.
Menyokong perdagangan dua arah. lalai adalah perdagangan dua arah, tetapi juga boleh pergi lama sahaja. Ini menyesuaikan diri dengan lebih banyak persekitaran pasaran.
Mekanisme penyetelan semula kedudukan mengawal risiko. Penyetelan semula kedudukan apabila harga melihat penyesuaian besar membolehkan kerugian berhenti tepat pada masanya.
Tetapan parameter yang fleksibel. Pengguna boleh memilih kombinasi parameter yang optimum berdasarkan data sejarah, instrumen perdagangan dan lain-lain.
Struktur kod yang bersih. Pemisahan tanggungjawab yang jelas menjadikan kod mudah difahami, dioptimumkan dan diperluaskan.

Ringkasnya, kelebihan terbesar strategi ini adalah untuk meningkatkan kualiti isyarat melalui pelbagai mekanisme sambil mengejar pulangan yang lebih tinggi di bawah risiko terkawal.

Risiko

Strategi Divergence Matrix Trend Following juga mempunyai beberapa risiko, terutamanya dalam bidang berikut:

Risiko kegagalan isyarat RSI berganda. Apabila pasaran terikat julat, RSI sering memberikan isyarat palsu. campur tangan manual diperlukan untuk menyesuaikan parameter atau menangguhkan perdagangan.
Risiko purata bergerak matriks yang tidak betul. Jika parameter matriks tidak ditetapkan dengan betul, pelarasan kedudukan boleh menjadi terlalu agresif, sehingga memperbesar kerugian.
Risiko kedudukan yang terlalu leveraged. Penyesuaian saiz kedudukan yang berlebihan juga akan meningkatkan kerugian. Parameter saiz kedudukan maksimum perlu ditetapkan dengan berhati-hati.
Risiko pembalikan trend. Jika gagal menutup kedudukan dengan segera apabila trend berbalik, kerugian besar mungkin timbul. Ini memerlukan pemantauan penunjuk trend jangka panjang.
Risiko ruang pengoptimuman terhad. Strategi ini sudah cukup matang. Potensi pengoptimuman berterusan adalah terhad. Peningkatan utama mungkin diperlukan jika rejimen pasaran berubah secara drastik.

Penilaian dan pengoptimuman strategi adalah kunci untuk mengurangkan risiko ini - menyesuaikan parameter, memantau penunjuk jangka panjang, dll, boleh mengurangkan risiko hingga tahap tertentu.

Peluang Peningkatan

Terdapat ruang untuk meningkatkan lagi Trend Matriks Divergensi Strategi berikut:

Mengoptimumkan parameter RSI berganda. Uji lebih banyak kombinasi parameter dan pilih tempoh RSI dengan ketepatan tertinggi.
Garis matriks yang boleh disesuaikan. Membolehkan pengguna untuk menetapkan tetapan matriks berdasarkan instrumen yang berbeza untuk lebih sesuai dengan ciri mereka.
Tambahkan mekanisme stop loss. Sebagai contoh, tetapkan garis keluar untuk menghentikan kedudukan jika harga melanggar garis tersebut.
Tambah peraturan saiz kedudukan yang lebih saintifik.
Masukkan penunjuk lain. Memperkenalkan penunjuk tambahan seperti MACD, KD dll untuk meningkatkan ketepatan isyarat.
Mengoptimumkan struktur kod. Meningkatkan lagi kebolehluasan, penyelenggaraan dan kecekapan pelaksanaan kod.

Kesimpulan

Divergence Matrix Trend Following Strategy adalah strategi perdagangan kuantitatif yang canggih yang menggabungkan pelbagai mekanisme - menggunakan RSI berganda untuk arah trend dan garis matriks untuk mendapat keuntungan daripada trend. Berbanding dengan strategi satu penunjuk, ia memberikan isyarat perdagangan yang lebih stabil dan cekap. Dengan penyempurnaan parameter dan pelanjutan pengoptimuman, strategi ini dapat menyesuaikan diri dengan lebih banyak keadaan dan rejim pasaran, menjadikannya sangat serba boleh. Secara keseluruhan, strategi ini mencapai keseimbangan yang baik antara risiko dan pulangan, dan layak aplikasi aktif dan peningkatan berterusan oleh pelabur.

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

2019 FMZ - Semua hak dilindungi