Strategi Dagangan Kuantitatif yang Mengikuti Trend Grid Dinamik

Penulis:ChaoZhang, Tarikh: 2024-03-22 16:03:09
Tag:

img

Ringkasan

Ini adalah strategi perdagangan kuantitatif yang mengikuti trend grid dinamik yang maju. Idea utama strategi ini adalah untuk membahagikan beberapa garis grid dalam julat harga yang telah ditetapkan dan secara automatik membuka kedudukan apabila harga mencapai garis grid dan menutup kedudukan ketika menjual, dengan itu mendapat keuntungan dari pasaran yang turun naik. Pada masa yang sama, strategi ini juga mempunyai fungsi menyesuaikan kedudukan garis grid secara dinamik, yang dapat mengoptimumkan susun atur grid mengikut trend harga terkini.

Prinsip Strategi

Prinsip-prinsip utama strategi ini adalah seperti berikut:

  1. Pertama, tentukan sempadan atas dan bawah grid dan bilangan garis grid berdasarkan tetapan pengguna.

  2. Dalam batas yang ditentukan, bahagikan julat harga ke dalam beberapa grid. Setiap garis grid sepadan dengan harga beli atau jual.

  3. Apabila harga mencapai setiap garis grid, strategi akan memeriksa sama ada kedudukan yang sepadan dengan garis grid sudah dipegang. Jika tidak, ia akan membuka kedudukan dan membeli, jika ya, ia akan menutup kedudukan dan menjual.

  4. Dengan menjual pada kedudukan yang agak tinggi dan membeli pada kedudukan yang rendah, strategi dapat terus mendapat keuntungan apabila harga turun naik.

  5. Pada masa yang sama, jika pengguna mengaktifkan fungsi pelarasan sempadan automatik, kedudukan garis grid akan disesuaikan dengan sesuai dengan harga tertinggi dan terendah baru-baru ini atau purata bergerak yang ditetapkan untuk mengoptimumkan susun atur grid.

Melalui prinsip-prinsip di atas, strategi ini boleh merealisasikan pembelian rendah automatik dan penjualan tinggi dalam trend harga yang berfluktuasi, dan menyesuaikan mata keuntungan mengikut trend, dengan itu meningkatkan pulangan keseluruhan.

Analisis Kelebihan

Strategi grid dinamik ini mempunyai kelebihan berikut:

  1. Kemudahan penyesuaian yang kuat. Ia boleh menyesuaikan diri dengan pasaran dan jenis yang berbeza melalui tetapan parameter, dan mempunyai kemampuan penyesuaian yang baik untuk pasaran yang berfluktuasi.

  2. Oleh kerana strategi ini berdasarkan logik matematik yang ketat dan titik pembukaan dan penutupan kedudukan yang jelas, ia dapat mencapai perdagangan automatik sepenuhnya dan mengurangkan gangguan emosi subjektif.

  3. Risiko yang boleh dikawal: Dengan menetapkan parameter seperti bilangan grid dan sempadan grid, pendedahan risiko setiap transaksi dapat dikawal dengan berkesan, dengan itu mengekalkan risiko keseluruhan dalam julat yang boleh diterima.

  4. Keupayaan untuk menyesuaikan diri dengan trend. Fungsi penyesuaian sempadan grid secara dinamik ditambah kepada strategi, supaya grid dapat mengikuti trend harga dan dioptimumkan, meningkatkan keuntungan di pasaran trend.

  5. Kadar kemenangan yang stabil. Oleh kerana perdagangan grid pada dasarnya sering melemparkan tinggi dan menghisap rendah dalam turun naik harga, selagi harga mengekalkan turun naik, strategi ini dapat terus mendapat keuntungan, jadi ia mempunyai kadar kemenangan yang tinggi dalam jangka panjang.

Analisis Risiko

Walaupun strategi ini mempunyai kelebihan yang jelas, ia juga mempunyai risiko tertentu:

  1. Risiko trend: Jika harga memecahkan sempadan grid dengan trend sepihak yang kuat, ruang keuntungan strategi ini akan terhad dan ia mungkin menghadapi retracement yang besar.

  2. Kesukaran dalam pengoptimuman parameter. Strategi ini mempunyai banyak parameter, termasuk bilangan grid, sempadan awal, parameter sempadan dinamik, dll. Gabungan parameter yang berbeza mempunyai kesan yang besar terhadap prestasi strategi, dan kesukaran pengoptimuman sebenar tidak kecil.

  3. Perdagangan yang kerap: Strategi grid pada dasarnya adalah strategi frekuensi tinggi, dengan pembukaan dan penutupan kedudukan yang sangat kerap, yang bermaksud kos transaksi yang lebih tinggi dan potensi risiko tergelincir.

  4. Kebergantungan yang kuat terhadap keadaan pasaran. Strategi ini sangat bergantung kepada pasaran yang berfluktuasi. Sebaik sahaja harga memasuki trend sepihak yang cepat, strategi ini mungkin menghadapi retracement yang besar.

