Stratégie de couverture des risques liés au trading sur grille


Date de création: 2024-03-27 18:15:12 Dernière modification: 2024-03-27 18:15:12
Copier: 0 Nombre de clics: 1321
1
Suivre
1617
Abonnés

Stratégie de couverture des risques liés au trading sur grille

Aperçu de la stratégie

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

Principe de stratégie

Le principe central de cette stratégie est le trading de grille. Tout d’abord, en fonction des paramètres définis par l’utilisateur, déterminer le bord supérieur et inférieur de la grille et le nombre de lignes de la grille. Ensuite, placer des ordres de vente et d’achat sur la grille: lorsque le prix touche la grille, s’il n’y a pas d’ordres avant cette grille, il ouvre la position; s’il y a des ordres avant, il est en position de vente.

En outre, 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 période la plus récente, et en tenant compte du déplacement de la valeur définie par l’utilisateur; 2) en fonction des moyennes mobiles, et en tenant compte du déplacement de la valeur définie par l’utilisateur.

En outre, la stratégie consiste à diviser le capital total en N parties, et à utiliser le même montant à chaque fois que l’on ouvre une position, ce qui réduit le risque d’une transaction unique.

Analyse des avantages

  1. Adaptabilité: en ajustant dynamiquement les bordures de la grille, la stratégie peut s’adapter à différents environnements de marché, qu’il s’agisse de tendances ou de chocs, et s’adapter automatiquement pour obtenir de meilleurs rendements.

  2. Risque maîtrisé: la stratégie consiste à utiliser la même quantité de fonds lors de l’ouverture de la position et à réduire le risque de transaction unique. Par ailleurs, le mécanisme d’ajustement dynamique des limites de la grille réduit le risque de rupture des limites de la grille.

  3. Fréquence de négociation élevée: la grille est généralement plus grande en termes d’ordres, ce qui signifie une fréquence de négociation plus élevée et une meilleure rentabilité en cas de volatilité.

  4. Flexibilité des paramètres: l’utilisateur peut adapter les paramètres à ses préférences, en réglant le nombre de grilles, les limites supérieures et inférieures, les paramètres de réglage dynamique, etc., afin de s’adapter à différents styles de négociation.

Analyse des risques

  1. La stratégie peut être exposée à un risque plus élevé si les prix continuent à monter ou à descendre unilatéralement, dépassent les limites de la grille et ne suivent pas le rythme des changements de prix.

  2. Les frais de traitement: En raison de la fréquence élevée des transactions stratégiques, les frais de traitement peuvent avoir une certaine incidence sur les résultats.

  3. Paramètres mal réglés: Si les paramètres sont mal réglés, comme un nombre excessif de grilles, des limites de grille mal réglées, etc., cela peut entraîner une mauvaise performance de la stratégie.

Les solutions: 1) Dans le cas d’une tendance, il est possible d’envisager d’augmenter l’amplitude d’ajustement des limites de la grille, ou de la combiner avec la stratégie de tendance; 2) Choisir des échanges et des devises avec des frais de traitement plus faibles; 3) Avant la mise en œuvre réelle, il est nécessaire de faire un retour d’examen et d’optimiser suffisamment les paramètres.

Direction d’optimisation

  1. Combinaison avec d’autres stratégies: il peut être envisagé de combiner la stratégie de négociation de la grille avec d’autres types de stratégies, telles que la stratégie de tendance, la stratégie de régression moyenne, etc., afin d’améliorer l’adaptabilité et la stabilité de la stratégie.

  2. Amélioration des mécanismes d’ajustement dynamique: les mécanismes d’ajustement dynamique des stratégies actuelles sont relativement simples et peuvent être optimisés, par exemple en tenant compte de plus de facteurs (comme le trafic, les fluctuations, etc.) et en utilisant des algorithmes plus avancés (comme les algorithmes d’adaptation, les algorithmes d’apprentissage automatique, etc.).

  3. Optimisation de la gestion des fonds: la stratégie actuelle adopte une gestion équivalente des fonds. Des méthodes de gestion des fonds plus avancées, telles que la loi de Kelly, la méthode d’optimisation, etc., peuvent être envisagées pour améliorer encore l’efficacité de l’utilisation des fonds et les rendements.

  4. Introduction d’un stop-loss: Sur la base de la grille de négociation, il est possible d’introduire des logiques de stop-loss, telles que le stop-loss mobile, le stop-loss sur la volatilité, etc., afin de réduire davantage le risque stratégique.

Résumer

La stratégie de couverture des risques de la grille de négociation est une stratégie de négociation quantitative, hautement automatisée, adaptative et à risque contrôlable. Grâce à la négociation sur grille et à l’ajustement dynamique de la grille, la stratégie peut être rentable dans divers scénarios, tout en contrôlant les risques. Cependant, la stratégie peut être médiocre dans les scénarios de tendance et les frais de traitement peuvent avoir un impact sur les gains.

Code source de la stratégie
/*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)