Strategi Jaringan Dinamis Adaptif Pendek dan Panjang

Penulis:ChaoZhang, Tanggal: 2024-03-19 14:19:12
Tag:

Gambaran umum

Ini adalah strategi perdagangan grid dinamis adaptif panjang-pendek berdasarkan Pine Script. Ide inti dari strategi ini adalah untuk secara otomatis menghitung batas atas dan bawah grid berdasarkan harga tertinggi dan terendah baru-baru ini atau rata-rata bergerak sederhana, dan kemudian membagi kisaran ini secara merata menjadi beberapa garis grid. Ketika harga mencapai garis grid tertentu, itu akan membuka posisi panjang atau menutup posisi di tingkat itu. Dengan cara ini, strategi dapat terus membuka dan menutup posisi di pasar kisaran untuk menangkap spread harga. Pada saat yang sama, dengan menyesuaikan batas-batas grid secara dinamis, itu juga dapat beradaptasi dengan tren pasar yang berbeda.

Prinsip Strategi

Menghitung batas grid. Berdasarkan pilihan pengguna, batas dapat dihitung dari titik tertinggi dan terendah dari N lilin terbaru, dengan opsi untuk memperluas atau mempersempit kisaran dengan persentase; atau mereka dapat didasarkan pada rata-rata bergerak sederhana dari harga penutupan N lilin terbaru, dengan opsi untuk mengatur rasio penyimpangan ke atas dan ke bawah.
Menghasilkan array garis grid. Menurut jumlah garis grid yang ditetapkan, bagi rentang grid secara merata untuk menghasilkan array harga garis grid.
Jika harga penutupan saat ini kurang dari harga garis grid dan tidak ada posisi pada garis grid itu, maka buka posisi panjang di tingkat itu. Dengan cara ini, ketika harga mencapai garis grid yang lebih tinggi, itu akan terus menambahkan posisi.
exit/reduction position. melintasi garis grid dari atas ke bawah. jika harga penutupan saat ini lebih besar dari harga garis grid dan ada posisi pada garis grid di bawah, maka tutup posisi panjang pada garis grid bawah. dengan cara ini, ketika harga turun kembali, itu akan terus mengurangi posisi.
Jika fungsi grid dinamis dipilih, batas atas dan bawah grid dan array garis grid akan dihitung ulang pada setiap lilin, sehingga grid dapat terus beradaptasi dengan perubahan pasar.

Analisis Keuntungan

Strategi perdagangan grid dapat beradaptasi dengan pasar rangebound dan tren. Di pasar rangebound, strategi grid dapat terus membuka dan menutup posisi untuk mendapatkan spread harga; di pasar tren, karena grid mengikuti pergerakan harga, ia juga dapat mempertahankan posisi tertentu untuk mendapatkan keuntungan tren.
Risiko yang dapat dikendalikan. Ukuran posisi setiap pembukaan ditentukan oleh jumlah grid yang ditetapkan, sehingga eksposur risiko tunggal kecil dan dapat dikendalikan. Pada saat yang sama, karena mencapai garis grid atas akan menutup posisi untuk keuntungan, itu juga melindungi potensi kerugian sampai batas tertentu.
Tingkat otomatisasi yang tinggi. Strategi ini pada dasarnya dapat berjalan sepenuhnya otomatis tanpa intervensi manual, yang cocok untuk investor yang membutuhkan pengembalian stabil jangka panjang.
Pengguna dapat mengatur secara fleksibel jumlah jalur grid, parameter grid dinamis, dll sesuai dengan karakteristik pasar untuk mengoptimalkan kinerja strategi.

Analisis Risiko

Risiko angsa hitam. Jika terjadi kemerosotan pasar yang ekstrem, jika harga langsung jatuh di bawah garis grid terendah, strategi akan penuh posisi dan menghadapi penarikan yang lebih besar. Untuk mengurangi risiko ini, kondisi stop-loss dapat diatur untuk menutup semua posisi setelah kerugian mencapai ambang batas.
Pengaturan parameter grid yang tidak tepat. Jika kepadatan grid terlalu tinggi, spread dari setiap buka dan tutup akan sangat kecil, dan biaya transaksi dapat mengikis sebagian besar keuntungan. Jika lebar grid terlalu besar, rasio pembukaan satu kali tinggi dan eksposur risiko besar. Karakteristik aset yang mendasari perlu dievaluasi dengan cermat untuk memilih parameter grid yang sesuai.
Risiko dasar. Strategi ini menetapkan kondisi pembukaan dan penutupan berdasarkan harga saat ini. Di pasar seperti berjangka, jika harga kontrak sangat berbeda dari harga yang mendasari, harga pembukaan dan penutupan yang sebenarnya dapat menyimpang secara signifikan dari harapan.

Arahan Optimasi

Tambahkan filter tren. Strategi grid tidak berkinerja baik di pasar tren sepihak. Indikator tren dapat ditambahkan sebagai filter, seperti hanya mengaktifkan grid ketika ADX berada di bawah ambang batas, dan menutup grid ketika tren jelas, hanya memegang posisi sepihak.
Optimasi sinyal. sinyal lain dapat ditumpuk berdasarkan grid, seperti grid + moving average, yaitu, pembukaan dan penutupan terutama ditentukan oleh grid, tetapi hanya membuka posisi ketika harga melintasi rata-rata bergerak tertentu, jika tidak jangan membuka posisi. Ini dapat mengurangi biaya pembukaan dan penutupan yang sering.
Manajemen Posisi. Saat ini, posisi setiap grid dalam strategi tetap. Hal ini dapat diatur untuk secara tepat mengurangi posisi setiap grid ketika harga jauh dari harga rata-rata pasar, dan meningkatkan posisi ketika dekat dengan harga rata-rata pasar untuk meningkatkan efisiensi penggunaan modal.
Densitas grid adaptif. Mengatur kepadatan grid secara dinamis sesuai dengan volatilitas harga. Ketika volatilitas tinggi, jumlah grid dapat ditingkatkan dengan tepat; ketika volatilitas rendah, jumlah grid dapat dikurangi. Ini dapat mengoptimalkan lebar grid dan meningkatkan pemanfaatan modal.

Ringkasan

Dengan menggunakan grid dinamis adaptif, strategi ini dapat sering membuka dan menutup posisi untuk mendapatkan spread harga di pasar rangebound, dan juga dapat mempertahankan tingkat tertentu dari arah eksposur di pasar tren untuk mendapatkan keuntungan tren. Ini adalah strategi kuantitatif jangka menengah hingga panjang dengan kemampuan beradaptasi yang kuat. Dengan mengatur grid yang memicu logika dan manajemen posisi secara wajar, pengembalian yang stabil dapat dicapai. Namun, perlu untuk memperhatikan risiko kondisi pasar ekstrem dan kesenjangan harga, yang membutuhkan pengaturan kondisi stop-loss yang tepat untuk dikendalikan. Selain itu, ada ruang tambahan untuk optimasi dalam pengaturan parameter dan manajemen risiko. Ketahanan dan profitabilitas strategi dapat ditingkatkan dengan memperkenalkan penyaringan tren, superposisi sinyal, manajemen posisi, kepadatan grid adaptif dan sarana lainnya.

// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © jcloyd

//@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