Les ressources ont été chargées... Je charge...

Stratégie de négociation en réseau quantique auto-adaptatif

Auteur:ChaoZhang est là., Date: 2024-02-02 18h08 et 22h
Les étiquettes:

Résumé

Cette stratégie établit une grille de négociation dynamique pour réaliser des profits réguliers au milieu de marchés volatils. Elle calcule automatiquement l'espacement de la grille et la limite supérieure / inférieure en fonction du nombre prédéfini de lignes de grille. Lorsque le prix traverse chaque ligne de grille, des positions longues / courtes seront construites en lots. Les profits seront réalisés lorsque le prix atteint à nouveau les lignes de grille d'origine. La stratégie prend en charge à la fois l'ajustement manuel et automatique des paramètres de la grille pour s'adapter aux conditions changeantes du marché.

La logique de la stratégie

Calculer les limites du réseau et le tableau des prix des lignes de réseau sur la base des paramètres d'entrée.
Lorsque le prix tombe en dessous d'une ligne de grille sans ordres correspondants, les ordres longs seront placés au prix de la ligne de grille. Lorsque le prix dépasse la ligne de grille précédente (la première exclue) avec la position existante, les ordres longs de la ligne précédente seront fermés.
Si le réglage automatique est activé, les limites supérieures/inférieures de la grille, l'espacement de la grille et les tableaux de grille seront régulièrement recalculés sur la base des données récentes du chandelier.

Analyse des avantages

Réaliser des bénéfices stables dans un marché volatil. Les positions longues/courtes sont construites et fermées par lots à différents niveaux de prix pour réaliser un profit global.
Prise en charge du réglage manuel et automatique des paramètres. Le réglage manuel offre un meilleur contrôle mais nécessite une intervention. Le réglage automatique réduit la charge de travail et s'adapte à l'évolution de la dynamique du marché.
Lorsque le prix dépasse toutes les lignes du réseau, les risques sont contenus.
Ajustez l'espacement de la grille pour ajuster les profits/pertes par transaction.

Analyse des risques

Le risque d'être pris au piège dans un coup de fouet: les oscillations fréquentes des prix dans la plage de la grille peuvent entraîner des pertes.
Il faut un capital initial adéquat, car un financement insuffisant ne peut pas soutenir suffisamment de lignes de réseau.
Les chiffres extrêmes des grilles désavantagent les profits. Trop peu de grilles ne parviennent pas à tirer pleinement parti de la volatilité tandis que trop de grilles conduisent à des profits minimes par transaction. Des tests approfondis sont nécessaires pour déterminer les paramètres optimaux.
L'ajustement automatique risque la manipulation des prix.

Optimisation

Introduire une logique de stop-loss telle que le stop-loss de suivi pour restreindre davantage le risque à la baisse par direction.
Optimiser les paramètres de grille via l'apprentissage automatique. Tester différents paramètres dans les conditions du marché et former des modèles ML pour obtenir des paramètres optimaux et adaptatifs.
Incorporer des indicateurs techniques supplémentaires. Évaluer la force de la tendance actuelle avec des indicateurs tels que le MACD et le RSI pour guider la quantité de grille et le réglage des paramètres.
Améliorer le contrôle des risques en fixant le pourcentage maximal admissible de retrait. Désactiver la stratégie lorsque le seuil est dépassé pour éviter de nouvelles pertes.

Conclusion

Cette stratégie utilise pleinement les caractéristiques des marchés volatils et réalise des bénéfices stables grâce à un cadre de négociation dynamique de la grille qui offre à la fois une flexibilité des paramètres et une facilité d'utilisation.

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

2019 FMZ - Tous les droits réservés