Basé sur une stratégie de grille dynamique adaptative long-court


Date de création: 2024-03-19 14:19:12 Dernière modification: 2024-03-19 14:19:28
Copier: 0 Nombre de clics: 925
1
Suivre
1617
Abonnés

Basé sur une stratégie de grille dynamique adaptative long-court

Aperçu

Il s’agit d’une stratégie de négociation de grille dynamique auto-adaptative multicolore écrite à base de Pine Script. L’idée centrale de cette stratégie est de calculer automatiquement la limite supérieure et inférieure d’une grille en fonction des hauts et des bas des prix les plus récents ou des moyennes mobiles simples, puis de diviser cette plage en plusieurs lignes de grille.

Principe de stratégie

  1. Calculer la limite supérieure et inférieure de la grille. Selon le choix de l’utilisateur, la limite supérieure et inférieure peut être basée sur les points les plus élevés et les plus bas de la ligne N à la racine K la plus proche, et peut être réglée pour agrandir ou réduire le pourcentage; ou peut être basée sur la moyenne mobile simple du prix de clôture de la ligne N à la racine K la plus proche, et peut être réglée pour un écart supérieur et inférieur.

  2. Générer un tableau de lignes de grille. Partagez la portée de la grille en fonction du nombre de lignes de grille mises en place et générez un tableau de lignes de grille correspondant au prix.

  3. Entrée / mise en position. Traverse la grille de bas en haut. Si le prix de clôture actuel est inférieur au prix d’une grille et que cette grille n’a pas encore de position, ouvre un ordre à cet endroit.

  4. Sortie/dépréciation. Traversez la grille de haut en bas. Si le prix de clôture actuel est supérieur au prix d’une grille et que la grille inférieure a une position, éliminez le polynôme de la grille inférieure. Ainsi, la dépréciation se poursuit lorsque le prix revient.

  5. Adaptation dynamique. Si vous choisissez la fonction de grille dynamique, chaque ligne K recompte les limites supérieures et inférieures de la grille et l’arrangement des lignes de la grille, ce qui permet à la grille de s’adapter en permanence aux changements de situation.

Analyse des avantages

  1. La stratégie de négociation de grille est adaptée aux chocs et aux tendances. Dans les conditions de choc, la stratégie de grille peut continuer à ouvrir des positions faibles et à tirer profit des écarts de prix. Dans les conditions de tendance, la stratégie de grille peut également maintenir une certaine position et obtenir des gains de tendance en suivant le mouvement des prix.

  2. Le risque est contrôlable. La taille de la position à chaque ouverture est déterminée par le nombre de grilles mises en place, l’ouverture de risque unique est petite et contrôlable. En outre, la position est compensée par une certaine protection contre les pertes potentielles, car le prix touche la grille supérieure.

  3. La stratégie est basée sur l’automatisation et ne nécessite aucune intervention humaine, ce qui convient aux investisseurs qui souhaitent des rendements stables à long terme.

  4. La flexibilité des paramètres. L’utilisateur peut adapter le nombre de lignes de grille en fonction des caractéristiques du marché, des paramètres de grille dynamiques, etc. afin d’optimiser la performance de la stratégie.

Analyse des risques

  1. Risque de l’échine noire. Si le cours plonge au-dessus de la ligne de la grille la plus basse, la stratégie risque d’être remplie et de faire face à un retrait plus important. Pour réduire ce risque, il est possible de définir des conditions d’arrêt de perte et de vider la position entière une fois que les pertes atteignent la valeur de la perte.

  2. Les paramètres de la grille ne sont pas correctement configurés. Si la grille est trop dense, la différence de prix pour chaque ouverture de position est faible et les frais de traitement peuvent éroder la majeure partie des bénéfices. Si la grille est trop large, le taux de prise de position unique est élevé et la marge de risque est grande.

  3. Le risque de décalage de base. La stratégie est basée sur les conditions d’ouverture d’une position claire au prix actuel. Dans les marchés tels que les contrats à terme, si le prix du contrat diffère beaucoup du prix de référence, le prix d’ouverture de la position claire réelle peut être plus éloigné de l’attente.

Direction d’optimisation

  1. Ajouter un filtre de tendance. La stratégie de grille ne fonctionne pas bien dans la tendance unilatérale. L’indicateur de tendance peut être ajouté comme filtre, par exemple, en activant la grille uniquement lorsque l’ADX est inférieur à une certaine barre, et en la fermant lorsque la tendance est évidente, en ne détenant que des positions unilatérales.

  2. Optimisation des signaux. Il est possible de superposer d’autres signaux sur la base de la grille, comme la grille + la ligne moyenne, c’est-à-dire que la grille décide principalement d’ouvrir une position de creusement, mais d’ouvrir la position lorsque le prix traverse une certaine ligne moyenne, sinon il n’est pas ouvert.

  3. Gestion des positions. La position par tranche de la stratégie actuelle est fixe. Elle peut être ajustée de manière à réduire la position par tranche lorsque le prix est éloigné du prix moyen du marché et à augmenter la position lorsque le prix est proche du prix moyen du marché, ce qui améliore l’efficacité de l’utilisation des fonds.

  4. Adapter la densité de la grille. Ajuster la densité de la grille en fonction de la volatilité des prix. Augmenter le nombre de grilles lorsque la volatilité est élevée et réduire le nombre de grilles lorsque la volatilité est faible.

Résumer

Cette stratégie est une stratégie de quantification à moyen et long terme très adaptative, grâce à une grille dynamique adaptative, capable de prendre des gains de tendance en cas de volatilité et de maintenir une certaine direction de rupture en cas de tendance. La logique de déclenchement et la gestion de la position de la grille sont raisonnablement configurées, ce qui permet d’obtenir des gains solides.

Code source de la stratégie
// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © jcloyd

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