Stratégies de couverture des risques liés aux transactions en réseau

Auteur:ChaoZhang est là., Date: 2024-03-27 18h15 et 12h
Les étiquettes:

网格交易风险对冲策略

Résumé de la stratégie

La stratégie de couverture de risque de la négociation sur la grille est une stratégie de négociation quantitative basée sur la notion de négociation sur la grille, combinée à l'idée de couverture de risque. Cette stratégie permet de profiter des fluctuations des prix en plaçant plusieurs ordres d'achat et de vente dans une plage de prix prédéfinie.

Les principes stratégiques

Le principe de base de cette stratégie est la négociation sur la grille. Tout d'abord, la limite supérieure et inférieure de la grille et le nombre de lignes de grille sont déterminés en fonction des paramètres définis par l'utilisateur.

Dans le même temps, pour réduire les risques, la stratégie introduit un mécanisme d'ajustement dynamique des limites de la grille. Selon le choix de l'utilisateur, les limites supérieures et inférieures de la grille peuvent être ajustées automatiquement de deux manières: 1) en fonction des prix les plus élevés et les plus bas de la dernière période, en tenant compte du décalage des paramètres de l'utilisateur; 2) en fonction des moyennes mobiles, en tenant compte du décalage des paramètres de l'utilisateur.

De plus, la stratégie consiste à diviser le capital total en N parts pour chaque opération, ce qui réduit le risque d'une seule transaction.

Analyse des avantages

Adaptabilité: grâce à l'ajustement dynamique des frontières de la grille, la stratégie peut s'adapter à différents environnements de marché, qu'il s'agisse de tendances ou de marchés perturbés, et peut s'adapter automatiquement pour obtenir de meilleurs rendements.
Risque contrôlé: la stratégie utilise des fonds équivalents lors de l'ouverture de la position, ce qui réduit le risque d'une transaction unique; en même temps, un mécanisme dynamique d'ajustement des limites du réseau peut réduire le risque que les prix dépassent les limites du réseau.
Haute fréquence de transaction: la grille est généralement plus fréquente et permet de réaliser des profits plus facilement dans des marchés volatiles.
Paramètres flexibles: l'utilisateur peut adapter les différents styles de négociation en fonction de ses préférences: nombre de grilles, limites ascendantes et descendantes, paramètres de réglage dynamique, etc.

L'analyse des risques

La stratégie peut être exposée à un risque plus important si les prix continuent à monter ou à descendre unilatéralement, à dépasser les limites de la grille et que l'ajustement dynamique ne peut pas suivre le rythme des changements de prix.
Frais de traitement: les frais de traitement peuvent avoir une certaine incidence sur les bénéfices en raison de la fréquence élevée des transactions stratégiques.
Les paramètres sont mal définis: si les paramètres sont mal définis, comme un nombre de grilles trop important, des limites de grille déraisonnables, etc., cela peut entraîner une mauvaise performance de la politique.

Les solutions suivantes sont envisageables: 1) dans le cas d'un marché en tendance, l'augmentation de la portée de l'ajustement des limites du réseau peut être envisagée, ou combinée à une stratégie de tendance; 2) choisir des échanges et des devises avec des frais de traitement moins élevés; 3) les paramètres doivent être suffisamment revus et optimisés avant la mise en œuvre.

Optimisation

Combinaison avec d'autres stratégies: une stratégie de trading de grille peut être envisagée en combinaison avec d'autres types de stratégies, telles que les stratégies de tendance, les stratégies de régression de la moyenne, etc., afin d'améliorer l'adaptabilité et la stabilité de la stratégie.
Amélioration des mécanismes d'ajustement dynamique: les mécanismes d'ajustement dynamique de la stratégie actuelle sont relativement simples et peuvent être optimisés en tenant compte de plus de facteurs (comme le volume de transactions, le taux de fluctuation, etc.) et en utilisant des algorithmes plus avancés (comme les algorithmes d'auto-adaptation, les algorithmes d'apprentissage automatique, etc.).
Optimisation de la gestion des fonds: la stratégie actuelle utilise la gestion des fonds équivalents, et l'introduction de méthodes de gestion des fonds plus avancées, telles que la loi Kelly, la méthode la plus optimale, etc., peut être envisagée pour améliorer encore l'efficacité et les rendements des fonds.
Introduction d'un stop-loss: sur la base de la négociation de la grille, il est possible d'introduire des logiques de stop-loss, telles que les stop-loss mobiles, les stop-loss à volatilité, etc., afin de réduire davantage le risque stratégique.

Résumé

La stratégie de couverture de risque de la grille de négociation est une stratégie de négociation quantitative hautement automatisée, adaptable et maîtrisée des risques. Grâce à la grille de négociation et à l'ajustement dynamique de la grille, la stratégie peut être rentable dans une variété de marchés tout en contrôlant les risques. Cependant, la stratégie peut mal fonctionner dans les marchés tendance et les frais de traitement peuvent avoir un impact sur les bénéfices, ce qui nécessite une optimisation et une amélioration supplémentaires dans les applications pratiques.

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

En savoir plus

2019 - FMZ - Inventeur quantifié