Strategi Perdagangan Kuantitatif Mengikuti Tren Grid Dinamis

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

img

Gambaran umum

Ini adalah strategi perdagangan kuantitatif yang mengikuti tren grid dinamis canggih. Ide utama strategi ini adalah untuk membagi beberapa garis grid dalam kisaran harga yang telah ditetapkan sebelumnya dan secara otomatis membuka posisi ketika harga mencapai garis grid dan menutup posisi saat menjual, sehingga mendapatkan keuntungan dari fluktuasi pasar. Pada saat yang sama, strategi ini juga memiliki fungsi untuk menyesuaikan posisi garis grid secara dinamis, yang dapat mengoptimalkan tata letak grid secara adaptif sesuai dengan tren harga terbaru.

Prinsip Strategi

Prinsip inti dari strategi ini adalah sebagai berikut:

  1. Pertama, tentukan batas atas dan bawah grid dan jumlah garis grid berdasarkan pengaturan pengguna.

  2. Dalam batas yang ditentukan, bagi kisaran harga menjadi beberapa kisi.

  3. Ketika harga mencapai setiap garis grid, strategi akan memeriksa apakah posisi yang sesuai dengan garis grid sudah dipegang. Jika tidak, itu akan membuka posisi dan membeli, jika demikian, itu akan menutup posisi dan menjual.

  4. Dengan menjual pada posisi yang relatif tinggi dan membeli pada posisi yang rendah, strategi dapat terus mendapat keuntungan ketika harga berfluktuasi.

  5. Pada saat yang sama, jika pengguna mengaktifkan fungsi penyesuaian batas otomatis, posisi garis grid akan disesuaikan sesuai dengan harga tertinggi dan terendah baru-baru ini atau rata-rata bergerak yang ditetapkan untuk mengoptimalkan tata letak grid.

Melalui prinsip-prinsip di atas, strategi ini dapat mewujudkan pembelian rendah otomatis dan penjualan tinggi dalam tren harga yang berfluktuasi, dan menyesuaikan poin keuntungan sesuai dengan tren, sehingga meningkatkan pengembalian keseluruhan.

Analisis Keuntungan

Strategi jaringan dinamis ini memiliki keuntungan berikut:

  1. Kemampuan beradaptasi yang kuat. Dapat beradaptasi dengan pasar dan varietas yang berbeda melalui pengaturan parameter, dan memiliki kemampuan beradaptasi yang baik dengan fluktuasi pasar.

  2. Karena strategi ini didasarkan pada logika matematika yang ketat dan titik pembukaan dan penutupan posisi yang jelas, ia dapat mencapai perdagangan yang sepenuhnya otomatis dan mengurangi gangguan emosional subjektif.

  3. Risiko yang dapat dikendalikan. Dengan menetapkan parameter seperti jumlah jaringan dan batas jaringan, eksposur risiko dari setiap transaksi dapat dikendalikan secara efektif, sehingga menjaga risiko keseluruhan dalam kisaran yang dapat diterima.

  4. Fungsi penyesuaian batas grid secara dinamis ditambahkan ke strategi, sehingga grid dapat mengikuti tren harga dan dioptimalkan, meningkatkan profitabilitas di pasar tren.

  5. Tingkat kemenangan yang stabil. Karena perdagangan grid pada dasarnya sering melemparkan tinggi dan menghisap rendah dalam fluktuasi harga, selama harga mempertahankan fluktuasi, strategi ini dapat terus menguntungkan, sehingga memiliki tingkat kemenangan yang tinggi dalam jangka panjang.

Analisis Risiko

Meskipun strategi ini memiliki keuntungan yang jelas, ia juga memiliki risiko tertentu:

  1. Risiko tren: Jika harga menembus batas grid dengan tren unilateral yang kuat, ruang keuntungan dari strategi ini akan terbatas dan mungkin menghadapi retracement yang besar.

  2. Kesulitan dalam optimasi parameter. Strategi ini memiliki banyak parameter, termasuk jumlah grid, batas awal, parameter batas dinamis, dll. Kombinasi parameter yang berbeda memiliki dampak besar pada kinerja strategi, dan kesulitan optimasi yang sebenarnya tidak kecil.

  3. Strategi grid pada dasarnya adalah strategi frekuensi tinggi, dengan pembukaan dan penutupan posisi yang sangat sering, yang berarti biaya transaksi yang lebih tinggi dan risiko slippage potensial.

  4. Strategi ini sangat bergantung pada fluktuasi pasar. Begitu harga memasuki tren unilateral yang cepat, strategi ini kemungkinan akan menghadapi retracement yang besar.

