Strategi Perdagangan Grid Kuantum yang Sesuai Sendiri

Penulis:ChaoZhang, Tarikh: 2024-02-02 18:08:22
Tag:

Ringkasan

Strategi ini menubuhkan grid dagangan dinamik untuk mencapai keuntungan yang stabil di tengah-tengah pasaran yang tidak menentu. Ia secara automatik mengira jarak grid dan had atas / bawah berdasarkan bilangan garis grid yang telah ditetapkan. Apabila harga memecahkan setiap garis grid, kedudukan panjang / pendek akan dibina dalam kumpulan. Keuntungan akan diambil apabila harga mencapai garis grid asal lagi. Strategi ini menyokong penyesuaian parameter grid secara manual dan automatik untuk menyesuaikan diri dengan keadaan pasaran yang berubah.

Logika Strategi

Mengira sempadan grid dan array harga garis grid berdasarkan parameter input.
Apabila harga jatuh di bawah garis grid tanpa pesanan yang sepadan, pesanan panjang akan diletakkan pada harga garis grid. Apabila harga meningkat di atas garis grid sebelumnya (yang pertama dikecualikan) dengan kedudukan sedia ada, pesanan panjang baris sebelumnya akan ditutup.
Jika penyesuaian automatik diaktifkan, had atas / bawah grid, jarak grid dan array grid akan dikira semula secara berkala berdasarkan data candlestick baru-baru ini.

Analisis Kelebihan

Mencapai keuntungan yang stabil di tengah-tengah pasaran yang tidak menentu. Posisi panjang / pendek dibina dan ditutup dalam kumpulan pada tahap harga yang berbeza untuk mencapai keuntungan keseluruhan.
Sokong penyesuaian parameter manual dan automatik. Penyesuaian manual menawarkan kawalan yang lebih baik tetapi memerlukan campur tangan. Penyesuaian automatik mengurangkan beban kerja dan menyesuaikan diri dengan dinamik pasaran yang berubah.
Hilang maksimum dibatasi dengan mengehadkan jumlah garis grid maksimum. Apabila harga melanggar semua garis grid, risiko terkandung.
Penyesuaian jarak grid untuk menyesuaikan keuntungan / kerugian setiap dagangan.

Analisis Risiko

Risiko terperangkap dalam whipswa. turun naik harga yang kerap dalam julat grid boleh membawa kepada kerugian.
Memerlukan modal permulaan yang mencukupi.
Nombor grid yang melampau menjejaskan keuntungan. Terlalu sedikit grid gagal memanfaatkan sepenuhnya turun naik sementara terlalu banyak grid membawa kepada keuntungan minimum setiap perdagangan. Ujian yang luas diperlukan untuk menentukan tetapan optimum.
Penyesuaian automatik risiko manipulasi harga. Bergantung pada lilin baru-baru ini yang boleh dipengaruhi oleh operasi harga jangka pendek.

Pengoptimuman

Memperkenalkan logik stop loss seperti trailing stop loss untuk lebih mengehadkan risiko penurunan setiap arah.
Mengoptimumkan parameter grid melalui pembelajaran mesin. Uji parameter yang berbeza dalam keadaan pasaran dan latih model ML untuk mendapatkan parameter yang optimum dan beradaptasi.
Menggabungkan penunjuk teknikal tambahan. Menilai kekuatan trend semasa dengan penunjuk seperti MACD dan RSI untuk membimbing kuantiti grid dan penyesuaian parameter.
Meningkatkan kawalan risiko dengan menetapkan peratusan pengeluaran maksimum yang dibenarkan.

Kesimpulan

Strategi ini sepenuhnya memanfaatkan ciri-ciri pasaran yang tidak menentu dan mencapai keuntungan yang stabil melalui rangka kerja perdagangan grid dinamik yang menawarkan fleksibiliti parameter dan kemudahan operasi.

/*backtest
start: 2024-01-02 00:00:00
end: 2024-02-01 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)

Lebih lanjut

2019 FMZ - Semua hak dilindungi