В процессе загрузки ресурсов... загрузка...

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

Автор:Чао Чжан, Дата: 2024-03-27 18:15:12
Тэги:

img

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

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

Принцип стратегии

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

В то же время, для снижения рисков, стратегия внедряет механизм динамической корректировки границ сетки. В соответствии с выбором пользователя, верхние и нижние границы сетки могут автоматически корректироваться двумя способами: 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)

Больше