Mengingat risiko-risiko ini, perbaikan dapat dilakukan dari aspek-aspek berikut: menambahkan indikator penilaian tren sebagai kondisi filter untuk memulai strategi, mengoptimalkan ruang dan metode pencarian parameter, memperkenalkan manajemen dana dan logika kontrol posisi, meningkatkan logika penutupan tren, dll. Melalui optimalisasi ini, ketahanan dan profitabilitas strategi ini dapat ditingkatkan lebih lanjut.

Arah Optimalisasi

Berdasarkan analisis di atas, arah optimalisasi strategi ini terutama meliputi:

  1. Memperkenalkan kondisi penyaringan tren. Tambahkan indikator penilaian tren sebelum strategi dimulai, seperti rata-rata bergerak, ADX, dll. Hanya memulai strategi dalam kondisi pasar yang berfluktuasi, dan terus menonton di pasar tren untuk secara efektif menghindari risiko retracement di pasar tren.

  2. Mengoptimalkan pencarian parameter. Gunakan algoritma cerdas untuk mengoptimalkan parameter grid, seperti algoritma genetik, algoritma kawanan partikel, dll., Untuk secara otomatis menemukan kombinasi parameter optimal dan meningkatkan efisiensi dan kualitas optimasi.

  3. Meningkatkan logika pengendalian risiko. Tambahkan lebih banyak logika pengendalian risiko ke strategi, seperti menyesuaikan lebar grid secara dinamis sesuai dengan volatilitas harga, menetapkan ambang retracement maksimum untuk memicu penutupan, dll., Untuk mengontrol risiko dengan lebih baik.

  4. Memperkenalkan stop loss tren. Tetapkan garis stop loss trend breakthrough, seperti persentase tertentu dari batas grid. Setelah harga menembus garis stop loss, tutup semua posisi untuk menghindari retracements besar di pasar tren.

  5. Mengoptimalkan eksekusi transaksi. Mengoptimalkan tautan eksekusi transaksi, seperti mengadopsi jenis order dan algoritma order yang lebih maju, meminimalkan frekuensi dan biaya transaksi, dan meningkatkan efisiensi eksekusi.

Melalui optimalisasi di atas, kemampuan beradaptasi, ketahanan dan profitabilitas strategi ini dapat ditingkatkan secara komprehensif, membuatnya lebih dekat dengan kebutuhan perdagangan yang sebenarnya.

Ringkasan

Secara umum, strategi mengikuti tren grid dinamis ini adalah strategi perdagangan kuantitatif frekuensi menengah hingga tinggi berdasarkan prinsip perdagangan grid, dan mengintegrasikan mekanisme penyesuaian dan penyesuaian tren dinamis. Keuntungannya terletak pada kemampuan beradaptasi yang kuat, tingkat otomatisasi yang tinggi, risiko yang dapat dikendalikan, kemampuan beradaptasi tren yang baik, dan tingkat kemenangan yang stabil. Pada saat yang sama, juga memiliki risiko seperti risiko tren, kesulitan dalam pengoptimalan parameter, perdagangan frekuensi, dan ketergantungan yang kuat pada kondisi pasar. Mengingat masalah ini, perbaikan dapat dilakukan dari penyaringan tren, pengoptimalan parameter, peningkatan risiko, kontrol stop loss tren, pengoptimalan transaksi, dan aspek lain untuk meningkatkan kinerja keseluruhan strategi.

Ide perdagangan grid itu sendiri adalah metode kuantitatif yang relatif matang dan praktis. Melalui penambahan mekanisme optimasi dinamis dan adaptasi tren ke strategi ini, keuntungan dari perdagangan grid klasik telah diperluas dan dikembangkan. Ini memberikan investor dengan ide perdagangan kuantitatif baru dan kemungkinan di pasar yang fluktuatif. Dengan optimasi dan perbaikan lebih lanjut, strategi ini diharapkan menjadi alat perdagangan kuantitatif frekuensi menengah 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 banyak