Strategi Perdagangan Kuantitatif Mengikuti Tren Grid Dinamis
ChaoZhang
Ringkasan
Ini adalah strategi perdagangan kuantitatif pelacakan tren grid dinamis yang canggih. Gagasan utama strategi ini adalah untuk membagi beberapa garis grid dalam kisaran harga yang ditetapkan sebelumnya dan secara otomatis melakukan pembelian atau penjualan posisi terendah saat harga menyentuh garis grid, sehingga menghasilkan keuntungan dalam situasi yang bergolak. Strategi ini juga memiliki fungsi untuk menyesuaikan posisi garis grid secara dinamis, yang dapat secara otomatis mengoptimalkan tata letak grid sesuai dengan pergerakan harga terbaru.
Prinsip Strategi
Prinsip-prinsip inti dari strategi ini adalah sebagai berikut:
Pertama, menentukan batas atas dan bawah grid dan jumlah garis grid berdasarkan pengaturan pengguna. Perbatasan dapat menjadi nilai tetap, atau dapat secara otomatis dihitung berdasarkan titik tinggi dan rendah terbaru atau rata-rata bergerak.
Dalam batas yang ditentukan, bagilah kisaran harga menjadi beberapa grid. Setiap garis grid sesuai dengan harga yang dibeli atau dijual.
Setiap kali harga menyentuh garis grid, strategi akan memeriksa apakah posisi yang sesuai dengan garis grid tersebut sudah dipegang. Jika tidak ada, posisi akan dibeli, dan jika ada, posisi akan dijual.
Dengan menjual dengan harga yang relatif tinggi dan membeli dengan harga rendah, strategi ini dapat terus menghasilkan keuntungan ketika harga bergejolak.
Selain itu, jika pengguna mengaktifkan fitur penyesuaian batas otomatis, posisi garis grid akan menyesuaikan diri dengan harga tinggi atau rendah baru-baru ini atau rata-rata bergerak yang disetel untuk mengoptimalkan tata letak grid.
Dengan prinsip-prinsip di atas, strategi ini memungkinkan untuk melakukan pembelian dan penjualan otomatis di bawah kondisi harga yang bergejolak, dan menyesuaikan posisi keuntungan sesuai dengan tren, sehingga meningkatkan pendapatan keseluruhan.
Analisis Keunggulan
Strategi grid dinamis memiliki keuntungan sebagai berikut:
Adaptif. Dapat disesuaikan dengan berbagai pasar dan varietas melalui pengaturan parameter. Adaptif terhadap kondisi getaran.
Tingkat otomatisasi yang tinggi. Karena strategi didasarkan pada logika matematika yang ketat, titik posisi yang jelas, maka perdagangan dapat sepenuhnya otomatis dan mengurangi gangguan emosi subjektif.
Risiko dapat dikontrol. Dengan mengatur parameter seperti jumlah grid, batas grid, dan lain-lain, Anda dapat secara efektif mengontrol risiko setiap transaksi, sehingga menjaga risiko keseluruhan dalam kisaran yang dapat diterima.
Adaptif terhadap tren. Strategi ini menambahkan fungsi untuk menyesuaikan secara dinamis batas grid, memungkinkan grid untuk mengikuti tren harga dan mengoptimalkan, meningkatkan kemampuan untuk menghasilkan keuntungan dalam situasi tren.
Strategi ini dapat terus menghasilkan keuntungan selama harga bergejolak, karena perdagangan grid pada dasarnya sering naik turun dalam pergerakan harga, strategi ini memiliki tingkat kemenangan yang tinggi dalam jangka panjang.
Analisis risiko
Meskipun ada keuntungan yang jelas dari strategi ini, ada juga risiko:
Risiko tren. Jika harga mengalami tren unilateral yang kuat yang melintasi batas grid, ruang untuk keuntungan dari strategi ini akan dibatasi dan mungkin menghadapi penarikan yang lebih besar.
Strategi ini memiliki banyak parameter, termasuk jumlah grid, batas awal, parameter batas dinamis, dan lain-lain. Kombinasi parameter yang berbeda sangat berpengaruh pada kinerja strategi, dan kesulitan pengoptimalan yang sebenarnya tidak kecil.
Strategi grid pada dasarnya adalah strategi dengan frekuensi tinggi, dengan posisi yang sangat sering, yang berarti biaya transaksi yang lebih tinggi dan potensi risiko slippage.
Strategi ini sangat bergantung pada tren tren goyangan, dan kemungkinan besar akan mengalami kemunduran besar jika harga memasuki tren satu sisi yang cepat.
Untuk menghadapi risiko ini, perbaikan dapat dimulai dengan cara berikut: menambahkan indikator penilaian tren sebagai kondisi penyaringan untuk memulai strategi, mengoptimalkan ruang dan metode pencarian parameter, memperkenalkan manajemen dana dan logika kontrol posisi, meningkatkan tren logik pemecahan posisi rata, dll. Dengan pengoptimalan ini, stabilitas dan profitabilitas strategi dapat ditingkatkan lebih lanjut.
Arah optimasi
Berdasarkan analisis di atas, arah optimasi dari strategi ini adalah:
Memperkenalkan kondisi penyaringan tren. Menambahkan indikator penilaian tren, seperti moving average, ADX, dan lain-lain sebelum memulai strategi, hanya memulai strategi dalam situasi getaran, dan tetap waspada dalam situasi tren, sehingga dapat secara efektif menghindari risiko penarikan balik dalam situasi tren.
Pencarian parameter optimasi. Menggunakan algoritma cerdas untuk mengoptimalkan parameter grid, seperti algoritma genetik, algoritma kelompok partikel, dan lain-lain, sehingga secara otomatis menemukan kombinasi parameter yang optimal, meningkatkan efisiensi dan kualitas optimasi.
Meningkatkan logika pengendalian risiko. Menambahkan lebih banyak logika pengendalian risiko ke dalam strategi, seperti penyesuaian lebar grid berdasarkan dinamika fluktuasi harga, pengaturan nilai ambang batas maksimum untuk memicu posisi rata, dan sebagainya, sehingga lebih baik mengendalikan risiko.
Memperkenalkan trend stop. Mengatur trend untuk menembus garis stop loss, seperti batas grid dalam proporsi tertentu, dan posisi yang benar-benar kosong jika harga menembus garis stop loss, untuk menghindari kemunduran besar dalam situasi tren.
Optimalkan eksekusi transaksi. Mengoptimalkan proses eksekusi transaksi, seperti menggunakan daftar syarat dan algoritma pesanan yang lebih canggih, mengurangi frekuensi dan biaya transaksi, dan meningkatkan efisiensi eksekusi.
Dengan optimasi ini, strategi ini dapat secara menyeluruh meningkatkan adaptasi, stabilitas, dan profitabilitas, sehingga lebih dekat dengan kebutuhan lapangan.
Meringkaskan
Secara keseluruhan, strategi pelacakan tren jaringan dinamis adalah strategi perdagangan berfrekuensi menengah dan tinggi yang didasarkan pada prinsip perdagangan jaringan, sekaligus mengintegrasikan mekanisme penyesuaian dinamis dan adaptasi tren. Kelebihannya adalah kemampuan beradaptasi yang kuat, tingkat otomatisasi yang tinggi, risiko yang dapat dikontrol, kemampuan beradaptasi dengan tren yang baik, tingkat kemenangan yang stabil, dll, tetapi pada saat yang sama ada risiko yang kuat seperti risiko tren, kesulitan mengoptimalkan parameter, perdagangan yang sering, ketergantungan pada kondisi perdagangan. Untuk mengatasi masalah ini, Anda dapat memperbaiki dan meningkatkan kinerja keseluruhan strategi dari penyaringan tren, pengoptimalan parameter, penguatan kontrol risiko, penghentian kerugian tren, dan optimalisasi perdagangan.
Metode perdagangan grid sendiri adalah metode kuantitatif yang relatif matang dan praktis, dengan optimasi dinamis strategi dan penambahan mekanisme adaptasi tren, keuntungan dari perdagangan grid klasik diperpanjang dan dikembangkan. Ini menawarkan investor dengan ide dan kemungkinan baru untuk perdagangan kuantitatif dalam situasi yang bergolak. Dengan pengoptimalan dan perbaikan lebih lanjut, strategi ini diharapkan menjadi alat perdagangan kuantitatif frekuensi menengah dan tinggi yang 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)