Stratégie de trading de grille de la théorie océanique
ChaoZhang
Aperçu
La stratégie utilise la méthode de négociation de la grille de la théorie de l’océan, une grille de distribution uniforme dans la plage de prix définie, en fonction de la relation entre le prix et la grille. La stratégie comporte des caractéristiques telles que le calcul automatique de la plage de prix de la grille, une grille de distribution uniforme, etc., ce qui permet de contrôler efficacement les risques.
Principe de stratégie
La stratégie consiste d’abord à calculer les limites supérieures et inférieures de la grille de prix en fonction de la sélection ou de la configuration par défaut de l’utilisateur, c’est-à-dire le prix le plus élevé et le prix le plus bas de la grille. Il existe deux façons de calculer, la première est de trouver le prix le plus élevé et le prix le plus bas au cours d’un cycle de réévaluation, la seconde est de calculer la moyenne d’une certaine période.
La génération du signal de négociation dépend de la relation entre le prix et la grille. Lorsque le prix est inférieur à la grille inférieure, il y a un nombre fixe d’ouvertures de positions sur cette grille; lorsque le prix est supérieur à la grille supérieure, il y a un nombre fixe de liquidations sur cette grille. Ainsi, lorsque le prix fluctue, la position fluctue également dans la grille, ce qui permet de réaliser un profit.
Plus précisément, la stratégie maintient un tableau de prix de la grille et un tableau de bool indiquant si chaque grille a des enchères. Lorsque le prix est inférieur à une grille et que la grille n’a pas de enchères, le prix est plus élevé sur cette ligne; lorsque le prix est supérieur à une grille et que la grille en dessous a des enchères, la grille en dessous est à plat. De cette façon, la grille est négociée.
Avantages stratégiques
Le calcul automatique de l’espacement de la grille permet d’éviter les difficultés de réglage manuel.
Les lignes de la grille sont réparties uniformément pour éviter que la densité de la grille ne conduise à des transactions excessives. Le nombre de lignes de la grille est réglable.
La méthode de négociation en grille permet de maîtriser efficacement les risques, tandis que les fluctuations de prix à l’intérieur de la grille sont toujours rentables.
Il n’y a pas de direction prévue pour les prix, ce qui s’applique aux situations de choc.
Les frais de transaction et le nombre de positions peuvent être personnalisés pour s’adapter à différents types de transactions.
La ligne de grille est affichée visuellement, ce qui facilite la maîtrise des transactions.
Risque stratégique
Risque de rupture de l’intervalle entre les grilles. La rupture de la limite inférieure de la grille entraîne une augmentation des pertes.
Le risque d’un espacement de grille trop large. Un espacement de grille trop large est moins rentable, mais un espacement de grille trop étroit augmente les frais de traitement.
Le risque de détention trop longue. La détention trop longue est difficile à rentabiliser, mais augmente les frais de transaction.
Risque d’erreur de paramétrage. Une erreur de paramétrage, telle que la période de réévaluation ou la période de moyenne, peut affecter le calcul de la distance entre les grilles.
Le risque systémique du marché. Cette stratégie est mieux adaptée aux situations de choc plutôt qu’aux situations unilatérales à long terme.
Optimisation de la stratégie
Optimiser les paramètres de la grille. Prendre en compte des facteurs tels que les caractéristiques du marché, les coûts de transaction, optimiser le nombre de grilles, les périodes de retestation, etc.
La régularisation dynamique des zones de grille. Des mécanismes d’ajustement dynamique des zones de grille peuvent être introduits lorsque le marché change de manière significative.
Adhérer à un mécanisme de stop-loss. Définir une limite de stop-loss raisonnable pour éviter des pertes excessives. La limite de stop-loss peut également être ajustée dynamiquement.
Filtrez les transactions avec d’autres indicateurs, tels que les lignes de Brin, les indicateurs de tendance, etc., afin d’éviter les transactions inappropriées.
Optimisation de l’efficacité de l’utilisation des fonds. Ajout d’analyses à froid et à chaud pour réduire les transactions en cas de moindre volatilité.
Résumer
La stratégie utilise le principe de la grille de négociation pour réaliser des transactions sur des conditions de choc à risque contrôlable. La stratégie présente des avantages tels que la grille de calcul automatique, la grille de distribution uniforme, qui peut être adaptée à différents environnements de marché en ajustant les paramètres.
/*backtest
start: 2023-09-12 00:00:00
end: 2023-10-12 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
strategy.initial_capital = 50000
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
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)