Memandangkan risiko-risiko ini, penambahbaikan boleh dibuat dari aspek-aspek berikut: penambahan penentuan trend indikator sebagai syarat penapis untuk permulaan strategi, mengoptimumkan ruang dan kaedah carian parameter, memperkenalkan pengurusan dana dan kawalan kedudukan logik, meningkatkan trend logik penutupan kejayaan, dll. Melalui pengoptimuman ini, ketahanan dan keuntungan strategi ini boleh ditingkatkan lagi.

Arah pengoptimuman

Berdasarkan analisis di atas, arah pengoptimuman strategi ini terutamanya termasuk:

  1. Memperkenalkan keadaan penapisan trend. Tambah indikator penilaian trend sebelum strategi bermula, seperti purata bergerak, ADX, dan lain-lain. Hanya memulakan strategi dalam keadaan pasaran yang berfluktuasi, dan terus menonton di pasaran trend untuk mengelakkan risiko retracement di pasaran trend.

  2. Mengoptimumkan carian parameter. Gunakan algoritma pintar untuk mengoptimumkan parameter grid, seperti algoritma genetik, algoritma kumpulan zarah, dan lain-lain, untuk mencari kombinasi parameter yang optimum secara automatik dan meningkatkan kecekapan dan kualiti pengoptimuman.

  3. Meningkatkan logik kawalan risiko. Tambah lebih banyak logik kawalan risiko kepada strategi, seperti menyesuaikan lebar grid secara dinamik mengikut turun naik harga, menetapkan ambang retracement maksimum untuk mencetuskan penutupan, dll., untuk mengawal risiko dengan lebih baik.

  4. Memperkenalkan trend stop loss. Tetapkan garis stop loss trend, seperti peratusan tertentu dari sempadan grid. Sebaik sahaja harga memecahkan garis stop loss, tutup semua kedudukan untuk mengelakkan retracements besar di pasaran trend.

  5. Mengoptimumkan pelaksanaan urus niaga. Mengoptimumkan pautan pelaksanaan urus niaga, seperti mengamalkan jenis pesanan dan algoritma pesanan yang lebih maju, meminimumkan kekerapan dan kos transaksi, dan meningkatkan kecekapan pelaksanaan.

Melalui pengoptimuman di atas, kebolehan menyesuaikan diri, ketahanan dan keuntungan strategi ini dapat ditingkatkan secara komprehensif, menjadikannya lebih dekat dengan keperluan perdagangan sebenar.

Ringkasan

Secara umum, strategi trend grid dinamik ini adalah strategi perdagangan kuantitatif frekuensi pertengahan hingga tinggi berdasarkan prinsip perdagangan grid, dan mengintegrasikan mekanisme penyesuaian dinamik dan penyesuaian trend. Kelebihannya terletak pada kemampuan beradaptasi yang kuat, tahap automasi yang tinggi, risiko yang boleh dikawal, kemampuan beradaptasi trend yang baik, dan kadar kemenangan yang stabil. Pada masa yang sama, ia juga mempunyai risiko seperti risiko trend, kesukaran dalam pengoptimuman parameter, perdagangan kerap, dan ketergantungan yang kuat pada keadaan pasaran. Memandangkan masalah ini, penambahbaikan boleh dibuat dari penapisan trend, pengoptimuman parameter, peningkatan risiko, kawalan trend stop loss, pengoptimuman transaksi dan aspek lain untuk meningkatkan prestasi keseluruhan strategi.

Idea perdagangan grid itu sendiri adalah kaedah kuantitatif yang agak matang dan praktikal. Melalui penambahan mekanisme pengoptimuman dinamik dan penyesuaian trend kepada strategi ini, kelebihan perdagangan grid klasik telah diperluaskan dan dibangunkan. Ia menyediakan pelabur dengan idea perdagangan kuantitatif baru dan kemungkinan dalam pasaran yang berfluktuasi. Dengan pengoptimuman dan peningkatan lanjut, strategi ini dijangka menjadi alat perdagangan kuantitatif frekuensi pertengahan hingga tinggi yang sangat baik.


