Sumber daya yang dimuat... Pemuatan...

Adaptive Intelligent Grid Trading Strategy (Strategi Perdagangan Grid Cerdas yang Adaptif)

Penulis:ChaoZhang, Tanggal: 2024-01-16 14:51:48
Tag:

img

Gambaran umum

Strategi ini adalah strategi perdagangan grid cerdas adaptif berdasarkan platform TradingView, yang ditulis dalam Pine Script v4.

Logika Strategi

Fitur Utama

  1. Piramida dan Manajemen Uang:

    • Memungkinkan hingga 14 penambahan dalam arah yang sama (pyramiding),
    • Menggunakan strategi berbasis kas untuk mengelola ukuran posisi,
    • Modal awal ditetapkan sebesar 100 USD untuk tujuan simulasi,
    • Sebuah komisi kecil sebesar 0,1% dibebankan untuk setiap perdagangan.
  2. Batas kisi:

    • Pengguna dapat memilih untuk menggunakan batas yang dihitung secara otomatis atau mengatur batas atas dan bawah grid secara manual,
    • Batas otomatis dapat berasal dari harga High & Low terbaru atau dari Simple Moving Average (SMA),
    • Pengguna dapat mendefinisikan periode lookback untuk perhitungan batas dan menyesuaikan penyimpangan untuk memperluas atau mempersempit batas.
  3. Garis kisi:

    • Strategi ini memungkinkan untuk menyesuaikan jumlah jalur grid dalam batas-batas, dengan kisaran yang direkomendasikan antara 3 dan 15,
    • Garis-garis kisi rata-rata antara batas atas dan bawah.

Logika Strategi

  • Masukan:

    • Skrip menempatkan pesanan beli ketika harga jatuh di bawah garis grid dan tidak ada pesanan yang ada yang terkait dengan garis grid tersebut.
    • Setiap jumlah pesanan pembelian dihitung berdasarkan modal awal dibagi dengan jumlah jalur jaringan, disesuaikan dengan harga saat ini.
  • Keluar:

    • Perintah jual dipicu ketika harga naik di atas garis grid, asalkan ada pesanan terbuka yang sesuai dengan garis grid bawah berikutnya.
  • Adaptive Grid:

    • Jika diatur ke batas otomatis, grid beradaptasi dengan perubahan kondisi pasar dengan menghitung ulang batas atas dan bawah dan menyesuaikan grid sesuai.

Analisis Keuntungan

Strategi ini mengintegrasikan sifat sistematis dan pelaksanaan perdagangan grid yang efisien. Memungkinkan piramida dan menggunakan manajemen uang dapat secara efektif mengendalikan risiko. Jaringan yang beradaptasi otomatis sesuai dengan kondisi pasar yang berbeda. Parameter yang dapat disesuaikan memenuhi gaya perdagangan yang berbeda.

Analisis Risiko

Penembusan harga di luar batas jaringan dapat menyebabkan kerugian yang parah. Parameter harus disesuaikan dengan benar atau dikombinasikan dengan stop loss untuk mengendalikan risiko. Juga, perdagangan yang berlebihan meningkatkan biaya transaksi.

Arahan Optimasi

Pertimbangkan untuk menggabungkan dengan filter tren atau mengoptimalkan parameter grid. Stop loss juga dapat membantu mencegah risiko dari pergerakan pasar yang ekstrim.

Kesimpulan

Strategi ini secara sistematis menghasilkan entri dan keluar saat mengelola posisi. Melalui penyesuaian parameter, ia beradaptasi dengan preferensi yang berbeda. Ini menggabungkan sifat berbasis aturan perdagangan grid dengan fleksibilitas perdagangan tren, meringankan kompleksitas operasi sambil mempertahankan ketahanan.


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