Sumber daya yang dimuat... Pemuatan...

Strategi Perdagangan Jaringan Kuantum yang Beradaptasi Sendiri

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

Gambaran umum

Strategi ini menetapkan grid perdagangan yang dinamis untuk mencapai keuntungan yang stabil di tengah pasar yang tidak stabil. Strategi ini secara otomatis menghitung jarak grid dan batas atas / bawah berdasarkan jumlah garis grid yang telah ditetapkan sebelumnya. Ketika harga melewati setiap garis grid, posisi panjang / pendek akan dibangun dalam batch. Keuntungan akan diambil ketika harga mencapai garis grid asli lagi. Strategi ini mendukung penyesuaian manual dan otomatis parameter grid untuk beradaptasi dengan perubahan kondisi pasar.

Logika Strategi

Menghitung batas grid dan array harga garis grid berdasarkan parameter input.
Ketika harga jatuh di bawah garis grid tanpa order yang sesuai, order panjang akan ditempatkan pada harga garis grid. Ketika harga naik di atas garis grid sebelumnya (yang pertama tidak termasuk) dengan posisi yang ada, order panjang dari baris sebelumnya akan ditutup.
Jika penyesuaian otomatis diaktifkan, batas atas/bawah grid, jarak grid dan array grid akan dihitung ulang secara berkala berdasarkan data candlestick terbaru.

Analisis Keuntungan

Mencapai keuntungan yang stabil di tengah volatilitas pasar Posisi panjang/pendek dibangun dan ditutup dalam jumlah besar pada tingkat harga yang berbeda untuk mencapai keuntungan keseluruhan.
Mendukung penyesuaian parameter manual dan otomatis. Penyesuaian manual menawarkan kontrol yang lebih baik tetapi membutuhkan intervensi. Penyesuaian otomatis mengurangi beban kerja dan beradaptasi dengan perubahan dinamika pasar.
Jika harga melanggar semua garis jaringan, risiko terkendali.
Tune grid spacing untuk menyesuaikan profit/loss per trade. spacing yang lebih kecil mengurangi eksposur per trade.

Analisis Risiko

Risiko terjebak di whipswa. osilasi harga yang sering dalam rentang grid dapat menyebabkan kerugian.
Membutuhkan modal awal yang memadai. Pendanaan yang tidak cukup tidak dapat mendukung jalur jaringan yang cukup.
Jumlah grid yang ekstrim merugikan keuntungan. Terlalu sedikit grid gagal memanfaatkan sepenuhnya volatilitas sementara terlalu banyak grid mengarah pada keuntungan minimal per perdagangan. pengujian ekstensif diperlukan untuk menentukan pengaturan optimal.
Auto adjustment risiko manipulasi harga. Bergantung pada candlesticks baru-baru ini yang dapat dipengaruhi oleh operasi harga jangka pendek.

Optimalisasi

Memperkenalkan logika stop loss seperti trailing stop loss untuk lebih membatasi risiko penurunan per arah.
Mengoptimalkan parameter grid melalui pembelajaran mesin. Uji parameter yang berbeda dalam kondisi pasar dan melatih model ML untuk mendapatkan parameter yang optimal dan adaptif.
Menggabungkan indikator teknis tambahan. Menilai kekuatan tren saat ini dengan indikator seperti MACD dan RSI untuk memandu kuantitas grid dan pengaturan parameter.
Meningkatkan pengendalian risiko dengan menetapkan persentase penarikan maksimum yang diizinkan.

Kesimpulan

Strategi ini sepenuhnya memanfaatkan karakteristik pasar yang tidak stabil dan mencapai keuntungan yang stabil melalui kerangka perdagangan grid dinamis yang menawarkan fleksibilitas 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 banyak

2019 FMZ - Semua hak dilindungi