Strategi lindung nilai risiko perdagangan jaringan

Penulis:ChaoZhang, Tanggal: 2024-03-27 18:15:12
Tag:

Tinjauan Strategi

Strategi Hedging Risiko Perdagangan Grid adalah strategi perdagangan kuantitatif yang didasarkan pada konsep perdagangan grid, dikombinasikan dengan gagasan hedging risiko. Strategi menetapkan beberapa pesanan beli dan jual dalam kisaran harga yang telah ditentukan untuk mendapatkan keuntungan dari fluktuasi harga. Pada saat yang sama, strategi memperkenalkan mekanisme hedging risiko yang secara dinamis menyesuaikan batas grid untuk beradaptasi dengan perubahan lingkungan pasar dan mengurangi risiko strategi.

Prinsip Strategi

Prinsip inti dari strategi ini adalah perdagangan grid. Pertama, berdasarkan parameter yang ditetapkan oleh pengguna, batas atas dan bawah grid dan jumlah garis grid ditentukan. Kemudian, pesanan beli dan jual ditempatkan di garis grid: ketika harga menyentuh garis grid, jika sebelumnya tidak ada pesanan di garis grid itu, posisi dibuka; jika sebelumnya ada pesanan, posisi ditutup. Dengan cara ini, strategi dapat terus membuka dan menutup posisi dalam fluktuasi harga untuk menghasilkan keuntungan.

Pada saat yang sama, untuk mengurangi risiko, strategi memperkenalkan mekanisme penyesuaian batas grid dinamis. Menurut pilihan pengguna, batas atas dan bawah grid dapat disesuaikan secara otomatis dengan dua cara: 1) berdasarkan harga tertinggi dan terendah dalam periode terakhir, dengan mempertimbangkan penyimpangan yang ditetapkan oleh pengguna; 2) berdasarkan garis rata-rata bergerak, dengan mempertimbangkan penyimpangan yang ditetapkan oleh pengguna. Dengan menyesuaikan batas grid secara dinamis, grid selalu dapat berpusat di sekitar harga saat ini, sehingga mengurangi risiko harga menerobos batas grid.

Selain itu, ketika membuka posisi, strategi membagi total dana menjadi N bagian yang sama, dan setiap kali membuka posisi, ia menggunakan jumlah dana yang sama, yang dapat mengurangi risiko satu transaksi.

Analisis Keuntungan

Kemampuan beradaptasi yang kuat: Dengan menyesuaikan batas-batas jaringan secara dinamis, strategi dapat beradaptasi dengan lingkungan pasar yang berbeda.
Risiko yang dapat dikendalikan: Strategi menggunakan jumlah dana yang sama saat membuka posisi, sehingga risiko satu transaksi kecil; pada saat yang sama, mekanisme penyesuaian batas grid dinamis dapat mengurangi risiko harga menerobos batas grid.
Frekuensi perdagangan yang tinggi: Karena grid biasanya memiliki banyak pesanan, frekuensi perdagangan tinggi, sehingga lebih mudah untuk mendapatkan keuntungan di pasar yang tidak stabil.
Parameter fleksibel: Pengguna dapat mengatur jumlah grid, batas atas dan bawah, parameter penyesuaian dinamis, dll sesuai dengan preferensi mereka, sehingga beradaptasi dengan gaya perdagangan yang berbeda.

Analisis Risiko

Kinerja yang buruk di pasar tren: Jika harga terus naik atau turun secara sepihak, menerobos batas-batas grid, dan penyesuaian dinamis tidak dapat mengikuti kecepatan perubahan harga, strategi dapat menghadapi risiko yang lebih besar.
Biaya transaksi: Karena strategi memiliki frekuensi perdagangan yang tinggi, biaya transaksi dapat berdampak pada pengembalian.
Pengaturan parameter yang tidak benar: Jika parameter ditetapkan secara tidak benar, seperti terlalu banyak garis grid atau pengaturan batas grid yang tidak wajar, hal itu dapat menyebabkan kinerja strategi yang buruk.

Solusi: 1) Di pasar tren, pertimbangkan untuk meningkatkan rentang penyesuaian batas jaringan atau menggabungkan dengan strategi tren; 2) Pilih bursa dan mata uang dengan biaya transaksi yang lebih rendah; 3) Sebelum operasi yang sebenarnya, parameter perlu sepenuhnya backtested dan dioptimalkan.

Arahan Optimasi

Menggabungkan dengan strategi lain: Pertimbangkan untuk menggabungkan strategi perdagangan grid dengan jenis strategi lain, seperti strategi tren, strategi reversi rata-rata, dll., Untuk meningkatkan kemampuan beradaptasi dan stabilitas strategi.
Meningkatkan mekanisme penyesuaian dinamis: Mekanisme penyesuaian dinamis saat ini dalam strategi relatif sederhana dan dapat dioptimalkan lebih lanjut, seperti mempertimbangkan lebih banyak faktor (seperti volume perdagangan, volatilitas, dll.), Dan mengadopsi algoritma yang lebih maju (seperti algoritma adaptif, algoritma pembelajaran mesin, dll.).
Mengoptimalkan manajemen dana: Saat ini, strategi mengadopsi manajemen dana yang setara. Kita dapat mempertimbangkan untuk memperkenalkan metode manajemen dana yang lebih maju, seperti Kriteria Kelly, metode optimalisasi, dll., Untuk lebih meningkatkan efisiensi pemanfaatan dana dan pengembalian.
Memperkenalkan mengambil keuntungan dan stop loss: Berdasarkan perdagangan grid, beberapa mengambil keuntungan dan stop loss logika dapat diperkenalkan, seperti bergerak mengambil keuntungan dan stop loss, volatilitas mengambil keuntungan dan stop loss, dll, untuk lebih mengurangi risiko strategi.

Ringkasan

Strategi Hedging Risiko Perdagangan Grid adalah strategi perdagangan kuantitatif yang sangat otomatis, dapat beradaptasi, dan dapat dikontrol risiko. Melalui perdagangan grid dan penyesuaian grid dinamis, strategi dapat menghasilkan keuntungan dalam berbagai kondisi pasar sambil mengendalikan risiko. Namun, strategi dapat berkinerja buruk di pasar tren, dan biaya transaksi dapat berdampak pada pengembalian. Oleh karena itu, optimasi dan peningkatan lebih lanjut diperlukan dalam aplikasi praktis. Secara umum, strategi memberikan ide perdagangan kuantitatif yang relatif matang yang layak untuk penelitian dan aplikasi 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)

Lebih banyak

2019 FMZ - Semua hak dilindungi