Strategi lindung nilai risiko perdagangan grid

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

img

Ringkasan Strategi

Strategi lindung nilai risiko perdagangan grid adalah strategi perdagangan kuantitatif berdasarkan konsep perdagangan grid, digabungkan dengan idea lindung nilai risiko. Strategi menetapkan beberapa pesanan beli dan jual dalam julat harga yang telah ditentukan untuk mendapat keuntungan dari turun naik harga. Pada masa yang sama, strategi memperkenalkan mekanisme lindung nilai risiko yang secara dinamik menyesuaikan sempadan grid untuk menyesuaikan diri dengan perubahan dalam persekitaran pasaran dan mengurangkan risiko strategi.

Prinsip Strategi

Prinsip utama strategi ini adalah perdagangan grid. Pertama, berdasarkan parameter yang ditetapkan oleh pengguna, sempadan atas dan bawah grid dan bilangan garis grid ditentukan. Kemudian, pesanan beli dan jual diletakkan pada garis grid: apabila harga menyentuh garis grid, jika tidak ada pesanan pada garis grid itu sebelumnya, kedudukan dibuka; jika ada pesanan sebelumnya, kedudukan ditutup. Dengan cara ini, strategi dapat terus membuka dan menutup kedudukan dalam turun naik harga untuk membuat keuntungan.

Pada masa yang sama, untuk mengurangkan risiko, strategi memperkenalkan mekanisme pelarasan sempadan grid dinamik. Menurut pilihan pengguna, sempadan atas dan bawah grid boleh diselaraskan secara automatik dengan dua cara: 1) berdasarkan harga tertinggi dan terendah dalam tempoh baru-baru ini, dengan mengambil kira penyimpangan yang ditetapkan oleh pengguna; 2) berdasarkan garis purata bergerak, dengan mengambil kira penyimpangan yang ditetapkan oleh pengguna. Dengan menyesuaikan sempadan grid secara dinamik, grid sentiasa boleh berpusat di sekitar harga semasa, sehingga mengurangkan risiko harga memecahkan sempadan grid.

Di samping itu, apabila membuka kedudukan, strategi membahagikan jumlah dana ke dalam N bahagian yang sama, dan setiap kali ia membuka kedudukan, ia menggunakan jumlah dana yang sama, yang dapat mengurangkan risiko satu transaksi.

Analisis Kelebihan

  1. Kemampuan penyesuaian yang kuat: Dengan menyesuaikan sempadan grid secara dinamik, strategi dapat menyesuaikan diri dengan persekitaran pasaran yang berbeza. Sama ada dalam trend atau pasaran yang tidak menentu, ia boleh menyesuaikan diri secara automatik untuk mendapatkan pulangan yang lebih baik.

  2. Risiko yang boleh dikawal: Strategi menggunakan jumlah dana yang sama ketika membuka kedudukan, jadi risiko satu transaksi kecil; pada masa yang sama, mekanisme pelarasan sempadan grid dinamik dapat mengurangkan risiko harga memecahkan sempadan grid.

  3. Frekuensi perdagangan yang tinggi: Oleh kerana grid biasanya mempunyai banyak pesanan, frekuensi perdagangan tinggi, menjadikannya lebih mudah untuk mendapat keuntungan di pasaran yang tidak menentu.

  4. Parameter fleksibel: Pengguna boleh menetapkan bilangan grid, sempadan atas dan bawah, parameter pelarasan dinamik, dan lain-lain mengikut pilihan mereka, dengan itu menyesuaikan diri dengan gaya perdagangan yang berbeza.

Analisis Risiko

  1. Prestasi yang lemah di pasaran trend: Jika harga terus meningkat atau jatuh secara sepihak, memecahkan sempadan grid, dan penyesuaian dinamik tidak dapat mengikuti kelajuan perubahan harga, strategi mungkin menghadapi risiko yang lebih besar.

  2. Bayaran urus niaga: Oleh kerana strategi mempunyai kekerapan perdagangan yang tinggi, yuran urus niaga mungkin mempunyai kesan tertentu terhadap pulangan.

  3. Tetapan parameter yang tidak betul: Jika parameter ditetapkan dengan tidak betul, seperti terlalu banyak garis grid atau tetapan sempadan grid yang tidak munasabah, ia boleh menyebabkan prestasi strategi yang buruk.

Penyelesaian: 1) Dalam pasaran trend, pertimbangkan untuk meningkatkan julat pelarasan sempadan grid atau menggabungkan dengan strategi trend; 2) Pilih bursa dan mata wang dengan yuran transaksi yang lebih rendah; 3) Sebelum operasi sebenar, parameter perlu diuji sepenuhnya dan dioptimumkan.

Arahan pengoptimuman

  1. Gabungkan dengan strategi lain: Pertimbangkan untuk menggabungkan strategi perdagangan grid dengan jenis strategi lain, seperti strategi trend, strategi pembalikan purata, dan lain-lain, untuk meningkatkan kebolehan menyesuaikan diri dan kestabilan strategi.

  2. Meningkatkan mekanisme pelarasan dinamik: Mekanisme pelarasan dinamik semasa dalam strategi agak mudah dan boleh dioptimumkan lagi, seperti mempertimbangkan lebih banyak faktor (seperti jumlah dagangan, turun naik, dll.), Dan mengamalkan algoritma yang lebih maju (seperti algoritma adaptif, algoritma pembelajaran mesin, dll.).

  3. Mengoptimumkan pengurusan dana: Pada masa ini, strategi mengamalkan pengurusan dana yang sama. Kita boleh mempertimbangkan pengenalan kaedah pengurusan dana yang lebih maju, seperti Kriteria Kelly, kaedah pengoptimuman, dll., untuk meningkatkan lagi kecekapan penggunaan dana dan pulangan.

  4. Memperkenalkan mengambil keuntungan dan menghentikan kerugian: Berdasarkan perdagangan grid, beberapa mengambil keuntungan dan menghentikan kerugian logik boleh diperkenalkan, seperti bergerak mengambil keuntungan dan menghentikan kerugian, turun naik mengambil keuntungan dan menghentikan kerugian, dan lain-lain, untuk mengurangkan lagi risiko strategi.

Ringkasan

Strategi Hedging Risiko Dagangan Grid adalah strategi perdagangan kuantitatif yang sangat automatik, mudah disesuaikan, dan boleh dikawal risiko. Melalui perdagangan grid dan pelarasan grid dinamik, strategi ini dapat memperoleh keuntungan dalam pelbagai keadaan pasaran sambil mengawal risiko. Walau bagaimanapun, strategi ini mungkin berprestasi buruk di pasaran trend, dan yuran transaksi mungkin memberi kesan kepada pulangan. Oleh itu, pengoptimuman dan penambahbaikan lanjut diperlukan dalam aplikasi praktikal. Secara umum, strategi ini menyediakan idea perdagangan kuantitatif yang agak matang yang bernilai penyelidikan dan penerapan 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 lanjut