Strategi Dagangan Grid Cryptocurrency Beradaptasi Berdasarkan Arbitraj

Penulis:ChaoZhang, Tarikh: 2024-01-19 14:17:50
Tag:

Ringkasan

Ini adalah strategi perdagangan grid cryptocurrency adaptif berdasarkan metodologi perdagangan grid untuk arbitrase. Ia boleh menyesuaikan julat harga perdagangan grid secara automatik berdasarkan turun naik pasaran dan menjalankan perdagangan arbitrase yang cekap dalam julat harga itu.

Prinsip Strategi

Idea teras strategi ini ialah:

Mengira secara dinamik julat harga grid dagangan berdasarkan harga tinggi dan rendah sejarah.
Tetapkan N garis grid pada selang masa yang sama dalam julat harga ini.
Apabila harga memecahkan setiap garis grid, buka kedudukan panjang atau pendek dengan kuantiti tetap.
Arbitraj antara garis grid bersebelahan dan posisi yang ditutup untuk keuntungan.
Apabila harga kembali memasuki julat grid, terus membuka kedudukan pada kos marginal garis grid.
Ulangi kitaran ini untuk perdagangan arbitraj frekuensi tinggi dalam julat harga grid.

Khususnya, strategi pertama mengira had atas dan bawah grid dalam masa nyata mengikut tetingkap belakang yang dikonfigurasi (i_boundLookback) dan rentang turun naik (i_boundDev) parameter.

Kemudian N garis grid (i_gridQty) dibahagikan secara merata antara had atas dan bawah. Harga garis grid ini disimpan dalam array gridLineArr.

Apabila harga memecahkan garis grid, kuantiti tetap (modal strategi dibahagikan dengan bilangan grid) digunakan untuk membuka kedudukan panjang atau pendek. Rekod pesanan disimpan dalam array orderArr.

Apabila harga menembusi garisan grid bersebelahan lagi, ia boleh dipadankan dengan pesanan sebelumnya untuk arbitrage dan menutup kedudukan untuk keuntungan.

Ulangi kitaran ini untuk arbitraj frekuensi tinggi dalam julat turun naik harga.

Analisis Kelebihan

Berbanding dengan strategi grid tradisional, kelebihan terbesar strategi ini adalah bahawa julat grid disesuaikan secara automatik untuk menyesuaikan diri dengan turun naik pasaran, dengan ciri-ciri berikut:

Secara automatik, tiada campur tangan manual diperlukan.
Mampu menangkap trend harga dan perdagangan ke arah trend.
Risiko yang boleh dikawal, mengelakkan risiko mengejar secara sepihak.
Frekuensi perdagangan yang tinggi dan margin keuntungan.
Mudah difahami, konfigurasi mudah.
Penggunaan modal yang tinggi, tidak mudah terperangkap.
Mencerminkan perubahan pasaran dalam masa nyata, sesuai untuk perdagangan algoritma.

Analisis Risiko

Walaupun strategi ini mempunyai banyak kelebihan, terdapat juga beberapa risiko, terutamanya tertumpu pada:

Kemungkinan kerugian yang lebih besar dalam turun naik harga yang melampau.
Memerlukan tempoh pemegang yang sesuai dan pasangan dagangan untuk mendapat keuntungan.
Skala modal perlu sepadan dengan julat turun naik.
Mungkin memerlukan pemantauan dan pengoptimuman parameter yang kerap.

Tindakan balas termasuk:

Meningkatkan jarak grid untuk meluaskan julat grid.
Pilih pasangan dagangan yang lebih stabil.
Penyesuaian skala modal untuk kecairan yang mencukupi.
Menubuhkan mekanisme pemantauan dan amaran automatik.

Arahan pengoptimuman

Strategi ini boleh dioptimumkan dalam aspek berikut:

Grid dinamik: menyesuaikan parameter grid secara automatik berdasarkan turun naik.
Mekanisme Stop Loss: menetapkan lokasi stop loss yang munasabah untuk mengurangkan risiko yang melampau.
Grid gabungan: menggabungkan grid menggunakan parameter yang berbeza untuk tempoh yang berbeza untuk memaksimumkan penggunaan masa.
Pembelajaran mesin: menggunakan rangkaian saraf untuk mengoptimumkan parameter secara automatik dan bukannya peraturan.
Arbitraj rentas pasaran: arbitrase antara pertukaran atau pasangan mata wang.

Ringkasan

Ringkasnya, ini adalah strategi perdagangan grid crypto adaptif yang sangat praktikal untuk arbitrage. Berbanding dengan strategi grid tradisional, ciri terbesarnya adalah penyesuaian automatik julat grid berdasarkan perubahan pasaran, yang membolehkan peniaga mengkonfigurasi julat perdagangan mereka sendiri. Logik strategi jelas dan mudah difahami dan dikonfigurasi, sesuai untuk pelabur individu dengan beberapa asas dan juga sebagai templat untuk algoritma perdagangan. Dengan penyesuaian parameter yang betul, kecekapan penggunaan modal yang sangat tinggi dapat dicapai.

/*backtest
start: 2024-01-11 00:00:00
end: 2024-01-18 00:00:00
period: 1m
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

2019 FMZ - Semua hak dilindungi