Stratégie de trading quantitatif suivant la tendance de la grille dynamique


Date de création: 2024-03-22 16:03:09 Dernière modification: 2024-03-22 16:03:09
Copier: 0 Nombre de clics: 1231
1
Suivre
1617
Abonnés

Stratégie de trading quantitatif suivant la tendance de la grille dynamique

Aperçu

Il s’agit d’une stratégie de trading quantitative de suivi de tendances de grille dynamique avancée. L’idée principale de cette stratégie est de diviser plusieurs lignes de grille dans des intervalles de prix prédéfinis et de faire automatiquement des achats et des ventes en position de marché lorsque les prix touchent les lignes de grille, afin de tirer profit des conditions de choc.

Principe de stratégie

Les principes fondamentaux de cette stratégie sont les suivants:

  1. Tout d’abord, en fonction des paramètres de l’utilisateur, les limites supérieures et inférieures de la grille et le nombre de lignes de la grille sont déterminés. Les limites peuvent être des valeurs fixes ou peuvent être calculées automatiquement en fonction des hauts et des bas des dernières heures ou des moyennes mobiles.

  2. Dans les limites définies, divisez la fourchette en plusieurs grilles. Chaque ligne de la grille correspond à un prix d’achat ou de vente.

  3. Chaque fois que le prix touche la grille, la stratégie vérifie si une position correspondant à cette grille est déjà détenue. Si aucune position n’est détenue, la position est achetée.

  4. En vendant à des prix relativement élevés et en achetant à des prix relativement bas, la stratégie permet de continuer à profiter des fluctuations des prix.

  5. Par ailleurs, si l’utilisateur a activé la fonction d’ajustement automatique des frontières, la position de la grille s’ajuste automatiquement en fonction des hauts et des bas des prix récents ou de la moyenne mobile définie, afin d’optimiser la disposition de la grille.

Grâce aux principes ci-dessus, la stratégie permet d’acheter ou de vendre automatiquement dans des conditions de volatilité des prix et d’ajuster les positions d’avantage en fonction de la tendance, ce qui améliore les gains globaux.

Analyse des avantages

La stratégie de la grille dynamique présente les avantages suivants:

  1. Il est très adaptable aux chocs. Il peut s’adapter à différents marchés et variétés par paramètres.

  2. La stratégie étant basée sur une logique mathématique rigoureuse, le point d’arrêt de la position est clairement défini, ce qui permet une négociation entièrement automatisée et réduit les interférences d’émotions subjectives.

  3. Le risque est contrôlable. En réglant le nombre de grilles, les limites de grilles et autres paramètres, l’ouverture de risque de chaque transaction peut être efficacement contrôlée, ce qui maintient le risque global dans une plage acceptable.

  4. Adaptabilité aux tendances. La stratégie intègre la fonction d’ajustement dynamique des frontières de la grille, permettant à la grille de suivre les tendances des prix et d’être optimisée, ce qui améliore la rentabilité dans des conditions de tendances.

  5. Le taux de victoire est stable. Comme la grille de négociation est essentiellement une stratégie de fluctuation fréquente des prix, la stratégie peut être rentable aussi longtemps que les prix se maintiennent dans la volatilité, et a donc un taux de victoire élevé sur le long terme.

Analyse des risques

Bien que cette stratégie présente des avantages évidents, elle comporte aussi des risques:

  1. Le risque de tendance. Si le prix fait une forte tendance unilatérale à franchir les bornes de la grille, l’espace de profit de la stratégie sera limité et pourrait faire face à un retrait plus important.

  2. Les paramètres sont très difficiles à optimiser. La stratégie a de nombreux paramètres, y compris le nombre de grilles, les limites initiales, les paramètres de bordures dynamiques, etc. Les différentes combinaisons de paramètres ont une grande influence sur la performance de la stratégie et la difficulté d’optimisation réelle n’est pas faible.

  3. La stratégie de grille est essentiellement une stratégie à haute fréquence, avec une très grande fréquence de placement, ce qui implique des coûts de transaction plus élevés et un risque potentiel de glissement.

  4. La stratégie est fortement tributaire des tendances choquantes et est susceptible de faire face à des retraits plus importants une fois que les prix entrent dans une tendance unilatérale rapide.

Pour répondre à ces risques, des améliorations peuvent être apportées en ajoutant des indicateurs de jugement de tendance comme conditions de filtrage pour le lancement de la stratégie, en optimisant l’espace et la méthode de recherche de paramètres, en introduisant une logique de gestion de fonds et de contrôle de position, en augmentant la logique de rupture de position de tendance. Grâce à ces optimisations, la robustesse et la rentabilité de la stratégie peuvent être encore améliorées.

Direction d’optimisation

Sur la base de ces analyses, la stratégie devrait être optimisée pour:

  1. Introduire des conditions de filtrage de tendance. Ajouter des indicateurs de jugement de tendance, tels que les moyennes mobiles, l’ADX, etc., avant le lancement de la stratégie.

  2. Optimisation de la recherche de paramètres. L’utilisation d’algorithmes intelligents pour optimiser les paramètres de la grille, tels que l’algorithme génétique, l’algorithme de groupe de particules, etc., permet de trouver automatiquement la combinaison optimale de paramètres, ce qui améliore l’efficacité et la qualité de l’optimisation.

  3. Augmentation de la logique de contrôle des risques. Ajouter plus de logiques de contrôle des risques à la stratégie, telles que l’ajustement dynamique de la largeur de la grille en fonction de la volatilité des prix, la définition d’une limite de retrait maximale pour déclencher une position de nivellement, etc., afin de mieux contrôler les risques.

  4. Introduction d’un arrêt de tendance. La mise en place d’un arrêt de tendance, tel qu’un certain pourcentage de la frontière de la grille, une fois que le prix a franchi le seuil d’arrêt, la position est complètement à plat, évitant ainsi un grand retrait de la tendance.

  5. Optimisation de l’exécution des transactions. Optimisation des étapes d’exécution des transactions, telles que l’utilisation d’algorithmes de conditions et d’ordres plus avancés, afin de réduire la fréquence et les coûts des transactions et d’améliorer l’efficacité de l’exécution.

Grâce à ces optimisations, il est possible d’améliorer globalement l’adaptabilité, la robustesse et la rentabilité de la stratégie, afin de la rendre plus proche des besoins du marché.

Résumer

Dans l’ensemble, la stratégie de suivi des tendances de la grille dynamique est une stratégie de négociation de moyenne et haute fréquence basée sur le principe de négociation de la grille, intégrant à la fois un mécanisme d’ajustement dynamique et d’adaptation à la tendance. Ses avantages sont sa forte adaptabilité, son haut degré d’automatisation, sa maîtrise des risques, sa bonne adaptabilité à la tendance et sa stabilité du taux de victoire, mais il existe également des risques importants tels que le risque de tendance, la difficulté d’optimisation des paramètres, la fréquence des transactions et la dépendance aux conditions de la conduite.

La méthode de trading à grille est elle-même une méthode de quantification relativement mature et pratique. Les avantages de la méthode classique de trading à grille ont été étendus et développés grâce à l’optimisation dynamique de la stratégie et à l’ajout de mécanismes d’adaptation aux tendances.

Code source de la stratégie
/*backtest
start: 2024-03-01 00:00:00
end: 2024-03-21 00:00:00
period: 1h
basePeriod: 15m
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)