Stratégie de négociation de réseaux intelligents adaptatifs

Auteur:ChaoZhang est là., Date: 2024-01-16 14:51:48 Je suis désolé
Les étiquettes:

Résumé

Cette stratégie est une stratégie de trading adaptative basée sur la plateforme TradingView, écrite en Pine Script v4. Elle se superpose sur le graphique de prix et crée une grille dans des limites spécifiées pour générer des signaux d'achat et de vente.

La logique de la stratégie

Principales caractéristiques

La pyramide et la gestion de l'argent
- Permet jusqu'à 14 ajouts dans le même sens (pyramides),
- Utilise une stratégie basée sur la trésorerie pour gérer la taille des positions,
- Le capital initial est fixé à 100 USD à des fins de simulation,
- Une petite commission de 0,1% est facturée pour chaque transaction.
Limites de la grille:
- Les utilisateurs peuvent choisir d'utiliser des limites calculées automatiquement ou définir manuellement les limites supérieure et inférieure de la grille,
- Les limites automatiques peuvent être dérivées du prix récent High & Low ou d'une moyenne mobile simple (SMA),
- Les utilisateurs peuvent définir la période de rétrospective pour le calcul des limites et ajuster l'écart pour élargir ou réduire les limites.
Les lignes de la grille:
- La stratégie prévoit un nombre personnalisable de lignes de réseau à l'intérieur des limites, avec une plage recommandée comprise entre 3 et 15,
- Les lignes de grille sont uniformément espacées entre les limites supérieure et inférieure.

La logique de la stratégie

Entrée:
- Le script place des ordres d'achat lorsque le prix tombe en dessous d'une ligne de grille et qu'aucun ordre existant n'est associé à cette ligne de grille.
- Chaque quantité d'ordre d'achat est calculée sur la base du capital initial divisé par le nombre de lignes de réseau, ajusté au prix courant.
Sortie:
- Les ordres de vente sont déclenchés lorsque le prix dépasse une ligne de grille, à condition qu'il y ait un ordre ouvert correspondant à la ligne inférieure de grille suivante.
Grille adaptative:
- S'il est réglé sur les limites automatiques, le réseau s'adapte aux conditions changeantes du marché en recalculant les limites supérieure et inférieure et en ajustant le réseau en conséquence.

Analyse des avantages

La stratégie intègre la nature systématique et l'exécution efficace du trading en réseau. Permettre la pyramide et utiliser la gestion de l'argent peut contrôler efficacement les risques. La grille d'adaptation automatique s'adapte aux différentes conditions du marché. Les paramètres réglables répondent à différents styles de trading.

Analyse des risques

Une rupture de prix au-delà des limites du réseau peut entraîner de graves pertes. Les paramètres doivent être ajustés correctement ou combinés avec un stop loss pour contrôler les risques.

Directions d'optimisation

Un stop loss peut également aider à prévenir les risques liés aux mouvements extrêmes du marché.

Conclusion

Cette stratégie génère systématiquement des entrées et des sorties tout en gérant les positions. Grâce au réglage des paramètres, elle s'adapte à différentes préférences. Elle combine la nature basée sur des règles du trading de grille avec la flexibilité du trading de tendance, facilitant la complexité de l'opération tout en conservant la robustesse.

/*backtest
start: 2024-01-08 00:00:00
end: 2024-01-15 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)

Plus de

2019 FMZ - Tous les droits réservés