Strategi Lindung Nilai Risiko Perdagangan Grid
ChaoZhang
Tinjauan Strategi
Strategi hedging risiko perdagangan grid adalah strategi perdagangan kuantitatif yang didasarkan pada konsep perdagangan grid, yang digabungkan dengan pemikiran hedging risiko. Strategi ini menghasilkan keuntungan dari fluktuasi harga dengan menempatkan beberapa pesanan beli dan jual dalam kisaran harga yang telah ditentukan. Strategi ini juga memperkenalkan mekanisme hedging risiko, yang secara dinamis menyesuaikan batas grid untuk menyesuaikan diri dengan perubahan lingkungan pasar, mengurangi risiko strategi.
Prinsip Strategi
Prinsip inti dari strategi ini adalah perdagangan grid. Pertama, menentukan batas atas dan bawah grid dan jumlah garis grid berdasarkan parameter yang ditetapkan oleh pengguna. Kemudian, letakkan pesanan jual beli pada garis grid: buka posisi jika tidak ada pesanan sebelumnya ketika harga menyentuh garis grid; tutup posisi jika ada pesanan sebelumnya. Dengan cara ini, strategi dapat terus membuka posisi terbuka dalam fluktuasi harga, sehingga menghasilkan keuntungan.
Untuk mengurangi risiko, strategi ini juga memperkenalkan mekanisme penyesuaian batas grid yang dinamis. Berdasarkan pilihan pengguna, batas atas dan bawah grid dapat disesuaikan secara otomatis dengan dua cara: 1) Berdasarkan harga tertinggi dan terendah dalam beberapa waktu terakhir, dan mempertimbangkan perpindahan yang ditetapkan pengguna; 2) Berdasarkan rata-rata bergerak, dan mempertimbangkan perpindahan yang ditetapkan pengguna. Dengan penyesuaian batas grid secara dinamis, jaringan dapat selalu berputar di sekitar harga saat ini, sehingga mengurangi risiko harga menembus batas grid.
Selain itu, strategi ini akan membagi jumlah total modal menjadi N bagian saat membuka posisi, menggunakan jumlah yang sama setiap kali membuka posisi, sehingga dapat mengurangi risiko transaksi tunggal.
Analisis Keunggulan
Adaptif: Dengan menyesuaikan batas grid secara dinamis, strategi dapat beradaptasi dengan lingkungan pasar yang berbeda, baik itu tren atau tren yang bergejolak, dapat menyesuaikan secara otomatis untuk mendapatkan hasil yang lebih baik.
Risiko yang dapat dikontrol: Strategi menggunakan jumlah dana yang sama saat membuka posisi, risiko transaksi tunggal lebih kecil; pada saat yang sama, mekanisme penyesuaian batas grid dinamis dapat mengurangi risiko harga menembus batas grid.
Frekuensi perdagangan yang tinggi: karena grid biasanya menempatkan lebih banyak pesanan, frekuensi perdagangan yang lebih tinggi, lebih mudah untuk mendapatkan keuntungan dalam situasi yang bergejolak.
Fleksibilitas parameter: pengguna dapat menyesuaikan gaya perdagangan yang berbeda sesuai dengan preferensi mereka sendiri, mengatur jumlah grid, batas atas dan bawah, parameter yang disesuaikan secara dinamis, dll.
Analisis risiko
Performa yang buruk dalam situasi tren: Strategi mungkin menghadapi risiko yang lebih besar jika harga terus naik atau turun secara sepihak, melampaui batas grid, dan penyesuaian dinamis tidak mengikuti kecepatan perubahan harga.
Biaya: Biaya ini dapat mempengaruhi pendapatan karena seringnya transaksi strategi.
Parameter yang tidak benar: Jika parameter yang tidak benar, seperti terlalu banyak grid, grille border yang tidak masuk akal, dan lain-lain, dapat menyebabkan kinerja kebijakan yang buruk.
Solusi: 1) Dalam situasi yang sedang tren, Anda dapat mempertimbangkan untuk meningkatkan ukuran penyesuaian batas grid, atau dikombinasikan dengan strategi tren; 2) Pilih pertukaran dan mata uang dengan biaya yang lebih rendah; 3) Parameter perlu diukur dan dioptimalkan sebelum operasi nyata.
Arah optimasi
Kombinasi dengan strategi lain: Anda dapat mempertimbangkan untuk menggabungkan strategi perdagangan grid dengan jenis strategi lain, seperti strategi tren, strategi regresi rata-rata, dan lain-lain, untuk meningkatkan fleksibilitas dan stabilitas strategi.
Meningkatkan mekanisme penyesuaian dinamis: mekanisme penyesuaian dinamis dalam strategi saat ini relatif sederhana, dapat dioptimalkan lebih lanjut, seperti mempertimbangkan lebih banyak faktor (seperti volume lalu lintas, volatilitas, dll.), Menggunakan algoritma yang lebih canggih (seperti algoritma adaptasi, algoritma pembelajaran mesin, dll.).
Pengelolaan dana yang optimal: Strategi saat ini mengadopsi pengelolaan dana yang setara, dan dapat mempertimbangkan untuk memperkenalkan metode pengelolaan dana yang lebih canggih, seperti Hukum Kelly, Metode Optimalisasi, dan lain-lain, untuk meningkatkan efisiensi dan keuntungan penggunaan dana.
Memperkenalkan Stop Loss: Berdasarkan perdagangan grid, beberapa logika stop loss dapat diperkenalkan, seperti stop loss bergerak, stop loss volatilitas, dan lain-lain, untuk mengurangi risiko strategi lebih lanjut.
Meringkaskan
Strategi hedging risiko perdagangan grid adalah strategi perdagangan kuantitatif dengan tingkat otomatisasi tinggi, adaptif, dan dapat dikontrol risiko. Dengan perdagangan grid dan penyesuaian jaringan dinamis, strategi dapat menghasilkan keuntungan dalam berbagai situasi, tetapi juga dapat mengendalikan risiko. Namun, strategi mungkin tidak berkinerja baik dalam situasi tren, dan biaya penanganan mungkin berdampak pada pendapatan, sehingga perlu lebih banyak pengoptimalan dan perbaikan dalam aplikasi nyata. Secara keseluruhan, strategi ini memberikan pemikiran perdagangan kuantitatif yang lebih matang yang layak untuk diteliti dan diterapkan lebih lanjut.
/*backtest
start: 2024-03-19 00:00:00
end: 2024-03-23 00:00:00
period: 5m
basePeriod: 1m
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)