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

Stratégie de négociation de cryptomonnaie adaptative basée sur l'arbitrage

Auteur:ChaoZhang est là., Date: 19 janvier 2024 14:17:50
Les étiquettes:

Résumé

Il s'agit d'une stratégie de négociation de crypto-monnaie adaptative basée sur la méthodologie de négociation de la grille pour l'arbitrage. Il peut ajuster automatiquement la fourchette de prix du trading de la grille en fonction des fluctuations du marché et mener une négociation d'arbitrage efficace dans cette fourchette de prix.

Principe de stratégie

L'idée de base de cette stratégie est la suivante:

Calculer dynamiquement une fourchette de prix de la grille de négociation sur la base des prix historiques élevés et bas.
Définir N lignes de grille à intervalles égaux dans cette fourchette de prix.
Lorsque le prix franchit chaque ligne de la grille, ouvrez des positions longues ou courtes avec une quantité fixe.
L'arbitrage entre les lignes de grille adjacentes et les positions fermées pour le profit.
Lorsque le prix rentre dans la fourchette, continuer à ouvrir des positions au coût marginal des lignes de réseau.
Répétez ce cycle pour les opérations d'arbitrage à haute fréquence dans la fourchette de prix du réseau.

Plus précisément, la stratégie calcule d'abord les limites supérieures et inférieures de la grille en temps réel en fonction des paramètres de la fenêtre de rétrospective configurée (i_boundLookback) et de la plage de volatilité (i_boundDev).

Ensuite, les N lignes de grille (i_gridQty) sont réparties uniformément entre les limites supérieure et inférieure.

Lorsque le prix franchit une ligne de grille, une quantité fixe (capital stratégique divisé par le nombre de grilles) est utilisée pour ouvrir des positions longues ou courtes.

Lorsque le prix franchit à nouveau la ligne de la grille adjacente, il peut être associé à des ordres antérieurs d'arbitrage et de fermeture de positions pour un profit.

Répétez ce cycle pour l'arbitrage à haute fréquence dans la fourchette de fluctuation des prix.

Analyse des avantages

Par rapport aux stratégies de réseau traditionnelles, le plus grand avantage de cette stratégie est que la plage de réseau est automatiquement ajustée pour s'adapter aux fluctuations du marché, avec les caractéristiques suivantes:

Entièrement automatisé, pas besoin d'intervention manuelle.
Capable de détecter les tendances des prix et de négocier dans la direction de la tendance.
Des risques maîtrisables, évitant les risques de poursuite unilatéraux.
Fréquence de négociation élevée et marge de profit.
Facile à comprendre, configuration simple.
Une utilisation élevée du capital, pas facile à piéger.
Réfléchir aux changements du marché en temps réel, adapté au trading algorithmique.

Analyse des risques

Bien que la stratégie présente de nombreux avantages, elle comporte également certains risques, principalement concentrés dans les domaines suivants:

Potentiel de pertes plus importantes en cas de fluctuations extrêmes des prix.
Requiert une période de détention et une paire de négociation appropriées pour réaliser des bénéfices.
L'échelle de capital doit correspondre à la fourchette de volatilité.
Peut nécessiter une surveillance et une optimisation fréquentes des paramètres.

Les contre-mesures comprennent:

Augmenter l'espacement de la grille pour élargir la portée de la grille.
Choisissez des paires de trading plus stables.
Ajuster l'échelle de fonds propres pour assurer une liquidité suffisante.
Mettre en place des mécanismes automatiques de surveillance et d'alerte.

Directions d'optimisation

La stratégie peut être optimisée dans les aspects suivants:

Grille dynamique: ajuste automatiquement les paramètres du réseau en fonction de la volatilité.
Mécanisme de rupture: définir des emplacements de stop loss raisonnables pour limiter les risques extrêmes.
Grille composée: combiner des grilles utilisant différents paramètres pour différentes périodes afin de maximiser l'utilisation du temps.
Apprentissage automatique: utiliser les réseaux de neurones pour optimiser automatiquement les paramètres au lieu des règles.
Arbitrage transfrontalier: arbitrage entre bourses ou paires de devises.

Résumé

En résumé, il s'agit d'une stratégie de trading de grille cryptographique très pratique pour l'arbitrage. Par rapport aux stratégies de grille traditionnelles, sa plus grande caractéristique est l'ajustement automatique de la plage de grille en fonction des changements du marché, permettant aux traders de configurer leur propre plage de trading.

/*backtest
start: 2024-01-11 00:00:00
end: 2024-01-18 00:00:00
period: 1m
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