Стратегия хеджирования рисков сетевой торговли


Дата создания: 2024-03-27 18:15:12 Последнее изменение: 2024-03-27 18:15:12
Копировать: 0 Количество просмотров: 1321
1
Подписаться
1617
Подписчики

Стратегия хеджирования рисков сетевой торговли

Обзор стратегии

Стройная торговая стратегия рискового хеджирования - это количественная торговая стратегия, основанная на концепции торговой сетки, в сочетании с идеей хеджирования риска. Эта стратегия позволяет получать прибыль от колебаний цен путем размещения нескольких ордеров на покупку и продажу в заданном ценовом диапазоне. В то же время, эта стратегия также вводит механизм рискового хеджирования, динамически регулируя границы сетки, чтобы адаптироваться к изменению рыночной среды, чтобы снизить риски стратегии.

Стратегический принцип

Ключевым принципом стратегии является торгование в сетке. Во-первых, определяется верхняя и нижняя границы сетки и количество линий сетки в соответствии с параметрами, установленными пользователем. Затем на сетчатой линии размещаются ордера на покупку и продажу.

В то же время, в целях снижения риска, в стратегии также внедрен механизм динамической коррекции границ сетки. В зависимости от выбора пользователя, верхняя и нижняя границы сетки могут автоматически корректироваться двумя способами: 1) в соответствии с наивысшей и наименьшей ценой за последнее время и с учетом смещения, установленного пользователем; 2) в соответствии с подвижной средней и с учетом смещения, установленного пользователем.

Кроме того, при открытии позиции стратегия делит общий капитал на N частей и т. д., используя при каждом открытии позиции одинаковую сумму, что снижает риск однократной сделки.

Анализ преимуществ

  1. Адаптируемость: благодаря динамической корректировке границ сетки, стратегия может адаптироваться к различным рыночным условиям, будь то тенденции или колебания, и может автоматически адаптироваться, чтобы получить лучшую прибыль.

  2. Контролируемый риск: стратегия использует равный объем средств при открытии позиции, одна сделка имеет меньший риск; в то же время, механизм корректировки границ динамической сетки может снизить риск прорыва цены через границы сетки.

  3. Высокая частота сделок: из-за того, что сеть обычно размещает больше заказов, частота сделок выше, и легче получить прибыль в волатильных ситуациях.

  4. Гибкость параметров: пользователь может адаптироваться к различным стилям торгов в зависимости от своих предпочтений, количества сеток, верхних и нижних границ, динамически регулируемых параметров и т. Д.

Анализ рисков

  1. Недостаточная производительность в трендовых условиях: стратегия может быть подвержена большому риску, если цены будут продолжать расти или падать в одностороннем порядке, нарушая границы сетки, и динамическая коррекция не будет идти в ногу со скоростью изменения цены.

  2. Процедура оплаты: из-за высокой частоты стратегических сделок комиссионные могут оказать определенное влияние на прибыль.

  3. Неправильная настройка параметров: неправильная настройка параметров может привести к плохой работе стратегии, например, избыточному количеству решётки, неразумной настройке границ решётки и т. д.

Решение: 1) в случае тренда, можно рассмотреть возможность увеличения границ сетки или в сочетании с трендовой стратегией; 2) выбор бирж и монет с более низкими комиссионными; 3) необходимость полной обратной проверки и оптимизации параметров перед фактическим запуском.

Направление оптимизации

  1. В сочетании с другими стратегиями: можно рассмотреть возможность объединения стратегии торговой сетки с другими типами стратегий, такими как стратегия тренда, стратегия средней величины, чтобы повысить адаптивность и стабильность стратегии.

  2. Улучшение механизмов динамической корректировки: механизмы динамической корректировки в нынешней стратегии относительно просты и могут быть оптимизированы, например, с учетом большего количества факторов (например, трафика, волатильности и т. д.), с использованием более продвинутых алгоритмов (например, адаптивных алгоритмов, алгоритмов машинного обучения и т. д.).

  3. Оптимизация управления капиталом: в настоящее время в стратегии используется эквивалентное управление капиталом, можно рассмотреть возможность внедрения более продвинутых методов управления капиталом, таких как закон Келли, оптимальный метод и т. Д., Чтобы еще больше повысить эффективность использования капитала и прибыль.

  4. Введение стоп-стоп: на основе сетчатой торговли можно ввести некоторые логики стоп-стоп, такие как движущийся стоп-стоп, волатильный стоп-стоп и т. д., чтобы еще больше снизить риск стратегии.

Подвести итог

Стратегия хеджирования риска в торговле сеткой - это высокоавтоматизированная, адаптивная и управляемая риском стратегия количественной торговли. Благодаря торговле сеткой и динамической корректировке сети, стратегия может приносить прибыль в различных ситуациях, а также контролировать риск. Однако стратегия может плохо работать в трендовых ситуациях, а комиссионные могут повлиять на прибыль, поэтому в практическом применении требуется дальнейшая оптимизация и улучшение.

Исходный код стратегии
/*backtest
start: 2024-03-19 00:00:00
end: 2024-03-23 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)