/*backtest
start: 2024-03-01 00:00:00
end: 2024-03-21 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("(IK) Grid Script", overlay=true, pyramiding=14, close_entries_rule="ANY", default_qty_type=strategy.cash, initial_capital=100.0, currency="USD", commission_type=strategy.commission.percent, commission_value=0.1)
i_autoBounds    = input(group="Grid Bounds", title="Use Auto Bounds?", defval=true, type=input.bool)                             // calculate upper and lower bound of the grid automatically? This will theorhetically be less profitable, but will certainly require less attention
i_boundSrc      = input(group="Grid Bounds", title="(Auto) Bound Source", defval="Hi & Low", options=["Hi & Low", "Average"])     // should bounds of the auto grid be calculated from recent High & Low, or from a Simple Moving Average
i_boundLookback = input(group="Grid Bounds", title="(Auto) Bound Lookback", defval=250, type=input.integer, maxval=500, minval=0) // when calculating auto grid bounds, how far back should we look for a High & Low, or what should the length be of our sma
i_boundDev      = input(group="Grid Bounds", title="(Auto) Bound Deviation", defval=0.10, type=input.float, maxval=1, minval=-1)  // if sourcing auto bounds from High & Low, this percentage will (positive) widen or (negative) narrow the bound limits. If sourcing from Average, this is the deviation (up and down) from the sma, and CANNOT be negative.
i_upperBound    = input(group="Grid Bounds", title="(Manual) Upper Boundry", defval=0.285, type=input.float)                      // for manual grid bounds only. The upperbound price of your grid
i_lowerBound    = input(group="Grid Bounds", title="(Manual) Lower Boundry", defval=0.225, type=input.float)                      // for manual grid bounds only. The lowerbound price of your grid.
i_gridQty       = input(group="Grid Lines",  title="Grid Line Quantity", defval=8, maxval=15, minval=3, type=input.integer)       // how many grid lines are in your grid

f_getGridBounds(_bs, _bl, _bd, _up) =>
    if _bs == "Hi & Low"
        _up ? highest(close, _bl) * (1 + _bd) : lowest(close, _bl)  * (1 - _bd)
    else
        avg = sma(close, _bl)
        _up ? avg * (1 + _bd) : avg * (1 - _bd)

f_buildGrid(_lb, _gw, _gq) =>
    gridArr = array.new_float(0)
    for i=0 to _gq-1
        array.push(gridArr, _lb+(_gw*i))
    gridArr

f_getNearGridLines(_gridArr, _price) =>
    arr = array.new_int(3)
    for i = 0 to array.size(_gridArr)-1
        if array.get(_gridArr, i) > _price
            array.set(arr, 0, i == array.size(_gridArr)-1 ? i : i+1)
            array.set(arr, 1, i == 0 ? i : i-1)
            break
    arr

var upperBound      = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true) : i_upperBound  // upperbound of our grid
var lowerBound      = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false) : i_lowerBound // lowerbound of our grid
var gridWidth       = (upperBound - lowerBound)/(i_gridQty-1)                                                       // space between lines in our grid
var gridLineArr     = f_buildGrid(lowerBound, gridWidth, i_gridQty)                                                 // an array of prices that correspond to our grid lines
var orderArr        = array.new_bool(i_gridQty, false)                                                              // a boolean array that indicates if there is an open order corresponding to each grid line

var closeLineArr    = f_getNearGridLines(gridLineArr, close)                                                        // for plotting purposes - an array of 2 indices that correspond to grid lines near price
var nearTopGridLine = array.get(closeLineArr, 0)                                                                    // for plotting purposes - the index (in our grid line array) of the closest grid line above current price
var nearBotGridLine = array.get(closeLineArr, 1)                                                                    // for plotting purposes - the index (in our grid line array) of the closest grid line below current price
strategy.initial_capital = 50000
for i = 0 to (array.size(gridLineArr) - 1)
    if close < array.get(gridLineArr, i) and not array.get(orderArr, i) and i < (array.size(gridLineArr) - 1)
        buyId = i
        array.set(orderArr, buyId, true)
        strategy.entry(id=tostring(buyId), long=true, qty=(strategy.initial_capital/(i_gridQty-1))/close, comment="#"+tostring(buyId))
    if close > array.get(gridLineArr, i) and i != 0
        if array.get(orderArr, i-1)
            sellId = i-1
            array.set(orderArr, sellId, false)
            strategy.close(id=tostring(sellId), comment="#"+tostring(sellId))

if i_autoBounds
    upperBound  := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true)
    lowerBound  := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false)
    gridWidth   := (upperBound - lowerBound)/(i_gridQty-1)
    gridLineArr := f_buildGrid(lowerBound, gridWidth, i_gridQty)

closeLineArr    := f_getNearGridLines(gridLineArr, close)
nearTopGridLine := array.get(closeLineArr, 0)
nearBotGridLine := array.get(closeLineArr, 1)







Lebih lanjut