Tài nguyên đang được tải lên... tải...

Chiến lược giao dịch mạng lưới tiền điện tử thích nghi dựa trên trọng tài

Tác giả:ChaoZhang, Ngày: 2024-01-19 14:17:50
Tags:

img

Tổng quan

Đây là một chiến lược giao dịch lưới tiền điện tử thích nghi dựa trên phương pháp giao dịch lưới cho chênh lệch giá. Nó có thể tự động điều chỉnh phạm vi giá của giao dịch lưới dựa trên biến động thị trường và tiến hành giao dịch chênh lệch giá hiệu quả trong phạm vi giá đó.

Nguyên tắc chiến lược

Ý tưởng cốt lõi của chiến lược này là:

  1. Tính năng tính toán một phạm vi giá lưới giao dịch dựa trên giá cao và thấp trong lịch sử.

  2. Đặt N đường lưới ở khoảng thời gian bằng nhau trong phạm vi giá này.

  3. Khi giá vượt qua mỗi đường lưới, mở các vị trí dài hoặc ngắn với một số lượng cố định.

  4. Trọng tài giữa các đường lưới liền kề và đóng các vị trí để kiếm lợi nhuận.

  5. Khi giá quay trở lại phạm vi lưới, tiếp tục mở các vị trí với chi phí biên của các đường lưới.

  6. Lặp lại chu kỳ này cho giao dịch chênh lệch tần số cao trong phạm vi giá lưới.

Cụ thể, chiến lược đầu tiên tính toán giới hạn trên và dưới của lưới trong thời gian thực theo các thông số cửa sổ lookback được cấu hình (i_boundLookback) và phạm vi biến động (i_boundDev).

Sau đó, các đường lưới N (i_gridQty) được chia đều giữa giới hạn trên và dưới. Giá của các đường lưới này được lưu trữ trong mảng gridLineArr.

Khi giá vượt qua một đường lưới, một số lượng cố định (thủ đô chiến lược chia cho số lưới) được sử dụng để mở các vị trí dài hoặc ngắn.

Khi giá vượt qua đường lưới liền kề một lần nữa, nó có thể được khớp với các lệnh trước đó để điều chỉnh và đóng các vị trí để kiếm lợi nhuận.

Lặp lại chu kỳ này cho sự điều chỉnh tần số cao trong phạm vi biến động giá.

Phân tích lợi thế

So với các chiến lược lưới truyền thống, lợi thế lớn nhất của chiến lược này là phạm vi lưới được điều chỉnh tự động để thích nghi với biến động thị trường, với các đặc điểm sau:

  1. Hoàn toàn tự động, không cần can thiệp bằng tay.

  2. Có khả năng nắm bắt xu hướng giá và giao dịch theo hướng xu hướng.

  3. Những rủi ro có thể kiểm soát được, tránh những rủi ro đơn phương.

  4. Tần suất giao dịch cao và lợi nhuận.

  5. Dễ hiểu, cấu hình đơn giản.

  6. Sử dụng vốn cao, không dễ bị bắt.

  7. Phản ánh sự thay đổi thị trường trong thời gian thực, phù hợp với giao dịch thuật toán.

Phân tích rủi ro

Mặc dù chiến lược có nhiều lợi thế, nhưng cũng có một số rủi ro, chủ yếu tập trung vào:

  1. Khả năng mất mát lớn hơn trong biến động giá cực đoan.

  2. Cần thời gian nắm giữ phù hợp và cặp giao dịch để kiếm lợi nhuận.

  3. Mức vốn cần phù hợp với phạm vi biến động.

  4. Có thể yêu cầu giám sát và tối ưu hóa các thông số thường xuyên.

Các biện pháp đối phó bao gồm:

  1. Tăng khoảng cách lưới để mở rộng phạm vi lưới.

  2. Chọn các cặp giao dịch ổn định hơn.

  3. Điều chỉnh quy mô vốn để có đủ thanh khoản.

  4. Thiết lập các cơ chế giám sát và cảnh báo tự động.

Hướng dẫn tối ưu hóa

Chiến lược có thể được tối ưu hóa trong các khía cạnh sau:

  1. Mạng lưới động: tự động điều chỉnh các thông số lưới dựa trên sự biến động.

  2. Cơ chế dừng lỗ: thiết lập các vị trí dừng lỗ hợp lý để hạn chế rủi ro cực đoan.

  3. Mạng lưới hợp chất: kết hợp lưới sử dụng các tham số khác nhau cho các khoảng thời gian khác nhau để tối đa hóa việc sử dụng thời gian.

  4. Học máy: sử dụng mạng thần kinh để tự động tối ưu hóa các tham số thay vì các quy tắc.

  5. Thuế trọng tài giữa các thị trường: điều chỉnh giữa các sàn giao dịch hoặc các cặp tiền tệ.

Tóm lại

Tóm lại, đây là một chiến lược giao dịch lưới điện tử thích nghi rất thực tế cho sự điều chỉnh. So với các chiến lược lưới truyền thống, tính năng lớn nhất của nó là điều chỉnh tự động phạm vi lưới dựa trên những thay đổi của thị trường, cho phép các nhà giao dịch cấu hình phạm vi giao dịch của riêng họ. Logic chiến lược rõ ràng và dễ hiểu và cấu hình, phù hợp với các nhà đầu tư cá nhân với một số nền tảng và cũng là một mẫu cho các thuật toán giao dịch. Với việc điều chỉnh tham số thích hợp, hiệu quả sử dụng vốn rất cao có thể đạt được.


/*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)





Thêm nữa