Stratégie de négociation quantitative basée sur la tendance de la grille dynamique

Auteur:ChaoZhang est là., Date: 2024-03-22 16:03:09
Les étiquettes:

img

Résumé

Il s'agit d'une stratégie de négociation quantitative avancée basée sur la tendance de la grille dynamique. L'idée principale de cette stratégie est de diviser plusieurs lignes de grille dans une plage de prix prédéfinie et d'ouvrir automatiquement des positions lorsque le prix atteint les lignes de grille et de fermer des positions lors de la vente, profitant ainsi des marchés fluctuants.

Principe de stratégie

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

  1. Tout d'abord, déterminez les limites supérieures et inférieures de la grille et le nombre de lignes de grille en fonction des paramètres de l'utilisateur.

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

  3. Lorsque le prix atteint chaque ligne de grille, la stratégie vérifie si la position correspondant à la ligne de grille est déjà détenue.

  4. En vendant à des positions relativement élevées et en achetant à des positions basses, la stratégie peut générer continuellement des bénéfices lorsque les prix fluctuent.

  5. Dans le même temps, si l'utilisateur active la fonction d'ajustement automatique des limites, la position des lignes de la grille sera ajustée de manière adaptative en fonction des hauts et des bas prix récents ou de la moyenne mobile définie pour optimiser la disposition de la grille.

Grâce aux principes ci-dessus, cette stratégie peut réaliser automatiquement des achats bas et des ventes élevées dans les tendances fluctuantes des prix, et ajuster les points de profit en fonction des tendances, améliorant ainsi les rendements globaux.

Analyse des avantages

Cette stratégie de réseau dynamique présente les avantages suivants:

  1. Une forte adaptabilité: il peut s'adapter à différents marchés et variétés grâce à des paramètres et a une bonne adaptabilité aux fluctuations des marchés.

  2. Étant donné que la stratégie est basée sur une logique mathématique stricte et des points d'ouverture et de fermeture de position clairs, elle peut réaliser un trading entièrement automatisé et réduire les interférences émotionnelles subjectives.

  3. Risque contrôlable: en fixant des paramètres tels que le nombre de réseaux et les limites du réseau, l'exposition au risque de chaque transaction peut être contrôlée efficacement, ce qui permet de maintenir le risque global dans une fourchette acceptable.

  4. Adaptabilité à la tendance: la fonction d'ajustement dynamique des limites du réseau est ajoutée à la stratégie, de sorte que le réseau puisse suivre les tendances des prix et être optimisé, améliorant la rentabilité sur les marchés tendance.

  5. Étant donné que le trading sur réseau est essentiellement fréquent, avec des fluctuations de prix élevées et faibles, tant que le prix maintient ses fluctuations, cette stratégie peut continuer à générer des bénéfices, donc elle a un taux de gain élevé à long terme.

Analyse des risques

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

  1. Si le prix franchit la limite du réseau avec une forte tendance unilatérale, l'espace de profit de cette stratégie sera limité et il pourrait faire face à une forte retracement.

  2. Difficulté d'optimisation des paramètres. Cette stratégie a de nombreux paramètres, y compris le nombre de grilles, les limites initiales, les paramètres de limites dynamiques, etc. Différentes combinaisons de paramètres ont un grand impact sur les performances de la stratégie, et la difficulté d'optimisation réelle n'est pas petite.

  3. La stratégie de réseau est essentiellement une stratégie à haute fréquence, avec des ouvertures et fermetures de positions très fréquentes, ce qui signifie des coûts de transaction plus élevés et des risques potentiels de glissement.

  4. Une forte dépendance aux conditions du marché. Cette stratégie est fortement dépendante des fluctuations des marchés. Une fois que le prix entre dans une tendance unilatérale rapide, cette stratégie risque de faire face à un retracement important.

Compte tenu de ces risques, des améliorations peuvent être apportées dans les aspects suivants: ajout d'indicateurs de jugement de tendance comme conditions de filtrage pour le démarrage de la stratégie, optimisation de l'espace et des méthodes de recherche de paramètres, introduction d'une logique de gestion des fonds et de contrôle des positions, augmentation de la logique de clôture de la tendance, etc. Grâce à ces optimisations, la robustesse et la rentabilité de cette stratégie peuvent être encore améliorées.

Direction de l'optimisation

Sur la base de l'analyse ci-dessus, les orientations d'optimisation de cette stratégie comprennent principalement:

  1. Introduisez des conditions de filtrage de tendance. Ajoutez des indicateurs de jugement de tendance avant le début de la stratégie, tels que les moyennes mobiles, ADX, etc. Ne lancez la stratégie que dans des conditions de marché fluctuantes et surveillez les marchés tendance pour éviter efficacement le risque de retracement sur les marchés tendance.

  2. Optimiser la recherche de paramètres. Utiliser des algorithmes intelligents pour optimiser les paramètres de la grille, tels que les algorithmes génétiques, les algorithmes d'essaim de particules, etc., pour trouver automatiquement la combinaison optimale de paramètres et améliorer l'efficacité et la qualité de l'optimisation.

  3. Améliorer la logique de contrôle des risques. Ajouter plus de logique de contrôle des risques à la stratégie, comme ajuster dynamiquement la largeur de la grille en fonction de la volatilité des prix, définir le seuil de retracement maximum pour déclencher la fermeture, etc., pour mieux contrôler les risques.

  4. Introduisez un stop loss de tendance. Définissez une ligne de stop loss de rupture de tendance, telle qu'un certain pourcentage de la limite de la grille. Une fois que le prix franchit la ligne de stop loss, fermez toutes les positions pour éviter d'énormes retracements sur les marchés de tendance.

  5. Optimiser l'exécution des transactions. Optimiser le lien d'exécution des transactions, par exemple en adoptant des types d'ordres et des algorithmes d'ordres plus avancés, en minimisant la fréquence et les coûts des transactions et en améliorant l'efficacité de l'exécution.

Grâce à l'optimisation susmentionnée, l'adaptabilité, la robustesse et la rentabilité de cette stratégie peuvent être globalement améliorées, ce qui la rapproche des besoins réels du commerce.

Résumé

En général, cette stratégie de suivi de tendance dynamique de la grille est une stratégie de trading quantitative de moyenne à haute fréquence basée sur le principe du trading de la grille, et intègre des mécanismes d'ajustement dynamique et d'adaptation de tendance. Ses avantages résident dans une forte adaptabilité, un haut degré d'automatisation, un risque contrôlable, une bonne adaptabilité à la tendance et un taux de gain stable. En même temps, elle comporte également des risques tels que le risque de tendance, la difficulté d'optimisation des paramètres, le trading fréquent et une forte dépendance des conditions du marché.

L'idée même du trading par grille est une méthode quantitative relativement mature et pratique. Grâce à l'ajout de mécanismes d'optimisation dynamique et d'adaptation des tendances à cette stratégie, les avantages du trading par grille classique ont été étendus et développés. Il offre aux investisseurs une nouvelle idée de trading quantitatif et une possibilité dans les marchés fluctuants. Avec une optimisation et une amélioration supplémentaires, cette stratégie devrait devenir un excellent outil de trading quantitatif de moyenne à haute fréquence.


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







Plus de